@juspay/neurolink 7.1.0 → 7.2.0

package/dist/cli/commands/mcp.js

@@ -0,0 +1,916 @@
+/**
+ * MCP CLI Commands for NeuroLink
+ * Implements comprehensive MCP server management commands
+ * Part of Phase 4.2 - MCP CLI Commands
+ */
+import { NeuroLink } from "../../lib/neurolink.js";
+import { logger } from "../../lib/utils/logger.js";
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs";
+import path from "path";
+/**
+ * Popular MCP servers registry
+ */
+const POPULAR_MCP_SERVERS = {
+    filesystem: {
+        command: "npx",
+        args: [
+            "-y",
+            "@modelcontextprotocol/server-filesystem",
+            "/path/to/allowed/files",
+        ],
+        transport: "stdio",
+        description: "File system operations (read, write, create, list directories)",
+    },
+    github: {
+        command: "npx",
+        args: ["-y", "@modelcontextprotocol/server-github"],
+        env: { GITHUB_PERSONAL_ACCESS_TOKEN: "${GITHUB_PERSONAL_ACCESS_TOKEN}" },
+        transport: "stdio",
+        description: "GitHub repository management and file operations",
+    },
+    postgres: {
+        command: "npx",
+        args: ["-y", "@modelcontextprotocol/server-postgres"],
+        env: { DATABASE_URL: "${DATABASE_URL}" },
+        transport: "stdio",
+        description: "PostgreSQL database query and management",
+    },
+    sqlite: {
+        command: "npx",
+        args: ["-y", "@modelcontextprotocol/server-sqlite", "/path/to/database.db"],
+        transport: "stdio",
+        description: "SQLite database operations and queries",
+    },
+    brave: {
+        command: "npx",
+        args: ["-y", "@modelcontextprotocol/server-brave-search"],
+        env: { BRAVE_API_KEY: "${BRAVE_API_KEY}" },
+        transport: "stdio",
+        description: "Brave Search API for web search capabilities",
+    },
+    puppeteer: {
+        command: "npx",
+        args: ["-y", "@modelcontextprotocol/server-puppeteer"],
+        transport: "stdio",
+        description: "Web scraping and browser automation",
+    },
+    git: {
+        command: "npx",
+        args: ["-y", "@modelcontextprotocol/server-git"],
+        transport: "stdio",
+        description: "Git repository operations and version control",
+    },
+    memory: {
+        command: "npx",
+        args: ["-y", "@modelcontextprotocol/server-memory"],
+        transport: "stdio",
+        description: "Persistent memory and knowledge storage",
+    },
+};
+/**
+ * Convert SDK MCPStatus to CLI format with server list
+ */
+function convertMCPStatusForCLI(status, // Use flexible object type
+sdk) {
+    // Create server list from in-memory servers and discovered servers
+    const servers = [];
+    // Add in-memory servers
+    const inMemoryServers = sdk.getInMemoryServers();
+    inMemoryServers.forEach((config, name) => {
+        servers.push({
+            name,
+            connected: true, // In-memory servers are always "connected"
+            description: config.server?.title || "In-memory MCP server",
+            tools: [], // Could extract from config.server.tools if needed
+        });
+    });
+    // Add auto-discovered servers
+    if (status.autoDiscoveredServers &&
+        Array.isArray(status.autoDiscoveredServers)) {
+        status.autoDiscoveredServers.forEach((server) => {
+            servers.push({
+                name: server.name || server.id,
+                connected: server.status === "connected",
+                description: server.source
+                    ? `Auto-discovered from ${server.source}`
+                    : `Auto-discovered server`,
+                tools: [],
+                error: server.status === "failed"
+                    ? "Connection failed"
+                    : undefined,
+            });
+        });
+    }
+    return {
+        mcpInitialized: status.mcpInitialized,
+        totalServers: status.totalServers,
+        availableServers: status.availableServers,
+        autoDiscoveredCount: status.autoDiscoveredCount,
+        totalTools: status.totalTools,
+        customToolsCount: status.customToolsCount,
+        inMemoryServersCount: status.inMemoryServersCount,
+        error: status.error,
+        servers,
+    };
+}
+/**
+ * MCP CLI command factory
+ */
+export class MCPCommandFactory {
+    /**
+     * Create the main MCP command with subcommands
+     */
+    static createMCPCommands() {
+        return {
+            command: "mcp <subcommand>",
+            describe: "Manage Model Context Protocol (MCP) servers",
+            builder: (yargs) => {
+                return yargs
+                    .command("list", "List configured MCP servers with status", (yargs) => this.buildListOptions(yargs), (argv) => this.executeList(argv))
+                    .command("install <server>", "Install popular MCP servers", (yargs) => this.buildInstallOptions(yargs), (argv) => this.executeInstall(argv))
+                    .command("add <name> <command>", "Add custom MCP server configuration", (yargs) => this.buildAddOptions(yargs), (argv) => this.executeAdd(argv))
+                    .command("test [server]", "Test connectivity to MCP servers", (yargs) => this.buildTestOptions(yargs), (argv) => this.executeTest(argv))
+                    .command("exec <server> <tool>", "Execute tools from MCP servers", (yargs) => this.buildExecOptions(yargs), (argv) => this.executeExec(argv))
+                    .command("remove <server>", "Remove MCP server configuration", (yargs) => this.buildRemoveOptions(yargs), (argv) => this.executeRemove(argv))
+                    .option("format", {
+                    choices: ["table", "json", "compact"],
+                    default: "table",
+                    description: "Output format",
+                })
+                    .option("output", {
+                    type: "string",
+                    description: "Save output to file",
+                })
+                    .option("quiet", {
+                    type: "boolean",
+                    alias: "q",
+                    default: false,
+                    description: "Suppress non-essential output",
+                })
+                    .option("debug", {
+                    type: "boolean",
+                    default: false,
+                    description: "Enable debug output",
+                })
+                    .demandCommand(1, "Please specify an MCP subcommand")
+                    .help();
+            },
+            handler: () => {
+                // No-op handler as subcommands handle everything
+            },
+        };
+    }
+    /**
+     * Create discover command (top-level command)
+     */
+    static createDiscoverCommand() {
+        return {
+            command: "discover",
+            describe: "Auto-discover MCP servers from various sources",
+            builder: (yargs) => {
+                return yargs
+                    .option("auto-install", {
+                    type: "boolean",
+                    default: false,
+                    description: "Automatically install discovered servers",
+                })
+                    .option("source", {
+                    choices: ["claude-desktop", "vscode", "all"],
+                    default: "all",
+                    description: "Source to discover servers from",
+                })
+                    .option("format", {
+                    choices: ["table", "json", "compact"],
+                    default: "table",
+                    description: "Output format",
+                })
+                    .option("quiet", {
+                    type: "boolean",
+                    alias: "q",
+                    default: false,
+                    description: "Suppress non-essential output",
+                })
+                    .example("neurolink discover", "Discover MCP servers from all sources")
+                    .example("neurolink discover --source claude-desktop", "Discover from Claude Desktop only")
+                    .example("neurolink discover --auto-install", "Discover and auto-install servers");
+            },
+            handler: async (argv) => await MCPCommandFactory.executeDiscover(argv),
+        };
+    }
+    /**
+     * Build options for list command
+     */
+    static buildListOptions(yargs) {
+        return yargs
+            .option("status", {
+            type: "boolean",
+            default: false,
+            description: "Check server connection status",
+        })
+            .option("detailed", {
+            type: "boolean",
+            default: false,
+            description: "Show detailed server information",
+        })
+            .example("neurolink mcp list", "List all configured MCP servers")
+            .example("neurolink mcp list --status", "List servers with connection status")
+            .example("neurolink mcp list --detailed", "Show detailed server information");
+    }
+    /**
+     * Build options for install command
+     */
+    static buildInstallOptions(yargs) {
+        return yargs
+            .positional("server", {
+            type: "string",
+            description: "Server name to install from popular registry",
+            choices: Object.keys(POPULAR_MCP_SERVERS),
+            demandOption: true,
+        })
+            .option("transport", {
+            choices: ["stdio", "sse", "ws"],
+            default: "stdio",
+            description: "Transport type for MCP communication",
+        })
+            .option("args", {
+            type: "array",
+            description: "Additional arguments for the server command",
+        })
+            .option("env", {
+            type: "string",
+            description: "Environment variables as JSON string",
+        })
+            .example("neurolink mcp install filesystem", "Install filesystem MCP server")
+            .example("neurolink mcp install github", "Install GitHub MCP server")
+            .example("neurolink mcp install postgres", "Install PostgreSQL MCP server");
+    }
+    /**
+     * Build options for add command
+     */
+    static buildAddOptions(yargs) {
+        return yargs
+            .positional("name", {
+            type: "string",
+            description: "Name for the custom MCP server",
+            demandOption: true,
+        })
+            .positional("command", {
+            type: "string",
+            description: "Command to execute the MCP server",
+            demandOption: true,
+        })
+            .option("transport", {
+            choices: ["stdio", "sse", "ws"],
+            default: "stdio",
+            description: "Transport type for MCP communication",
+        })
+            .option("args", {
+            type: "array",
+            description: "Arguments for the server command",
+        })
+            .option("env", {
+            type: "string",
+            description: "Environment variables as JSON string",
+        })
+            .example("neurolink mcp add my-server node", "Add custom Node.js MCP server")
+            .example("neurolink mcp add api-server python", "Add custom Python MCP server");
+    }
+    /**
+     * Build options for test command
+     */
+    static buildTestOptions(yargs) {
+        return yargs
+            .positional("server", {
+            type: "string",
+            description: "Server name to test (optional - tests all if not specified)",
+        })
+            .option("timeout", {
+            type: "number",
+            default: 10000,
+            description: "Test timeout in milliseconds",
+        })
+            .example("neurolink mcp test", "Test all configured servers")
+            .example("neurolink mcp test filesystem", "Test specific server")
+            .example("neurolink mcp test --timeout 5000", "Test with custom timeout");
+    }
+    /**
+     * Build options for exec command
+     */
+    static buildExecOptions(yargs) {
+        return yargs
+            .positional("server", {
+            type: "string",
+            description: "MCP server name",
+            demandOption: true,
+        })
+            .positional("tool", {
+            type: "string",
+            description: "Tool name to execute",
+            demandOption: true,
+        })
+            .option("params", {
+            type: "string",
+            description: "Tool parameters as JSON string",
+        })
+            .example("neurolink mcp exec filesystem read_file", "Execute read_file tool")
+            .example("neurolink mcp exec github list_repos", "Execute GitHub list_repos tool");
+    }
+    /**
+     * Build options for remove command
+     */
+    static buildRemoveOptions(yargs) {
+        return yargs
+            .positional("server", {
+            type: "string",
+            description: "Server name to remove",
+            demandOption: true,
+        })
+            .option("force", {
+            type: "boolean",
+            default: false,
+            description: "Force removal without confirmation",
+        })
+            .example("neurolink mcp remove filesystem", "Remove filesystem server")
+            .example("neurolink mcp remove old-server --force", "Force remove without confirmation");
+    }
+    /**
+     * Execute list command
+     */
+    static async executeList(argv) {
+        try {
+            const spinner = argv.quiet ? null : ora("Loading MCP servers...").start();
+            // Get configured servers from NeuroLink
+            const sdk = new NeuroLink();
+            const rawMcpStatus = await sdk.getMCPStatus();
+            const mcpStatus = convertMCPStatusForCLI(rawMcpStatus, sdk);
+            if (spinner) {
+                spinner.succeed(`Found ${mcpStatus.servers.length} MCP servers`);
+            }
+            if (mcpStatus.servers.length === 0) {
+                logger.always(chalk.yellow("No MCP servers configured."));
+                logger.always(chalk.blue("💡 Use 'neurolink mcp install <server>' to install popular servers"));
+                logger.always(chalk.blue("💡 Use 'neurolink discover' to find existing servers"));
+                return;
+            }
+            // Format and display results
+            if (argv.format === "json") {
+                logger.always(JSON.stringify(mcpStatus, null, 2));
+            }
+            else if (argv.format && argv.format === "compact") {
+                mcpStatus.servers.forEach((server) => {
+                    const status = server.connected ? chalk.green("✓") : chalk.red("✗");
+                    logger.always(`${status} ${server.name} - ${server.description || "No description"}`);
+                });
+            }
+            else {
+                // Table format
+                logger.always(chalk.bold("\n🔧 MCP Servers:\n"));
+                for (const server of mcpStatus.servers) {
+                    const status = server.connected
+                        ? chalk.green("CONNECTED")
+                        : chalk.red("DISCONNECTED");
+                    logger.always(`${chalk.cyan(server.name)} ${status}`);
+                    logger.always(`  Command: ${server.command || "Unknown"}`);
+                    logger.always(`  Tools: ${server.tools?.length || 0} available`);
+                    if (argv.detailed && server.tools) {
+                        server.tools.forEach((tool) => {
+                            logger.always(`    • ${tool.name}: ${tool.description}`);
+                        });
+                    }
+                    if (server.error) {
+                        logger.always(`  ${chalk.red("Error:")} ${server.error}`);
+                    }
+                    logger.always();
+                }
+            }
+        }
+        catch (error) {
+            logger.error(chalk.red(`❌ List command failed: ${error.message}`));
+            process.exit(1);
+        }
+    }
+    /**
+     * Execute install command
+     */
+    static async executeInstall(argv) {
+        try {
+            const serverName = argv.server;
+            const serverConfig = POPULAR_MCP_SERVERS[serverName];
+            if (!serverConfig) {
+                logger.error(chalk.red(`❌ Unknown server: ${serverName}`));
+                logger.always(chalk.blue("Available servers:"));
+                Object.keys(POPULAR_MCP_SERVERS).forEach((name) => {
+                    logger.always(`  • ${name}: ${POPULAR_MCP_SERVERS[name].description}`);
+                });
+                process.exit(1);
+            }
+            const spinner = argv.quiet
+                ? null
+                : ora(`Installing ${serverName} MCP server...`).start();
+            // Parse environment variables if provided
+            let env = serverConfig.env;
+            if (argv.env) {
+                try {
+                    const parsedEnv = JSON.parse(argv.env);
+                    env = { ...env, ...parsedEnv };
+                }
+                catch (error) {
+                    if (spinner) {
+                        spinner.fail();
+                    }
+                    logger.error(chalk.red("❌ Invalid JSON in env parameter"));
+                    process.exit(1);
+                }
+            }
+            // Create server configuration
+            const config = {
+                name: serverName,
+                command: serverConfig.command,
+                args: argv.args || serverConfig.args,
+                env,
+                transport: (argv.transport &&
+                    (argv.transport === "websocket"
+                        ? "ws"
+                        : argv.transport)) ||
+                    serverConfig.transport,
+                description: serverConfig.description,
+                installed: true,
+                status: "unknown",
+            };
+            // Add server to NeuroLink (using in-memory MCP server for now)
+            const sdk = new NeuroLink();
+            await sdk.addInMemoryMCPServer(serverName, {
+                server: {
+                    title: serverConfig.description,
+                    tools: {}, // Empty tools for external servers
+                    description: serverConfig.description,
+                },
+                metadata: {
+                    command: config.command,
+                    args: config.args,
+                    env: config.env,
+                    transport: config.transport,
+                },
+            });
+            if (spinner) {
+                spinner.succeed(chalk.green(`✅ Successfully installed ${serverName} MCP server`));
+            }
+            // Display configuration info
+            logger.always(chalk.bold("\n📋 Server Configuration:"));
+            logger.always(`Name: ${config.name}`);
+            logger.always(`Command: ${config.command}`);
+            if (config.args?.length) {
+                logger.always(`Args: ${config.args.join(" ")}`);
+            }
+            if (config.env) {
+                logger.always(`Environment: ${Object.keys(config.env).length} variables`);
+            }
+            logger.always(`Transport: ${config.transport}`);
+            logger.always(`Description: ${config.description}`);
+            // Test connection
+            logger.always(chalk.blue("\n🔍 Testing connection..."));
+            try {
+                const rawStatus = await sdk.getMCPStatus();
+                const status = convertMCPStatusForCLI(rawStatus, sdk);
+                const installedServer = status.servers.find((s) => s.name === serverName);
+                if (installedServer?.connected) {
+                    logger.always(chalk.green("✅ Server connected successfully"));
+                    if (installedServer.tools?.length) {
+                        logger.always(`🛠️  Available tools: ${installedServer.tools.length}`);
+                    }
+                }
+                else {
+                    logger.always(chalk.yellow("⚠️  Server installed but not connected"));
+                    if (installedServer?.error) {
+                        logger.always(chalk.red(`Error: ${installedServer.error}`));
+                    }
+                }
+            }
+            catch (testError) {
+                logger.always(chalk.yellow("⚠️  Could not test connection"));
+            }
+        }
+        catch (error) {
+            logger.error(chalk.red(`❌ Install command failed: ${error.message}`));
+            process.exit(1);
+        }
+    }
+    /**
+     * Execute add command
+     */
+    static async executeAdd(argv) {
+        try {
+            const name = argv.name;
+            const command = argv.command;
+            const spinner = argv.quiet
+                ? null
+                : ora(`Adding custom MCP server: ${name}...`).start();
+            // Parse environment variables if provided
+            let env;
+            if (argv.env) {
+                try {
+                    env = JSON.parse(argv.env);
+                }
+                catch (error) {
+                    if (spinner) {
+                        spinner.fail();
+                    }
+                    logger.error(chalk.red("❌ Invalid JSON in env parameter"));
+                    process.exit(1);
+                }
+            }
+            // Create server configuration
+            const config = {
+                name,
+                command,
+                args: argv.args,
+                env,
+                transport: (argv.transport === "websocket"
+                    ? "ws"
+                    : argv.transport) || "stdio",
+                installed: true,
+                status: "unknown",
+            };
+            // Add server to NeuroLink
+            const sdk = new NeuroLink();
+            await sdk.addInMemoryMCPServer(name, {
+                server: {
+                    title: name,
+                    tools: {}, // Empty tools for external servers
+                    description: `Custom MCP server: ${command}`,
+                },
+                metadata: {
+                    command: config.command,
+                    args: config.args,
+                    env: config.env,
+                    transport: config.transport,
+                },
+            });
+            if (spinner) {
+                spinner.succeed(chalk.green(`✅ Successfully added ${name} MCP server`));
+            }
+            // Display configuration
+            logger.always(chalk.bold("\n📋 Server Configuration:"));
+            logger.always(`Name: ${config.name}`);
+            logger.always(`Command: ${config.command}`);
+            if (config.args?.length) {
+                logger.always(`Args: ${config.args.join(" ")}`);
+            }
+            if (config.env) {
+                logger.always(`Environment: ${Object.keys(config.env).length} variables`);
+            }
+            logger.always(`Transport: ${config.transport}`);
+        }
+        catch (error) {
+            logger.error(chalk.red(`❌ Add command failed: ${error.message}`));
+            process.exit(1);
+        }
+    }
+    /**
+     * Execute test command
+     */
+    static async executeTest(argv) {
+        try {
+            const targetServer = argv.server;
+            const spinner = argv.quiet
+                ? null
+                : ora("Testing MCP server connections...").start();
+            const sdk = new NeuroLink();
+            const rawMcpStatus = await sdk.getMCPStatus();
+            const mcpStatus = convertMCPStatusForCLI(rawMcpStatus, sdk);
+            let serversToTest = mcpStatus.servers;
+            if (targetServer) {
+                serversToTest = mcpStatus.servers.filter((s) => s.name === targetServer);
+                if (serversToTest.length === 0) {
+                    if (spinner) {
+                        spinner.fail();
+                    }
+                    logger.error(chalk.red(`❌ Server not found: ${targetServer}`));
+                    process.exit(1);
+                }
+            }
+            if (spinner) {
+                spinner.succeed(`Testing ${serversToTest.length} servers`);
+            }
+            // Display test results
+            logger.always(chalk.bold("\n🧪 MCP Server Test Results:\n"));
+            for (const server of serversToTest) {
+                const status = server.connected
+                    ? chalk.green("✅ CONNECTED")
+                    : chalk.red("❌ DISCONNECTED");
+                logger.always(`${server.name}: ${status}`);
+                if (server.connected) {
+                    logger.always(`  Tools: ${server.tools?.length || 0} available`);
+                    if (server.tools?.length) {
+                        server.tools.slice(0, 3).forEach((tool) => {
+                            logger.always(`    • ${tool.name}`);
+                        });
+                        if (server.tools.length > 3) {
+                            logger.always(`    ... and ${server.tools.length - 3} more`);
+                        }
+                    }
+                }
+                else {
+                    if (server.error) {
+                        logger.always(`  ${chalk.red("Error:")} ${server.error}`);
+                    }
+                    logger.always(chalk.yellow("  💡 Try: neurolink mcp remove && neurolink mcp install"));
+                }
+                logger.always();
+            }
+            // Summary
+            const connected = serversToTest.filter((s) => s.connected).length;
+            const total = serversToTest.length;
+            if (connected === total) {
+                logger.always(chalk.green(`🎉 All ${total} servers connected successfully`));
+            }
+            else {
+                logger.always(chalk.yellow(`⚠️  ${connected}/${total} servers connected`));
+            }
+        }
+        catch (error) {
+            logger.error(chalk.red(`❌ Test command failed: ${error.message}`));
+            process.exit(1);
+        }
+    }
+    /**
+     * Execute exec command
+     */
+    static async executeExec(argv) {
+        try {
+            const serverName = argv.server;
+            const toolName = argv.tool;
+            const spinner = argv.quiet
+                ? null
+                : ora(`Executing ${toolName} on ${serverName}...`).start();
+            // Parse parameters if provided
+            let params = {};
+            if (argv.params) {
+                try {
+                    params = JSON.parse(argv.params);
+                }
+                catch (error) {
+                    if (spinner) {
+                        spinner.fail();
+                    }
+                    logger.error(chalk.red("❌ Invalid JSON in params parameter"));
+                    process.exit(1);
+                }
+            }
+            const sdk = new NeuroLink();
+            // Check if server exists and is connected
+            const rawMcpStatus = await sdk.getMCPStatus();
+            const mcpStatus = convertMCPStatusForCLI(rawMcpStatus, sdk);
+            const server = mcpStatus.servers.find((s) => s.name === serverName);
+            if (!server) {
+                if (spinner) {
+                    spinner.fail();
+                }
+                logger.error(chalk.red(`❌ Server not found: ${serverName}`));
+                process.exit(1);
+            }
+            if (!server.connected) {
+                if (spinner) {
+                    spinner.fail();
+                }
+                logger.error(chalk.red(`❌ Server not connected: ${serverName}`));
+                logger.always(chalk.yellow("💡 Try: neurolink mcp test " + serverName));
+                process.exit(1);
+            }
+            // Check if tool exists
+            const tool = server.tools?.find((t) => t.name === toolName);
+            if (!tool) {
+                if (spinner) {
+                    spinner.fail();
+                }
+                logger.error(chalk.red(`❌ Tool not found: ${toolName}`));
+                if (server.tools?.length) {
+                    logger.always(chalk.blue("Available tools:"));
+                    server.tools.forEach((t) => {
+                        logger.always(`  • ${t.name}: ${t.description}`);
+                    });
+                }
+                process.exit(1);
+            }
+            // Execute the tool (This would need actual MCP execution logic)
+            // For now, showing a placeholder implementation
+            const result = {
+                tool: toolName,
+                server: serverName,
+                params,
+                result: "Tool execution not yet implemented in NeuroLink SDK",
+                timestamp: new Date().toISOString(),
+            };
+            if (spinner) {
+                spinner.succeed(chalk.green("✅ Tool executed successfully"));
+            }
+            // Display results
+            if (argv.format === "json") {
+                logger.always(JSON.stringify(result, null, 2));
+            }
+            else {
+                logger.always(chalk.bold("\n🛠️  Tool Execution Result:\n"));
+                logger.always(`Tool: ${toolName}`);
+                logger.always(`Server: ${serverName}`);
+                if (Object.keys(params).length > 0) {
+                    logger.always(`Params: ${JSON.stringify(params)}`);
+                }
+                logger.always(`Result: ${result.result}`);
+                logger.always(`Time: ${result.timestamp}`);
+            }
+        }
+        catch (error) {
+            logger.error(chalk.red(`❌ Exec command failed: ${error.message}`));
+            process.exit(1);
+        }
+    }
+    /**
+     * Execute remove command
+     */
+    static async executeRemove(argv) {
+        try {
+            const serverName = argv.server;
+            const sdk = new NeuroLink();
+            const rawMcpStatus = await sdk.getMCPStatus();
+            const mcpStatus = convertMCPStatusForCLI(rawMcpStatus, sdk);
+            const server = mcpStatus.servers.find((s) => s.name === serverName);
+            if (!server) {
+                logger.error(chalk.red(`❌ Server not found: ${serverName}`));
+                process.exit(1);
+            }
+            // Confirmation unless forced
+            if (!argv.force) {
+                logger.always(chalk.yellow(`⚠️  This will remove the MCP server: ${serverName}`));
+                logger.always("Use --force flag to confirm removal");
+                process.exit(1);
+            }
+            const spinner = argv.quiet
+                ? null
+                : ora(`Removing MCP server: ${serverName}...`).start();
+            // Remove server (This would need actual removal logic in NeuroLink SDK)
+            // For now, showing a placeholder
+            logger.always(chalk.yellow("⚠️  Server removal not yet implemented in NeuroLink SDK"));
+            if (spinner) {
+                spinner.succeed(chalk.green(`✅ Server ${serverName} removed successfully`));
+            }
+        }
+        catch (error) {
+            logger.error(chalk.red(`❌ Remove command failed: ${error.message}`));
+            process.exit(1);
+        }
+    }
+    /**
+     * Execute discover command
+     */
+    static async executeDiscover(argv) {
+        try {
+            const spinner = argv.quiet
+                ? null
+                : ora("Discovering MCP servers...").start();
+            const discovered = [];
+            // Discover from Claude Desktop
+            if (argv.source === "claude-desktop" || argv.source === "all") {
+                const claudeServers = await this.discoverFromClaudeDesktop();
+                discovered.push(...claudeServers);
+            }
+            // Discover from VS Code
+            if (argv.source === "vscode" || argv.source === "all") {
+                const vscodeServers = await this.discoverFromVSCode();
+                discovered.push(...vscodeServers);
+            }
+            if (spinner) {
+                spinner.succeed(`Discovered ${discovered.length} MCP servers`);
+            }
+            if (discovered.length === 0) {
+                logger.always(chalk.yellow("No MCP servers discovered."));
+                logger.always(chalk.blue("💡 Try installing popular servers: neurolink mcp install filesystem"));
+                return;
+            }
+            // Display discovered servers
+            if (argv.format === "json") {
+                logger.always(JSON.stringify(discovered, null, 2));
+            }
+            else {
+                logger.always(chalk.bold("\n🔍 Discovered MCP Servers:\n"));
+                discovered.forEach((server) => {
+                    logger.always(`${chalk.cyan(server.name)}`);
+                    logger.always(`  Command: ${server.command}`);
+                    logger.always(`  Source: ${server.description || "Unknown"}`);
+                    logger.always(`  Status: ${server.status}`);
+                    logger.always();
+                });
+            }
+            // Auto-install if requested
+            if (argv.autoInstall && discovered.length > 0) {
+                logger.always(chalk.blue("🚀 Auto-installing discovered servers..."));
+                const sdk = new NeuroLink();
+                for (const server of discovered) {
+                    try {
+                        await sdk.addInMemoryMCPServer(server.name, {
+                            server: {
+                                title: server.name,
+                                tools: {},
+                                description: server.description,
+                            },
+                            metadata: {
+                                command: server.command,
+                                args: server.args,
+                                env: server.env,
+                                transport: server.transport,
+                            },
+                        });
+                        logger.always(chalk.green(`✅ Installed ${server.name}`));
+                    }
+                    catch (error) {
+                        logger.always(chalk.red(`❌ Failed to install ${server.name}: ${error.message}`));
+                    }
+                }
+            }
+        }
+        catch (error) {
+            logger.error(chalk.red(`❌ Discover command failed: ${error.message}`));
+            process.exit(1);
+        }
+    }
+    /**
+     * Discover servers from Claude Desktop configuration
+     */
+    static async discoverFromClaudeDesktop() {
+        const servers = [];
+        try {
+            // Common Claude Desktop config paths
+            const possiblePaths = [
+                path.join(process.env.HOME || "", "Library", "Application Support", "Claude", "claude_desktop_config.json"),
+                path.join(process.env.APPDATA || "", "Claude", "claude_desktop_config.json"),
+                path.join(process.env.HOME || "", ".config", "claude", "claude_desktop_config.json"),
+            ];
+            for (const configPath of possiblePaths) {
+                if (fs.existsSync(configPath)) {
+                    const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+                    if (config.mcpServers) {
+                        Object.entries(config.mcpServers).forEach(([name, serverConfig]) => {
+                            const config = serverConfig;
+                            servers.push({
+                                name,
+                                command: config.command,
+                                args: config.args,
+                                env: config.env,
+                                transport: "stdio",
+                                description: "Discovered from Claude Desktop",
+                                installed: false,
+                                status: "unknown",
+                            });
+                        });
+                    }
+                    break; // Found config file, stop searching
+                }
+            }
+        }
+        catch (error) {
+            // Ignore errors in discovery
+        }
+        return servers;
+    }
+    /**
+     * Discover servers from VS Code configuration
+     */
+    static async discoverFromVSCode() {
+        const servers = [];
+        try {
+            // VS Code settings paths
+            const possiblePaths = [
+                path.join(process.env.HOME || "", "Library", "Application Support", "Code", "User", "settings.json"),
+                path.join(process.env.APPDATA || "", "Code", "User", "settings.json"),
+                path.join(process.env.HOME || "", ".config", "Code", "User", "settings.json"),
+            ];
+            for (const settingsPath of possiblePaths) {
+                if (fs.existsSync(settingsPath)) {
+                    const settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+                    // Look for MCP-related extensions or configurations
+                    if (settings["mcp.servers"]) {
+                        Object.entries(settings["mcp.servers"]).forEach(([name, serverConfig]) => {
+                            const config = serverConfig;
+                            servers.push({
+                                name,
+                                command: config.command || "unknown",
+                                args: config.args,
+                                env: config.env,
+                                transport: "stdio",
+                                description: "Discovered from VS Code",
+                                installed: false,
+                                status: "unknown",
+                            });
+                        });
+                    }
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            // Ignore errors in discovery
+        }
+        return servers;
+    }
+}