@compass-ai/nova 1.0.74 → 1.0.76

package/dist/commands/slash/mcp.js

@@ -1,1026 +0,0 @@
-/**
- * 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