/**
 * @license
 * Copyright 2025 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */
import { loadSettings } from '../../config/settings.js';
import { MCPServerStatus, createTransport } from '@google/gemini-cli-core';
import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { ExtensionStorage, loadExtensions } from '../../config/extension.js';
import { ExtensionEnablementManager } from '../../config/extensions/extensionEnablement.js';
const COLOR_GREEN = '\u001b[32m';
const COLOR_YELLOW = '\u001b[33m';
const COLOR_RED = '\u001b[31m';
const RESET_COLOR = '\u001b[0m';
async function getMcpServersFromConfig() {
    const settings = loadSettings();
    const extensions = loadExtensions(new ExtensionEnablementManager(ExtensionStorage.getUserExtensionsDir()));
    const mcpServers = { ...(settings.merged.mcpServers || {}) };
    for (const extension of extensions) {
        Object.entries(extension.mcpServers || {}).forEach(([key, server]) => {
            if (mcpServers[key]) {
                return;
            }
            mcpServers[key] = {
                ...server,
                extensionName: extension.name,
            };
        });
    }
    return mcpServers;
}
async function testMCPConnection(serverName, config) {
    const client = new Client({
        name: 'mcp-test-client',
        version: '0.0.1',
    });
    let transport;
    try {
        // Use the same transport creation logic as core
        transport = await createTransport(serverName, config, false);
    }
    catch (_error) {
        await client.close();
        return MCPServerStatus.DISCONNECTED;
    }
    try {
        // Attempt actual MCP connection with short timeout
        await client.connect(transport, { timeout: 5000 }); // 5s timeout
        // Test basic MCP protocol by pinging the server
        await client.ping();
        await client.close();
        return MCPServerStatus.CONNECTED;
    }
    catch (_error) {
        await transport.close();
        return MCPServerStatus.DISCONNECTED;
    }
}
async function getServerStatus(serverName, server) {
    // Test all server types by attempting actual connection
    return await testMCPConnection(serverName, server);
}
export async function listMcpServers() {
    const mcpServers = await getMcpServersFromConfig();
    const serverNames = Object.keys(mcpServers);
    if (serverNames.length === 0) {
        console.log('No MCP servers configured.');
        return;
    }
    console.log('Configured MCP servers:\n');
    for (const serverName of serverNames) {
        const server = mcpServers[serverName];
        const status = await getServerStatus(serverName, server);
        let statusIndicator = '';
        let statusText = '';
        switch (status) {
            case MCPServerStatus.CONNECTED:
                statusIndicator = COLOR_GREEN + '✓' + RESET_COLOR;
                statusText = 'Connected';
                break;
            case MCPServerStatus.CONNECTING:
                statusIndicator = COLOR_YELLOW + '…' + RESET_COLOR;
                statusText = 'Connecting';
                break;
            case MCPServerStatus.DISCONNECTED:
            default:
                statusIndicator = COLOR_RED + '✗' + RESET_COLOR;
                statusText = 'Disconnected';
                break;
        }
        let serverInfo = `${serverName}: `;
        if (server.httpUrl) {
            serverInfo += `${server.httpUrl} (http)`;
        }
        else if (server.url) {
            serverInfo += `${server.url} (sse)`;
        }
        else if (server.command) {
            serverInfo += `${server.command} ${server.args?.join(' ') || ''} (stdio)`;
        }
        console.log(`${statusIndicator} ${serverInfo} - ${statusText}`);
    }
}
export const listCommand = {
    command: 'list',
    describe: 'List all configured MCP servers',
    handler: async () => {
        await listMcpServers();
    },
};
//# sourceMappingURL=list.js.map