@compass-ai/nova 1.0.72 → 1.0.74

package/dist/commands/slash/mcp.js

@@ -0,0 +1,1026 @@
+/**
+ * Slash /mcp command implementation for interactive MCP server management.
+ *
+ * This command provides an interactive interface for:
+ * - Viewing connected MCP servers and their status
+ * - Authenticating with OAuth-enabled servers
+ * - Managing server connections
+ * - Viewing available tools, resources, and prompts
+ *
+ * @example
+ * ```
+ * /mcp           - Show MCP server status overview
+ * /mcp servers   - List all configured servers
+ * /mcp tools     - List all available MCP tools
+ * /mcp connect   - Connect to all configured servers
+ * /mcp auth      - Start authentication for a server
+ * ```
+ */
+import chalk from 'chalk';
+import { exec } from 'child_process';
+import { getMCPServerManager } from '../../services/mcp-server-manager.js';
+import { getMCPConfigManager } from '../../services/mcp-config-manager.js';
+import { getMCPOAuthService, getProviderInfo, getFallbackConfig, checkLocalFigmaServer, } from '../../services/mcp-oauth-service.js';
+import { logger } from '../../utils/logger.js';
+import { registerSlashCommand, } from '../../core/slash-command-handler.js';
+import { isMCPHttpConfig, isMCPSseConfig, isMCPStdioConfig, } from '../../types/mcp.js';
+import { getEventEmitter } from '../../core/event-emitter.js';
+/**
+ * Opens a URL in the user's default browser.
+ * Uses platform-specific commands: start (Windows), open (macOS), xdg-open (Linux)
+ */
+function openInBrowser(url) {
+    return new Promise((resolve) => {
+        const platform = process.platform;
+        let command;
+        if (platform === 'win32') {
+            // Windows - use start command, wrap URL in quotes to handle special chars
+            command = `start "" "${url}"`;
+        }
+        else if (platform === 'darwin') {
+            // macOS
+            command = `open "${url}"`;
+        }
+        else {
+            // Linux and others
+            command = `xdg-open "${url}"`;
+        }
+        exec(command, (error) => {
+            if (error) {
+                logger.debug(`Failed to open browser: ${error.message}`);
+                resolve(false);
+            }
+            else {
+                resolve(true);
+            }
+        });
+    });
+}
+/**
+ * Emits output for the mcp command via the event system
+ * This allows the UI to capture and display the output in real-time
+ */
+function emitOutput(message, isError = false) {
+    const eventEmitter = getEventEmitter();
+    eventEmitter.emit('slash-command-output', {
+        command: 'mcp',
+        message,
+        isError,
+    });
+}
+/**
+ * Formats server type for display.
+ */
+function formatServerType(type) {
+    switch (type) {
+        case 'http':
+            return chalk.cyan('HTTP');
+        case 'sse':
+            return chalk.yellow('SSE');
+        case 'stdio':
+            return chalk.green('stdio');
+        default:
+            return chalk.gray(type);
+    }
+}
+/**
+ * Displays the MCP status overview.
+ */
+async function displayStatus() {
+    const serverManager = getMCPServerManager();
+    const states = serverManager.getAllServerStates();
+    emitOutput('');
+    emitOutput(chalk.bold('MCP Server Status'));
+    emitOutput(chalk.dim('─'.repeat(50)));
+    if (states.length === 0) {
+        emitOutput('');
+        emitOutput(chalk.gray('No MCP servers configured.'));
+        emitOutput('');
+        emitOutput(chalk.gray('Add servers using:'));
+        emitOutput(chalk.gray('  compass mcp add --transport http <name> <url>'));
+        emitOutput('');
+        return;
+    }
+    const connected = states.filter((s) => s.status === 'connected').length;
+    const total = states.length;
+    const totalTools = serverManager.getAllTools().length;
+    const totalResources = serverManager.getAllResources().length;
+    const totalPrompts = serverManager.getAllPrompts().length;
+    emitOutput('');
+    emitOutput(`${chalk.gray('Connected:')} ${connected}/${total} servers`);
+    emitOutput(`${chalk.gray('Tools:')} ${totalTools}`);
+    emitOutput(`${chalk.gray('Resources:')} ${totalResources}`);
+    emitOutput(`${chalk.gray('Prompts:')} ${totalPrompts}`);
+    emitOutput('');
+    let hasUnapproved = false;
+    let hasAuthRequired = false;
+    let hasErrors = false;
+    for (const state of states) {
+        const statusIndicator = state.status === 'connected'
+            ? chalk.green('●')
+            : state.status === 'error'
+                ? chalk.red('●')
+                : chalk.gray('○');
+        emitOutput(`${statusIndicator} ${chalk.bold(state.config.name)} ${chalk.gray(`(${formatServerType(state.config.type)})`)}`);
+        if (state.status === 'connected') {
+            emitOutput(`    ${chalk.gray('Tools:')} ${state.tools.length}, ${chalk.gray('Resources:')} ${state.resources.length}, ${chalk.gray('Prompts:')} ${state.prompts.length}`);
+        }
+        else if (state.status === 'error') {
+            emitOutput(`    ${chalk.red(state.error || 'Unknown error')}`);
+            hasErrors = true;
+        }
+        else if (state.error) {
+            emitOutput(`    ${chalk.yellow(state.error)}`);
+            if (state.error === 'Awaiting approval') {
+                hasUnapproved = true;
+            }
+            if (state.error.includes('Authentication required')) {
+                hasAuthRequired = true;
+            }
+        }
+    }
+    emitOutput('');
+    if (hasErrors) {
+        emitOutput(chalk.yellow('Tip: Reconnect failed servers with /mcp reconnect <server-name>'));
+        emitOutput('');
+    }
+    if (hasUnapproved) {
+        emitOutput(chalk.yellow('Tip: Approve project servers with /mcp approve <server-name>'));
+        emitOutput('');
+    }
+    if (hasAuthRequired) {
+        emitOutput(chalk.yellow('Tip: Authenticate servers with /mcp auth <server-name> <token>'));
+        emitOutput('');
+    }
+    emitOutput(chalk.gray('Commands: /mcp servers | /mcp tools | /mcp connect | /mcp approve'));
+    emitOutput('');
+}
+/**
+ * Lists all configured servers.
+ */
+async function listServers() {
+    const configManager = getMCPConfigManager();
+    await configManager.load(process.cwd());
+    const servers = configManager.getAllServers(process.cwd());
+    emitOutput('');
+    emitOutput(chalk.bold('Configured MCP Servers'));
+    emitOutput(chalk.dim('─'.repeat(50)));
+    if (servers.length === 0) {
+        emitOutput(chalk.gray('No servers configured.'));
+        emitOutput('');
+        return;
+    }
+    for (const server of servers) {
+        const typeLabel = formatServerType(server.type);
+        const scopeLabel = chalk.gray(`[${server.scope || 'local'}]`);
+        emitOutput('');
+        emitOutput(`${chalk.bold(server.name)} ${typeLabel} ${scopeLabel}`);
+        if (isMCPHttpConfig(server) || isMCPSseConfig(server)) {
+            emitOutput(`  ${chalk.gray('URL:')} ${server.url}`);
+        }
+        else if (isMCPStdioConfig(server)) {
+            const cmd = server.args
+                ? `${server.command} ${server.args.join(' ')}`
+                : server.command;
+            emitOutput(`  ${chalk.gray('Command:')} ${cmd}`);
+        }
+        if (server.source === 'plugin') {
+            emitOutput(`  ${chalk.gray('Plugin:')} ${server.pluginName}`);
+        }
+    }
+    emitOutput('');
+}
+/**
+ * Lists all available tools from connected servers.
+ */
+async function listTools() {
+    const serverManager = getMCPServerManager();
+    const tools = serverManager.getAllTools();
+    emitOutput('');
+    emitOutput(chalk.bold('Available MCP Tools'));
+    emitOutput(chalk.dim('─'.repeat(50)));
+    if (tools.length === 0) {
+        emitOutput(chalk.gray('No tools available.'));
+        emitOutput(chalk.gray('Connect to MCP servers first with /mcp connect'));
+        emitOutput('');
+        return;
+    }
+    // Group tools by server
+    const toolsByServer = new Map();
+    for (const tool of tools) {
+        const serverName = tool.serverName || 'unknown';
+        if (!toolsByServer.has(serverName)) {
+            toolsByServer.set(serverName, []);
+        }
+        toolsByServer.get(serverName).push(tool);
+    }
+    for (const [serverName, serverTools] of toolsByServer) {
+        emitOutput('');
+        emitOutput(chalk.bold.cyan(serverName));
+        for (const tool of serverTools) {
+            emitOutput(`  ${chalk.white(tool.name)}`);
+            if (tool.description) {
+                emitOutput(`    ${chalk.gray(tool.description)}`);
+            }
+        }
+    }
+    emitOutput('');
+    emitOutput(chalk.gray(`Total: ${tools.length} tool(s)`));
+    emitOutput('');
+}
+/**
+ * Lists all available resources from connected servers.
+ */
+async function listResources() {
+    const serverManager = getMCPServerManager();
+    const resources = serverManager.getAllResources();
+    emitOutput('');
+    emitOutput(chalk.bold('Available MCP Resources'));
+    emitOutput(chalk.dim('─'.repeat(50)));
+    if (resources.length === 0) {
+        emitOutput(chalk.gray('No resources available.'));
+        emitOutput('');
+        return;
+    }
+    for (const resource of resources) {
+        emitOutput(`  ${chalk.white(resource.name)} ${chalk.gray(`(${resource.serverName})`)}`);
+        emitOutput(`    ${chalk.gray('URI:')} ${resource.uri}`);
+        if (resource.description) {
+            emitOutput(`    ${chalk.gray(resource.description)}`);
+        }
+    }
+    emitOutput('');
+}
+/**
+ * Lists all available prompts from connected servers.
+ */
+async function listPrompts() {
+    const serverManager = getMCPServerManager();
+    const prompts = serverManager.getAllPrompts();
+    emitOutput('');
+    emitOutput(chalk.bold('Available MCP Prompts'));
+    emitOutput(chalk.dim('─'.repeat(50)));
+    if (prompts.length === 0) {
+        emitOutput(chalk.gray('No prompts available.'));
+        emitOutput('');
+        return;
+    }
+    for (const prompt of prompts) {
+        emitOutput(`  ${chalk.white(prompt.name)} ${chalk.gray(`(${prompt.serverName})`)}`);
+        if (prompt.description) {
+            emitOutput(`    ${chalk.gray(prompt.description)}`);
+        }
+        if (prompt.arguments && prompt.arguments.length > 0) {
+            const argNames = prompt.arguments
+                .map((a) => (a.required ? a.name : `[${a.name}]`))
+                .join(', ');
+            emitOutput(`    ${chalk.gray('Args:')} ${argNames}`);
+        }
+    }
+    emitOutput('');
+}
+/**
+ * Connects to all configured servers.
+ */
+async function connectServers() {
+    emitOutput('');
+    emitOutput(chalk.cyan('Connecting to MCP servers...'));
+    try {
+        const serverManager = getMCPServerManager();
+        await serverManager.initialize(process.cwd());
+        await serverManager.connectAllServers();
+        const connected = serverManager.getConnectedCount();
+        const total = serverManager.getTotalCount();
+        emitOutput('');
+        if (connected === total) {
+            emitOutput(chalk.green(`All ${total} server(s) connected successfully.`));
+        }
+        else {
+            emitOutput(chalk.yellow(`Connected ${connected}/${total} server(s).`));
+            emitOutput(chalk.gray('Use /mcp to see server status and errors.'));
+        }
+        emitOutput('');
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        emitOutput(chalk.red(`Failed to connect: ${errorMessage}`));
+        emitOutput('');
+    }
+}
+/**
+ * Disconnects from all servers.
+ */
+async function disconnectServers() {
+    emitOutput('');
+    emitOutput(chalk.cyan('Disconnecting from MCP servers...'));
+    try {
+        const serverManager = getMCPServerManager();
+        await serverManager.disconnectAllServers();
+        emitOutput(chalk.green('Disconnected from all servers.'));
+        emitOutput('');
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        emitOutput(chalk.red(`Failed to disconnect: ${errorMessage}`));
+        emitOutput('');
+    }
+}
+/**
+ * Displays fallback server information and setup instructions.
+ */
+async function displayFallbackInfo(serverUrl, serverName) {
+    const fallback = getFallbackConfig(serverUrl);
+    const provider = getProviderInfo(serverUrl);
+    if (!fallback || !provider) {
+        return;
+    }
+    emitOutput('');
+    emitOutput(chalk.yellow('━'.repeat(50)));
+    emitOutput(chalk.yellow.bold(`OAuth Restricted: ${provider.name}`));
+    emitOutput(chalk.yellow('━'.repeat(50)));
+    emitOutput('');
+    emitOutput(chalk.white(fallback.reason));
+    emitOutput('');
+    if (provider.approvedClients && provider.approvedClients.length > 0) {
+        emitOutput(chalk.gray('Approved clients: ') + provider.approvedClients.join(', '));
+        emitOutput('');
+    }
+    emitOutput(chalk.cyan.bold(`Alternative: ${fallback.name}`));
+    emitOutput('');
+    if (fallback.requirements && fallback.requirements.length > 0) {
+        emitOutput(chalk.white('Requirements:'));
+        for (const req of fallback.requirements) {
+            emitOutput(chalk.gray(`  • ${req}`));
+        }
+        emitOutput('');
+    }
+    if (fallback.setupInstructions && fallback.setupInstructions.length > 0) {
+        emitOutput(chalk.white('Setup Instructions:'));
+        for (const instruction of fallback.setupInstructions) {
+            emitOutput(chalk.gray(`  ${instruction}`));
+        }
+        emitOutput('');
+    }
+    // Check if local Figma server is available
+    if (provider.name === 'figma') {
+        emitOutput(chalk.cyan('Checking local Figma server availability...'));
+        const isAvailable = await checkLocalFigmaServer();
+        if (isAvailable) {
+            emitOutput(chalk.green('✓ Local Figma MCP server is running!'));
+            emitOutput('');
+            emitOutput(chalk.white('To use it, update your .mcp.json:'));
+            emitOutput('');
+            emitOutput(chalk.gray('  {'));
+            emitOutput(chalk.gray('    "mcpServers": {'));
+            emitOutput(chalk.gray(`      "${serverName}": {`));
+            emitOutput(chalk.gray('        "type": "http",'));
+            emitOutput(chalk.gray('        "url": "http://127.0.0.1:3845/mcp",'));
+            emitOutput(chalk.gray('        "enabled": true'));
+            emitOutput(chalk.gray('      }'));
+            emitOutput(chalk.gray('    }'));
+            emitOutput(chalk.gray('  }'));
+            emitOutput('');
+            emitOutput(chalk.cyan('Then run: /mcp connect'));
+        }
+        else {
+            emitOutput(chalk.yellow('✗ Local Figma MCP server not detected.'));
+            emitOutput(chalk.gray('  Follow the setup instructions above to enable it.'));
+        }
+        emitOutput('');
+    }
+    emitOutput(chalk.gray('For more information, see: docs/mcp-authentication.md'));
+    emitOutput('');
+}
+/**
+ * Starts authentication for a server.
+ * Supports both OAuth flow and simple token-based authentication.
+ *
+ * @param serverName - The name of the server to authenticate
+ * @param token - Optional API token for simple token-based authentication
+ */
+async function authenticateServer(serverName, token) {
+    if (!serverName) {
+        emitOutput('');
+        emitOutput(chalk.yellow('Please specify a server name: /mcp auth <server-name> [token]'));
+        emitOutput('');
+        emitOutput(chalk.gray('Examples:'));
+        emitOutput(chalk.gray('  /mcp auth figma                    - Start OAuth flow (if configured)'));
+        emitOutput(chalk.gray('  /mcp auth figma figd_abc123...     - Set API token directly'));
+        emitOutput('');
+        return;
+    }
+    // Use server manager to get the server config - it already has all servers loaded
+    // and handles path normalization correctly
+    const serverManager = getMCPServerManager();
+    const serverState = serverManager.getServerState(serverName);
+    // If server is not in server manager, try the config manager as fallback
+    let server = serverState?.config;
+    if (!server) {
+        const configManager = getMCPConfigManager();
+        await configManager.load(process.cwd());
+        server = configManager.getServer(serverName, process.cwd());
+    }
+    if (!server) {
+        emitOutput('');
+        emitOutput(chalk.red(`Server not found: ${serverName}`));
+        emitOutput('');
+        return;
+    }
+    const oauthService = await getMCPOAuthService();
+    // If a token is provided, use simple token-based auth
+    if (token) {
+        emitOutput('');
+        emitOutput(chalk.cyan(`Setting API token for ${serverName}...`));
+        try {
+            await oauthService.setApiToken(serverName, token);
+            emitOutput(chalk.green(`✓ API token stored for '${serverName}'`));
+            // Try to connect with the new token
+            emitOutput(chalk.cyan('  Connecting...'));
+            const serverManager = getMCPServerManager();
+            const state = await serverManager.connectServer(serverName);
+            if (state.status === 'connected') {
+                emitOutput(chalk.green(`✓ Connected - ${state.tools.length} tool(s), ${state.resources.length} resource(s), ${state.prompts.length} prompt(s)`));
+            }
+            else if (state.error) {
+                emitOutput(chalk.yellow(`⚠ Connection issue: ${state.error}`));
+                if (state.error.includes('Authentication required')) {
+                    emitOutput(chalk.gray('  The token may be invalid or expired. Try with a different token.'));
+                }
+            }
+            emitOutput('');
+            return;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            emitOutput(chalk.red(`Failed to set token: ${errorMessage}`));
+            emitOutput('');
+            return;
+        }
+    }
+    // Get server URL for OAuth discovery (only for HTTP/SSE servers)
+    let serverUrl;
+    if (isMCPHttpConfig(server) || isMCPSseConfig(server)) {
+        serverUrl = server.url;
+    }
+    // Check if this is a provider with restricted OAuth (e.g., Figma)
+    // Show a proactive warning with fallback information
+    if (serverUrl) {
+        const provider = getProviderInfo(serverUrl);
+        if (provider?.oauthRestricted) {
+            emitOutput('');
+            emitOutput(chalk.yellow(`Note: ${provider.name} restricts OAuth to approved clients.`));
+            emitOutput(chalk.gray(`Approved clients: ${provider.approvedClients?.join(', ') || 'Unknown'}`));
+            emitOutput(chalk.gray(`Kore-CLI may not be able to authenticate with the remote server.`));
+            emitOutput('');
+            emitOutput(chalk.cyan('Attempting OAuth flow anyway...'));
+        }
+    }
+    // Check if we have complete OAuth config (with URLs) or partial (just credentials)
+    const hasCompleteOAuthConfig = server.oauth?.authorizationUrl && server.oauth?.tokenUrl;
+    const hasPartialOAuthConfig = server.oauth && !hasCompleteOAuthConfig;
+    // Try OAuth flow - either with pre-configured OAuth or via discovery
+    emitOutput('');
+    if (hasCompleteOAuthConfig) {
+        emitOutput(chalk.cyan(`Starting OAuth authentication for ${serverName}...`));
+    }
+    else if (serverUrl) {
+        if (hasPartialOAuthConfig) {
+            emitOutput(chalk.cyan(`Discovering OAuth endpoints for ${serverName} (using configured credentials)...`));
+        }
+        else {
+            emitOutput(chalk.cyan(`Discovering OAuth configuration for ${serverName}...`));
+        }
+    }
+    else {
+        // stdio server without OAuth - must use token
+        emitOutput(chalk.yellow(`Server '${serverName}' requires authentication.`));
+        emitOutput('');
+        emitOutput(chalk.white('To authenticate, provide your API token:'));
+        emitOutput('');
+        emitOutput(chalk.cyan(`  /mcp auth ${serverName} <your-api-token>`));
+        emitOutput('');
+        emitOutput(chalk.gray('You can usually find your API token in the service\'s settings or developer portal.'));
+        emitOutput('');
+        return;
+    }
+    try {
+        // Start the OAuth flow - with discovery if needed
+        let authUrl;
+        let discoveredConfig;
+        if (hasCompleteOAuthConfig) {
+            // Use fully pre-configured OAuth (has URLs)
+            const result = await oauthService.startAuthFlow(serverName, server.oauth);
+            if (result.error || !result.authUrl) {
+                emitOutput('');
+                emitOutput(chalk.red(`Failed to start auth flow: ${result.error || 'Unknown error'}`));
+                emitOutput('');
+                return;
+            }
+            authUrl = result.authUrl;
+        }
+        else {
+            // Try OAuth discovery, merging with any partial config (clientId/clientSecret)
+            const result = await oauthService.startAuthFlowWithDiscovery(serverName, serverUrl, server.oauth);
+            if (result.error || !result.authUrl) {
+                // Discovery failed - fall back to token prompt
+                emitOutput('');
+                emitOutput(chalk.yellow(`Could not discover OAuth for '${serverName}'.`));
+                emitOutput('');
+                emitOutput(chalk.white('To authenticate, provide your API token:'));
+                emitOutput('');
+                emitOutput(chalk.cyan(`  /mcp auth ${serverName} <your-api-token>`));
+                emitOutput('');
+                emitOutput(chalk.gray('You can usually find your API token in the service\'s settings or developer portal.'));
+                emitOutput('');
+                // Emit event for UI
+                const eventEmitter = getEventEmitter();
+                eventEmitter.emit('mcp-token-required', {
+                    serverName,
+                    message: `Authentication required for '${serverName}'. Provide an API token.`,
+                });
+                return;
+            }
+            authUrl = result.authUrl;
+            discoveredConfig = result.discoveredConfig;
+        }
+        // Open the auth URL in browser automatically
+        emitOutput('');
+        const browserOpened = await openInBrowser(authUrl);
+        if (browserOpened) {
+            emitOutput(chalk.green('  ✓ Opening browser for authentication...'));
+        }
+        else {
+            emitOutput(chalk.yellow('  Could not open browser automatically.'));
+            emitOutput(chalk.white('  Please open this URL manually:'));
+            emitOutput('');
+            emitOutput(chalk.cyan(`  ${authUrl}`));
+        }
+        emitOutput('');
+        emitOutput(chalk.gray('  Waiting for authentication...'));
+        // Poll for completion (the callback server stores the code)
+        const maxWaitMs = 5 * 60 * 1000; // 5 minutes
+        const pollIntervalMs = 1000;
+        const startTime = Date.now();
+        // Use the appropriate OAuth config for completion
+        const oauthConfigForCompletion = server.oauth || discoveredConfig;
+        while (Date.now() - startTime < maxWaitMs) {
+            await new Promise((r) => setTimeout(r, pollIntervalMs));
+            const result = oauthConfigForCompletion
+                ? await oauthService.completeAuthFlowWithConfig(serverName, oauthConfigForCompletion)
+                : { success: false, error: 'No OAuth config available' };
+            if (result.success) {
+                emitOutput('');
+                emitOutput(chalk.green(`✓ Authentication successful for '${serverName}'!`));
+                // Try to reconnect
+                emitOutput(chalk.cyan('  Reconnecting...'));
+                try {
+                    const reconnectManager = getMCPServerManager();
+                    const state = await reconnectManager.connectServer(serverName);
+                    if (state.status === 'connected') {
+                        emitOutput(chalk.green(`✓ Connected - ${state.tools.length} tool(s), ${state.resources.length} resource(s), ${state.prompts.length} prompt(s)`));
+                    }
+                    else if (state.error) {
+                        emitOutput(chalk.yellow(`⚠ ${state.error}`));
+                        // Check if this is a restricted OAuth provider error
+                        if (serverUrl && (state.error.includes('MCP remote server is not enabled') ||
+                            state.error.includes('not enabled') ||
+                            state.error.includes('not authorized'))) {
+                            await displayFallbackInfo(serverUrl, serverName);
+                        }
+                    }
+                }
+                catch (connectError) {
+                    logger.warn(`Failed to reconnect to '${serverName}'`, connectError);
+                    emitOutput(chalk.yellow('⚠ Failed to reconnect. Use /mcp connect to retry.'));
+                }
+                emitOutput('');
+                return;
+            }
+            // If error is NOT "no pending flow", it's a real error
+            if (result.error && !result.error.includes('No pending OAuth flow')) {
+                emitOutput('');
+                emitOutput(chalk.red(`Authentication failed: ${result.error}`));
+                // Check if this is a restricted OAuth provider and show fallback
+                if (serverUrl && (result.error.includes('Forbidden') ||
+                    result.error.includes('not enabled') ||
+                    result.error.includes('not authorized') ||
+                    result.error.includes('client not approved'))) {
+                    await displayFallbackInfo(serverUrl, serverName);
+                }
+                emitOutput('');
+                return;
+            }
+        }
+        emitOutput('');
+        emitOutput(chalk.red('Authentication timed out after 5 minutes.'));
+        emitOutput('');
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        emitOutput(chalk.red(`Failed to authenticate: ${errorMessage}`));
+        // Check if this is a restricted OAuth provider and show fallback
+        if (serverUrl && (errorMessage.includes('Forbidden') ||
+            errorMessage.includes('not enabled') ||
+            errorMessage.includes('not authorized'))) {
+            await displayFallbackInfo(serverUrl, serverName);
+        }
+        emitOutput('');
+    }
+}
+/**
+ * Clears authentication for a server.
+ */
+async function clearAuth(serverName) {
+    if (!serverName) {
+        emitOutput('');
+        emitOutput(chalk.yellow('Please specify a server name: /mcp clear-auth <server-name>'));
+        emitOutput('');
+        return;
+    }
+    try {
+        const oauthService = await getMCPOAuthService();
+        await oauthService.clearAuth(serverName);
+        emitOutput('');
+        emitOutput(chalk.green(`Cleared authentication for ${serverName}`));
+        emitOutput('');
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        emitOutput(chalk.red(`Failed to clear auth: ${errorMessage}`));
+        emitOutput('');
+    }
+}
+/**
+ * Refreshes a server's tools/resources/prompts.
+ */
+async function refreshServer(serverName) {
+    if (!serverName) {
+        emitOutput('');
+        emitOutput(chalk.yellow('Please specify a server name: /mcp refresh <server-name>'));
+        emitOutput('');
+        return;
+    }
+    try {
+        const serverManager = getMCPServerManager();
+        await serverManager.refreshServer(serverName);
+        const state = serverManager.getServerState(serverName);
+        if (state) {
+            emitOutput('');
+            emitOutput(chalk.green(`Refreshed ${serverName}:`));
+            emitOutput(`  ${chalk.gray('Tools:')} ${state.tools.length}`);
+            emitOutput(`  ${chalk.gray('Resources:')} ${state.resources.length}`);
+            emitOutput(`  ${chalk.gray('Prompts:')} ${state.prompts.length}`);
+            emitOutput('');
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        emitOutput(chalk.red(`Failed to refresh: ${errorMessage}`));
+        emitOutput('');
+    }
+}
+/**
+ * Reconnects to a specific server.
+ * Useful for servers that failed to connect or had a timeout.
+ */
+async function reconnectServer(serverName) {
+    if (!serverName) {
+        emitOutput('');
+        emitOutput(chalk.yellow('Please specify a server name: /mcp reconnect <server-name>'));
+        emitOutput('');
+        // Show servers that might need reconnection
+        const serverManager = getMCPServerManager();
+        const states = serverManager.getAllServerStates();
+        const errorServers = states.filter(s => s.status === 'error');
+        if (errorServers.length > 0) {
+            emitOutput(chalk.gray('Servers with errors:'));
+            for (const state of errorServers) {
+                emitOutput(chalk.gray(`  • ${state.config.name}: ${state.error || 'Unknown error'}`));
+            }
+            emitOutput('');
+        }
+        return;
+    }
+    const serverManager = getMCPServerManager();
+    const existingState = serverManager.getServerState(serverName);
+    if (!existingState) {
+        // Server not found in server manager - might need to load config
+        const configManager = getMCPConfigManager();
+        await configManager.load(process.cwd());
+        const server = configManager.getServer(serverName, process.cwd());
+        if (!server) {
+            emitOutput('');
+            emitOutput(chalk.red(`Server not found: ${serverName}`));
+            emitOutput('');
+            emitOutput(chalk.gray('Available servers:'));
+            const states = serverManager.getAllServerStates();
+            for (const state of states) {
+                emitOutput(chalk.gray(`  • ${state.config.name}`));
+            }
+            emitOutput('');
+            return;
+        }
+    }
+    emitOutput('');
+    emitOutput(chalk.cyan(`Reconnecting to ${serverName}...`));
+    // Show helpful message for npx commands
+    const config = existingState?.config;
+    if (config && isMCPStdioConfig(config) && config.command === 'npx') {
+        emitOutput(chalk.gray('First run may take up to 60 seconds to download packages...'));
+    }
+    try {
+        const state = await serverManager.reconnectServer(serverName);
+        if (state.status === 'connected') {
+            emitOutput(chalk.green(`✓ Connected - ${state.tools.length} tool(s), ${state.resources.length} resource(s), ${state.prompts.length} prompt(s)`));
+        }
+        else if (state.status === 'error') {
+            emitOutput(chalk.red(`✗ Failed to connect: ${state.error || 'Unknown error'}`));
+            // Provide helpful hints based on error type
+            if (state.error?.includes('Port') && state.error?.includes('already in use')) {
+                emitOutput('');
+                emitOutput(chalk.yellow('Tip: A previous MCP server process may still be running.'));
+                emitOutput(chalk.gray('  Try waiting a few minutes for it to timeout, or:'));
+                emitOutput(chalk.gray('  Windows: netstat -ano | findstr <port> && taskkill /PID <pid> /F'));
+                emitOutput(chalk.gray('  macOS/Linux: lsof -i :<port> && kill -9 <pid>'));
+            }
+            else if (state.error?.includes('timeout')) {
+                emitOutput('');
+                emitOutput(chalk.yellow('Tip: The server took too long to respond.'));
+                emitOutput(chalk.gray('  Check if the remote service is available.'));
+                emitOutput(chalk.gray('  For npx commands, the first run downloads packages and may be slow.'));
+            }
+            else if (state.error?.includes('Authentication')) {
+                emitOutput('');
+                emitOutput(chalk.yellow('Tip: Authentication may be required.'));
+                emitOutput(chalk.gray(`  Try: /mcp auth ${serverName}`));
+            }
+        }
+        else if (state.error) {
+            emitOutput(chalk.yellow(`⚠ ${state.error}`));
+        }
+        emitOutput('');
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        emitOutput(chalk.red(`Failed to reconnect: ${errorMessage}`));
+        emitOutput('');
+    }
+}
+/**
+ * Approves a project-scoped MCP server.
+ */
+async function approveServer(serverName) {
+    if (!serverName) {
+        emitOutput('');
+        emitOutput(chalk.yellow('Please specify a server name: /mcp approve <server-name>'));
+        emitOutput('');
+        return;
+    }
+    try {
+        const configManager = getMCPConfigManager();
+        await configManager.load(process.cwd());
+        const server = configManager.getServer(serverName, process.cwd());
+        if (!server) {
+            emitOutput('');
+            emitOutput(chalk.red(`Server not found: ${serverName}`));
+            emitOutput('');
+            return;
+        }
+        if (server.scope !== 'project') {
+            emitOutput('');
+            emitOutput(chalk.yellow(`Server '${serverName}' is not a project-scoped server and doesn't require approval.`));
+            emitOutput('');
+            return;
+        }
+        // Generate config hash for change detection
+        const configHash = configManager.generateConfigHash(server);
+        await configManager.setProjectServerApproval(process.cwd(), serverName, true, configHash);
+        emitOutput('');
+        emitOutput(chalk.green(`Approved server '${serverName}'.`));
+        // Auto-connect to the server
+        try {
+            emitOutput(chalk.cyan('Connecting...'));
+            // Show helpful message for npx commands
+            if (isMCPStdioConfig(server) && server.command === 'npx') {
+                emitOutput(chalk.gray('First run may take up to 60 seconds to download packages...'));
+            }
+            const serverManager = getMCPServerManager();
+            const state = await serverManager.connectServer(serverName);
+            if (state.status === 'connected') {
+                emitOutput(chalk.green(`✓ Connected - ${state.tools.length} tool(s), ${state.resources.length} resource(s), ${state.prompts.length} prompt(s)`));
+            }
+            else if (state.error) {
+                emitOutput(chalk.yellow(`⚠ Connection issue: ${state.error}`));
+                emitOutput(chalk.gray('Use /mcp connect to retry.'));
+            }
+        }
+        catch (connectError) {
+            logger.warn(`Failed to auto-connect to '${serverName}'`, connectError);
+            emitOutput(chalk.yellow('⚠ Failed to connect. Use /mcp connect to retry.'));
+        }
+        emitOutput('');
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        emitOutput(chalk.red(`Failed to approve: ${errorMessage}`));
+        emitOutput('');
+    }
+}
+/**
+ * Shows fallback information for a server with restricted OAuth.
+ */
+async function showFallback(serverName) {
+    if (!serverName) {
+        emitOutput('');
+        emitOutput(chalk.yellow('Please specify a server name: /mcp fallback <server-name>'));
+        emitOutput('');
+        return;
+    }
+    // Get server config
+    const serverManager = getMCPServerManager();
+    const serverState = serverManager.getServerState(serverName);
+    let server = serverState?.config;
+    if (!server) {
+        const configManager = getMCPConfigManager();
+        await configManager.load(process.cwd());
+        server = configManager.getServer(serverName, process.cwd());
+    }
+    if (!server) {
+        emitOutput('');
+        emitOutput(chalk.red(`Server not found: ${serverName}`));
+        emitOutput('');
+        return;
+    }
+    // Get server URL
+    let serverUrl;
+    if (isMCPHttpConfig(server) || isMCPSseConfig(server)) {
+        serverUrl = server.url;
+    }
+    if (!serverUrl) {
+        emitOutput('');
+        emitOutput(chalk.yellow(`Server '${serverName}' is not an HTTP/SSE server.`));
+        emitOutput(chalk.gray('Fallback information is only available for remote HTTP servers.'));
+        emitOutput('');
+        return;
+    }
+    const fallback = getFallbackConfig(serverUrl);
+    if (!fallback) {
+        emitOutput('');
+        emitOutput(chalk.green(`Server '${serverName}' does not have known OAuth restrictions.`));
+        emitOutput(chalk.gray('No fallback configuration is registered for this server.'));
+        emitOutput('');
+        return;
+    }
+    await displayFallbackInfo(serverUrl, serverName);
+}
+/**
+ * Denies a project-scoped MCP server.
+ */
+async function denyServer(serverName) {
+    if (!serverName) {
+        emitOutput('');
+        emitOutput(chalk.yellow('Please specify a server name: /mcp deny <server-name>'));
+        emitOutput('');
+        return;
+    }
+    try {
+        const configManager = getMCPConfigManager();
+        await configManager.load(process.cwd());
+        const server = configManager.getServer(serverName, process.cwd());
+        if (!server) {
+            emitOutput('');
+            emitOutput(chalk.red(`Server not found: ${serverName}`));
+            emitOutput('');
+            return;
+        }
+        await configManager.setProjectServerApproval(process.cwd(), serverName, false);
+        emitOutput('');
+        emitOutput(chalk.red(`Denied server '${serverName}'.`));
+        emitOutput(chalk.gray('This server will not be connected.'));
+        emitOutput('');
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        emitOutput(chalk.red(`Failed to deny: ${errorMessage}`));
+        emitOutput('');
+    }
+}
+/**
+ * Handler function for the /mcp slash command.
+ */
+async function mcpCommandHandler(args) {
+    try {
+        const subcommand = args[0]?.toLowerCase();
+        const subArgs = args.slice(1);
+        switch (subcommand) {
+            case 'servers':
+            case 'list':
+                await listServers();
+                break;
+            case 'tools':
+                await listTools();
+                break;
+            case 'resources':
+                await listResources();
+                break;
+            case 'prompts':
+                await listPrompts();
+                break;
+            case 'connect':
+                await connectServers();
+                break;
+            case 'disconnect':
+                await disconnectServers();
+                break;
+            case 'auth':
+            case 'authenticate':
+                // Support: /mcp auth <server-name> [token]
+                await authenticateServer(subArgs[0], subArgs.slice(1).join(' ') || undefined);
+                break;
+            case 'clear-auth':
+                await clearAuth(subArgs[0]);
+                break;
+            case 'refresh':
+                await refreshServer(subArgs[0]);
+                break;
+            case 'reconnect':
+            case 'retry':
+                await reconnectServer(subArgs[0]);
+                break;
+            case 'approve':
+                await approveServer(subArgs[0]);
+                break;
+            case 'deny':
+                await denyServer(subArgs[0]);
+                break;
+            case 'fallback':
+                await showFallback(subArgs[0]);
+                break;
+            case 'help':
+                displayHelp();
+                break;
+            default:
+                await displayStatus();
+                break;
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error('MCP command failed', error);
+        emitOutput('');
+        emitOutput(chalk.red(`Error: ${errorMessage}`));
+        emitOutput('');
+    }
+}
+/**
+ * Displays help for the /mcp command.
+ */
+function displayHelp() {
+    emitOutput('');
+    emitOutput(chalk.bold('MCP Command Help'));
+    emitOutput(chalk.dim('─'.repeat(50)));
+    emitOutput('');
+    emitOutput(chalk.white('/mcp') + chalk.gray('                      - Show server status overview'));
+    emitOutput(chalk.white('/mcp servers') + chalk.gray('              - List all configured servers'));
+    emitOutput(chalk.white('/mcp tools') + chalk.gray('                - List available tools'));
+    emitOutput(chalk.white('/mcp resources') + chalk.gray('            - List available resources'));
+    emitOutput(chalk.white('/mcp prompts') + chalk.gray('              - List available prompts'));
+    emitOutput(chalk.white('/mcp connect') + chalk.gray('              - Connect to all servers'));
+    emitOutput(chalk.white('/mcp reconnect <name>') + chalk.gray('     - Reconnect to a specific server'));
+    emitOutput(chalk.white('/mcp disconnect') + chalk.gray('           - Disconnect from all servers'));
+    emitOutput(chalk.white('/mcp auth <name>') + chalk.gray('          - Start OAuth flow (if configured)'));
+    emitOutput(chalk.white('/mcp auth <name> <token>') + chalk.gray('  - Authenticate with API token'));
+    emitOutput(chalk.white('/mcp clear-auth <name>') + chalk.gray('    - Clear authentication'));
+    emitOutput(chalk.white('/mcp refresh <name>') + chalk.gray('       - Refresh server tools/resources'));
+    emitOutput(chalk.white('/mcp approve <name>') + chalk.gray('       - Approve a project-scoped server'));
+    emitOutput(chalk.white('/mcp deny <name>') + chalk.gray('          - Deny a project-scoped server'));
+    emitOutput(chalk.white('/mcp fallback <name>') + chalk.gray('      - Show fallback options for restricted servers'));
+    emitOutput('');
+}
+/**
+ * Slash command definition for /mcp.
+ */
+export const mcpCommand = {
+    name: 'mcp',
+    description: 'Manage MCP (Model Context Protocol) servers and view status',
+    usage: '/mcp [subcommand]',
+    examples: [
+        '/mcp                      - Show server status overview',
+        '/mcp servers              - List all configured servers',
+        '/mcp tools                - List all available MCP tools',
+        '/mcp connect              - Connect to all configured servers',
+        '/mcp reconnect clickup    - Reconnect to a specific server',
+        '/mcp auth figma           - Start OAuth flow (if configured)',
+        '/mcp auth figma <token>   - Authenticate with API token',
+        '/mcp fallback figma       - Show fallback for restricted OAuth servers',
+    ],
+    handler: mcpCommandHandler,
+};
+/**
+ * Registers the /mcp command with the slash command handler.
+ */
+export function registerMCPCommand() {
+    registerSlashCommand(mcpCommand);
+}
+export default mcpCommand;
+//# sourceMappingURL=mcp.js.map