@compass-ai/nova 1.0.73 → 1.0.74

package/dist/commands/mcp.js

@@ -0,0 +1,687 @@
+/**
+ * MCP command implementation for managing Model Context Protocol servers.
+ *
+ * Commands:
+ * - compass mcp add: Add a new MCP server
+ * - compass mcp add-json: Add server from JSON configuration
+ * - compass mcp list: List all configured servers
+ * - compass mcp get: Get details for a specific server
+ * - compass mcp remove: Remove a server
+ * - compass mcp reset-project-choices: Reset project approval choices
+ * - compass mcp auth-status: Check authentication status of all configured servers
+ * - compass mcp auth: Authenticate with an MCP server (OAuth flow or API token)
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { getMCPConfigManager } from '../services/mcp-config-manager.js';
+import { getMCPOAuthService, getProviderInfo, } from '../services/mcp-oauth-service.js';
+import { logger } from '../utils/logger.js';
+import { isMCPHttpConfig, isMCPSseConfig, isMCPStdioConfig, } from '../types/mcp.js';
+/**
+ * Parses key=value pairs from command line arguments.
+ */
+function parseKeyValuePairs(pairs) {
+    const result = {};
+    for (const pair of pairs) {
+        const [key, ...valueParts] = pair.split('=');
+        if (key && valueParts.length > 0) {
+            result[key] = valueParts.join('=');
+        }
+    }
+    return result;
+}
+/**
+ * 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);
+    }
+}
+/**
+ * Formats scope for display.
+ */
+function formatScope(scope) {
+    switch (scope) {
+        case 'local':
+            return chalk.blue('local');
+        case 'project':
+            return chalk.magenta('project');
+        case 'user':
+            return chalk.cyan('user');
+        default:
+            return chalk.gray(scope);
+    }
+}
+/**
+ * Creates the MCP command with all subcommands.
+ */
+export function createMCPCommand() {
+    const command = new Command('mcp')
+        .description('Manage Model Context Protocol (MCP) servers')
+        .enablePositionalOptions()
+        .passThroughOptions()
+        .addHelpText('after', `
+Examples:
+  ${chalk.gray('# Add an HTTP server')}
+  compass mcp add --transport http notion https://mcp.notion.com/mcp
+
+  ${chalk.gray('# Add an HTTP server with authentication')}
+  compass mcp add --transport http api https://api.example.com/mcp --header "Authorization: Bearer token"
+
+  ${chalk.gray('# Add a local stdio server')}
+  compass mcp add --transport stdio db -- npx -y @bytebase/dbhub --dsn "postgresql://..."
+
+  ${chalk.gray('# Add server with environment variables')}
+  compass mcp add --transport stdio airtable --env AIRTABLE_API_KEY=key -- npx -y airtable-mcp-server
+
+  ${chalk.gray('# List all servers')}
+  compass mcp list
+
+  ${chalk.gray('# Get server details')}
+  compass mcp get notion
+
+  ${chalk.gray('# Remove a server')}
+  compass mcp remove notion
+
+  ${chalk.gray('# Check auth status of all servers (JSON output)')}
+  compass mcp auth-status --json
+
+  ${chalk.gray('# Start OAuth authentication for a server')}
+  compass mcp auth figma --json
+
+  ${chalk.gray('# Set a simple API token for a server')}
+  compass mcp auth notion --token "ntn_abc123..."
+`);
+    // Add subcommand
+    command
+        .command('add <name> [urlOrCommand] [args...]')
+        .description('Add a new MCP server')
+        .requiredOption('-t, --transport <type>', 'Transport type (http, sse, or stdio)')
+        .option('-s, --scope <scope>', 'Configuration scope (local, project, or user)', 'local')
+        .option('-H, --header <header...>', 'HTTP headers (key: value format)')
+        .option('-e, --env <env...>', 'Environment variables (KEY=value format)')
+        .action(async (name, urlOrCommand, args, options) => {
+        try {
+            const transport = options.transport.toLowerCase();
+            if (!['http', 'sse', 'stdio'].includes(transport)) {
+                console.log(chalk.red(`Invalid transport type: ${options.transport}`));
+                console.log(chalk.gray('Valid types: http, sse, stdio'));
+                process.exit(1);
+            }
+            if (!urlOrCommand) {
+                console.log(chalk.red('URL or command is required'));
+                process.exit(1);
+            }
+            const scope = options.scope.toLowerCase();
+            if (!['local', 'project', 'user'].includes(scope)) {
+                console.log(chalk.red(`Invalid scope: ${options.scope}`));
+                console.log(chalk.gray('Valid scopes: local, project, user'));
+                process.exit(1);
+            }
+            // Parse headers
+            let headers;
+            if (options.header) {
+                headers = {};
+                for (const h of options.header) {
+                    const colonIndex = h.indexOf(':');
+                    if (colonIndex > 0) {
+                        const key = h.substring(0, colonIndex).trim();
+                        const value = h.substring(colonIndex + 1).trim();
+                        headers[key] = value;
+                    }
+                }
+            }
+            // Parse environment variables
+            const env = options.env ? parseKeyValuePairs(options.env) : undefined;
+            const configManager = getMCPConfigManager();
+            await configManager.load(process.cwd());
+            const result = await configManager.addServer({
+                transport,
+                name,
+                urlOrCommand,
+                args: transport === 'stdio' ? args : undefined,
+                scope,
+                headers,
+                env,
+            }, process.cwd());
+            if (result.success) {
+                console.log('');
+                console.log(chalk.green(`Added MCP server '${name}'`));
+                console.log(chalk.gray(`  Transport: ${formatServerType(transport)}`));
+                console.log(chalk.gray(`  Scope: ${formatScope(scope)}`));
+                if (transport === 'stdio') {
+                    console.log(chalk.gray(`  Command: ${urlOrCommand} ${args.join(' ')}`));
+                }
+                else {
+                    console.log(chalk.gray(`  URL: ${urlOrCommand}`));
+                }
+                console.log('');
+            }
+            else {
+                console.log(chalk.red(`Failed to add server: ${result.error}`));
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('MCP add command failed', error);
+            console.log(chalk.red(`Failed to add server: ${errorMessage}`));
+            process.exit(1);
+        }
+    });
+    // Add-json subcommand
+    command
+        .command('add-json <name> <json>')
+        .description('Add an MCP server from JSON configuration')
+        .option('-s, --scope <scope>', 'Configuration scope (local, project, or user)', 'local')
+        .action(async (name, json, options) => {
+        try {
+            const scope = options.scope.toLowerCase();
+            if (!['local', 'project', 'user'].includes(scope)) {
+                console.log(chalk.red(`Invalid scope: ${options.scope}`));
+                process.exit(1);
+            }
+            const configManager = getMCPConfigManager();
+            await configManager.load(process.cwd());
+            const result = await configManager.addServerFromJson(name, json, scope, process.cwd());
+            if (result.success) {
+                console.log(chalk.green(`Added MCP server '${name}' from JSON configuration`));
+            }
+            else {
+                console.log(chalk.red(`Failed to add server: ${result.error}`));
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('MCP add-json command failed', error);
+            console.log(chalk.red(`Failed to add server: ${errorMessage}`));
+            process.exit(1);
+        }
+    });
+    // List subcommand
+    command
+        .command('list')
+        .alias('ls')
+        .description('List all configured MCP servers')
+        .option('-v, --verbose', 'Show detailed information')
+        .action(async (options) => {
+        try {
+            const configManager = getMCPConfigManager();
+            await configManager.load(process.cwd());
+            const servers = configManager.getAllServers(process.cwd());
+            if (servers.length === 0) {
+                console.log('');
+                console.log(chalk.gray('No MCP servers configured.'));
+                console.log('');
+                console.log(chalk.gray('Add a server with:'));
+                console.log(chalk.gray('  compass mcp add --transport http <name> <url>'));
+                console.log('');
+                return;
+            }
+            console.log('');
+            console.log(chalk.bold('MCP Servers'));
+            console.log(chalk.dim('─'.repeat(60)));
+            for (const server of servers) {
+                const typeLabel = formatServerType(server.type);
+                const scopeLabel = formatScope(server.scope || 'local');
+                console.log('');
+                console.log(`${chalk.bold(server.name)} ${chalk.gray(`(${typeLabel})`)} ${scopeLabel}`);
+                if (isMCPHttpConfig(server) || isMCPSseConfig(server)) {
+                    console.log(`  ${chalk.gray('URL:')} ${server.url}`);
+                }
+                else if (isMCPStdioConfig(server)) {
+                    const cmdLine = server.args
+                        ? `${server.command} ${server.args.join(' ')}`
+                        : server.command;
+                    console.log(`  ${chalk.gray('Command:')} ${cmdLine}`);
+                }
+                if (options.verbose) {
+                    if (server.env && Object.keys(server.env).length > 0) {
+                        console.log(`  ${chalk.gray('Environment:')} ${Object.keys(server.env).join(', ')}`);
+                    }
+                    if (server.source) {
+                        console.log(`  ${chalk.gray('Source:')} ${server.source}`);
+                    }
+                }
+            }
+            console.log('');
+            console.log(chalk.gray(`Total: ${servers.length} server(s)`));
+            console.log('');
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('MCP list command failed', error);
+            console.log(chalk.red(`Failed to list servers: ${errorMessage}`));
+            process.exit(1);
+        }
+    });
+    // Get subcommand
+    command
+        .command('get <name>')
+        .description('Get details for a specific MCP server')
+        .action(async (name) => {
+        try {
+            const configManager = getMCPConfigManager();
+            await configManager.load(process.cwd());
+            const server = configManager.getServer(name, process.cwd());
+            if (!server) {
+                console.log(chalk.red(`Server not found: ${name}`));
+                process.exit(1);
+            }
+            console.log('');
+            console.log(chalk.bold(`MCP Server: ${server.name}`));
+            console.log(chalk.dim('─'.repeat(40)));
+            console.log(`  ${chalk.gray('Type:')} ${formatServerType(server.type)}`);
+            console.log(`  ${chalk.gray('Scope:')} ${formatScope(server.scope || 'local')}`);
+            if (isMCPHttpConfig(server) || isMCPSseConfig(server)) {
+                console.log(`  ${chalk.gray('URL:')} ${server.url}`);
+                if (server.headers && Object.keys(server.headers).length > 0) {
+                    console.log(`  ${chalk.gray('Headers:')}`);
+                    for (const [key, value] of Object.entries(server.headers)) {
+                        // Mask sensitive headers
+                        const displayValue = key.toLowerCase().includes('authorization')
+                            ? value.substring(0, 20) + '...'
+                            : value;
+                        console.log(`    ${chalk.gray(key)}: ${displayValue}`);
+                    }
+                }
+            }
+            else if (isMCPStdioConfig(server)) {
+                console.log(`  ${chalk.gray('Command:')} ${server.command}`);
+                if (server.args && server.args.length > 0) {
+                    console.log(`  ${chalk.gray('Arguments:')} ${server.args.join(' ')}`);
+                }
+                if (server.cwd) {
+                    console.log(`  ${chalk.gray('Working Directory:')} ${server.cwd}`);
+                }
+            }
+            if (server.env && Object.keys(server.env).length > 0) {
+                console.log(`  ${chalk.gray('Environment Variables:')}`);
+                for (const [key, value] of Object.entries(server.env)) {
+                    // Mask sensitive values
+                    const displayValue = key.toLowerCase().includes('key') ||
+                        key.toLowerCase().includes('secret') ||
+                        key.toLowerCase().includes('token')
+                        ? '***'
+                        : value;
+                    console.log(`    ${chalk.gray(key)}: ${displayValue}`);
+                }
+            }
+            if (server.source) {
+                console.log(`  ${chalk.gray('Source:')} ${server.source}`);
+            }
+            if (server.description) {
+                console.log(`  ${chalk.gray('Description:')} ${server.description}`);
+            }
+            console.log('');
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('MCP get command failed', error);
+            console.log(chalk.red(`Failed to get server: ${errorMessage}`));
+            process.exit(1);
+        }
+    });
+    // Remove subcommand
+    command
+        .command('remove <name>')
+        .alias('rm')
+        .description('Remove an MCP server')
+        .action(async (name) => {
+        try {
+            const configManager = getMCPConfigManager();
+            await configManager.load(process.cwd());
+            const result = await configManager.removeServer(name, process.cwd());
+            if (result.success) {
+                console.log(chalk.green(`Removed MCP server '${name}'`));
+            }
+            else {
+                console.log(chalk.red(result.message));
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('MCP remove command failed', error);
+            console.log(chalk.red(`Failed to remove server: ${errorMessage}`));
+            process.exit(1);
+        }
+    });
+    // Reset project choices subcommand
+    command
+        .command('reset-project-choices')
+        .description('Reset all project MCP server approval choices')
+        .action(async () => {
+        try {
+            const configManager = getMCPConfigManager();
+            await configManager.load(process.cwd());
+            await configManager.resetProjectApprovals();
+            console.log(chalk.green('Reset all project MCP server approval choices'));
+            console.log(chalk.gray('You will be prompted to approve project servers again.'));
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('MCP reset-project-choices command failed', error);
+            console.log(chalk.red(`Failed to reset choices: ${errorMessage}`));
+            process.exit(1);
+        }
+    });
+    // Auth-status subcommand
+    command
+        .command('auth-status')
+        .description('Check authentication status of all configured MCP servers')
+        .option('--json', 'Output in JSON format (for programmatic use)')
+        .action(async (options) => {
+        try {
+            const configManager = getMCPConfigManager();
+            await configManager.load(process.cwd());
+            const servers = configManager.getAllServers(process.cwd());
+            const oauthService = await getMCPOAuthService();
+            const results = [];
+            for (const server of servers) {
+                let serverUrl;
+                if (isMCPHttpConfig(server) || isMCPSseConfig(server)) {
+                    serverUrl = server.url;
+                }
+                const hasStoredAuth = oauthService.hasStoredAuth(server.name);
+                const tokens = oauthService.getTokens(server.name);
+                const apiToken = oauthService.getApiToken(server.name);
+                // Determine if this server likely needs auth
+                const hasOAuthConfig = !!server.oauth;
+                const hasKnownProvider = serverUrl ? !!getProviderInfo(serverUrl) : false;
+                const hasAuthHeader = !!(isMCPHttpConfig(server) || isMCPSseConfig(server)) &&
+                    !!server.headers?.['Authorization'];
+                // A server "needs auth" if it has OAuth config, matches a known provider,
+                // or is an HTTP server without static auth headers that previously required auth
+                const needsAuth = hasOAuthConfig || hasKnownProvider;
+                // Determine method
+                let method = 'none';
+                if (hasOAuthConfig || hasKnownProvider) {
+                    method = 'oauth';
+                }
+                if (apiToken) {
+                    method = 'token';
+                }
+                if (hasAuthHeader) {
+                    method = 'header';
+                }
+                // Check token expiration
+                let tokenExpired;
+                if (tokens) {
+                    if (tokens.expiresAt) {
+                        const expiresAt = new Date(tokens.expiresAt);
+                        tokenExpired = expiresAt.getTime() - 5 * 60 * 1000 <= Date.now();
+                    }
+                    else {
+                        tokenExpired = false;
+                    }
+                }
+                const entry = {
+                    name: server.name,
+                    type: server.type,
+                    needsAuth,
+                    authenticated: hasStoredAuth || hasAuthHeader,
+                    method,
+                };
+                if (serverUrl) {
+                    entry.url = serverUrl;
+                }
+                if (hasKnownProvider && serverUrl) {
+                    entry.oauthRestricted = getProviderInfo(serverUrl)?.oauthRestricted ?? false;
+                }
+                if (tokenExpired !== undefined) {
+                    entry.tokenExpired = tokenExpired;
+                }
+                results.push(entry);
+            }
+            if (options.json) {
+                console.log(JSON.stringify({ servers: results }, null, 2));
+            }
+            else {
+                console.log('');
+                console.log(chalk.bold('MCP Server Authentication Status'));
+                console.log(chalk.dim('─'.repeat(60)));
+                if (results.length === 0) {
+                    console.log(chalk.gray('No MCP servers configured.'));
+                    console.log('');
+                    return;
+                }
+                for (const entry of results) {
+                    const authIcon = entry.authenticated
+                        ? chalk.green('●')
+                        : entry.needsAuth
+                            ? chalk.red('●')
+                            : chalk.gray('○');
+                    const authLabel = entry.authenticated
+                        ? chalk.green('authenticated')
+                        : entry.needsAuth
+                            ? chalk.red('needs auth')
+                            : chalk.gray('no auth required');
+                    console.log('');
+                    console.log(`${authIcon} ${chalk.bold(entry.name)} ${chalk.gray(`(${entry.type})`)} - ${authLabel}`);
+                    if (entry.url) {
+                        console.log(`    ${chalk.gray('URL:')} ${entry.url}`);
+                    }
+                    console.log(`    ${chalk.gray('Method:')} ${entry.method}`);
+                    if (entry.tokenExpired) {
+                        console.log(`    ${chalk.yellow('Token expired - re-authentication needed')}`);
+                    }
+                    if (entry.oauthRestricted) {
+                        console.log(`    ${chalk.yellow('OAuth restricted to approved clients')}`);
+                    }
+                }
+                console.log('');
+                const needingAuth = results.filter(r => r.needsAuth && !r.authenticated);
+                if (needingAuth.length > 0) {
+                    console.log(chalk.yellow(`${needingAuth.length} server(s) need authentication.`));
+                    console.log(chalk.gray('Use: compass mcp auth <server-name>'));
+                }
+                console.log('');
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('MCP auth-status command failed', error);
+            if (options.json) {
+                console.log(JSON.stringify({ error: errorMessage }));
+            }
+            else {
+                console.log(chalk.red(`Failed to check auth status: ${errorMessage}`));
+            }
+            process.exit(1);
+        }
+    });
+    // Auth subcommand
+    command
+        .command('auth <name>')
+        .description('Authenticate with an MCP server (OAuth flow or API token)')
+        .option('--json', 'Output in JSON format (for programmatic use)')
+        .option('--token <token>', 'Set a simple API token instead of OAuth flow')
+        .option('--no-open', 'Do not open the browser automatically')
+        .option('--timeout <ms>', 'OAuth callback timeout in milliseconds', '300000')
+        .action(async (name, options) => {
+        const useJson = !!options.json;
+        try {
+            const configManager = getMCPConfigManager();
+            await configManager.load(process.cwd());
+            const server = configManager.getServer(name, process.cwd());
+            if (!server) {
+                const msg = `Server not found: ${name}`;
+                if (useJson) {
+                    console.log(JSON.stringify({ error: msg }));
+                }
+                else {
+                    console.log(chalk.red(msg));
+                }
+                process.exit(1);
+            }
+            const oauthService = await getMCPOAuthService();
+            // Simple token mode
+            if (options.token) {
+                await oauthService.setApiToken(name, options.token);
+                if (useJson) {
+                    console.log(JSON.stringify({ success: true, method: 'token', serverName: name }));
+                }
+                else {
+                    console.log(chalk.green(`API token stored for '${name}'`));
+                }
+                return;
+            }
+            // OAuth flow
+            let serverUrl;
+            if (isMCPHttpConfig(server) || isMCPSseConfig(server)) {
+                serverUrl = server.url;
+            }
+            if (!serverUrl) {
+                const msg = `Server '${name}' is a stdio server. Use --token to provide an API token.`;
+                if (useJson) {
+                    console.log(JSON.stringify({ error: msg }));
+                }
+                else {
+                    console.log(chalk.red(msg));
+                }
+                process.exit(1);
+            }
+            // Start OAuth flow
+            const hasCompleteOAuthConfig = server.oauth?.authorizationUrl && server.oauth?.tokenUrl;
+            let authUrl;
+            let oauthConfig;
+            if (hasCompleteOAuthConfig) {
+                const result = await oauthService.startAuthFlow(name, server.oauth);
+                if (result.error || !result.authUrl) {
+                    const msg = `Failed to start auth flow: ${result.error || 'Unknown error'}`;
+                    if (useJson) {
+                        console.log(JSON.stringify({ error: msg }));
+                    }
+                    else {
+                        console.log(chalk.red(msg));
+                    }
+                    process.exit(1);
+                }
+                authUrl = result.authUrl;
+                oauthConfig = server.oauth;
+            }
+            else {
+                const result = await oauthService.startAuthFlowWithDiscovery(name, serverUrl, server.oauth);
+                if (result.error || !result.authUrl) {
+                    const msg = result.error || 'Could not discover OAuth configuration. Use --token for API token auth.';
+                    if (useJson) {
+                        console.log(JSON.stringify({ error: msg, needsToken: true }));
+                    }
+                    else {
+                        console.log(chalk.red(msg));
+                    }
+                    process.exit(1);
+                }
+                authUrl = result.authUrl;
+                oauthConfig = result.discoveredConfig || server.oauth;
+            }
+            // Output the auth URL
+            if (useJson) {
+                console.log(JSON.stringify({
+                    status: 'auth_required',
+                    authUrl,
+                    serverName: name,
+                    oauthRestricted: getProviderInfo(serverUrl)?.oauthRestricted ?? false,
+                }));
+            }
+            else {
+                console.log('');
+                console.log(chalk.cyan(`OAuth authentication for ${name}`));
+                console.log('');
+                if (getProviderInfo(serverUrl)?.oauthRestricted) {
+                    console.log(chalk.yellow('Note: This provider restricts OAuth to approved clients.'));
+                    console.log('');
+                }
+                console.log(chalk.white('Open this URL to authenticate:'));
+                console.log('');
+                console.log(`  ${authUrl}`);
+                console.log('');
+            }
+            // Open browser if allowed
+            if (options.open !== false) {
+                const { exec } = await import('child_process');
+                const platform = process.platform;
+                let browserCmd;
+                if (platform === 'win32') {
+                    browserCmd = `start "" "${authUrl}"`;
+                }
+                else if (platform === 'darwin') {
+                    browserCmd = `open "${authUrl}"`;
+                }
+                else {
+                    browserCmd = `xdg-open "${authUrl}"`;
+                }
+                exec(browserCmd, (err) => {
+                    if (err) {
+                        logger.debug(`Failed to open browser: ${err.message}`);
+                    }
+                });
+            }
+            // Poll for OAuth callback completion
+            const timeoutMs = parseInt(options.timeout, 10) || 300000;
+            const pollIntervalMs = 1000;
+            const startTime = Date.now();
+            if (!useJson) {
+                console.log(chalk.gray('Waiting for authentication callback...'));
+            }
+            while (Date.now() - startTime < timeoutMs) {
+                await new Promise((r) => setTimeout(r, pollIntervalMs));
+                const result = oauthConfig
+                    ? await oauthService.completeAuthFlowWithConfig(name, oauthConfig)
+                    : { success: false, error: 'No OAuth config available' };
+                if (result.success) {
+                    if (useJson) {
+                        console.log(JSON.stringify({ status: 'authenticated', serverName: name }));
+                    }
+                    else {
+                        console.log(chalk.green(`Authentication successful for '${name}'!`));
+                    }
+                    return;
+                }
+                // Real error (not just "still waiting")
+                if (result.error && !result.error.includes('No pending OAuth flow')) {
+                    if (useJson) {
+                        console.log(JSON.stringify({ status: 'error', error: result.error, serverName: name }));
+                    }
+                    else {
+                        console.log(chalk.red(`Authentication failed: ${result.error}`));
+                    }
+                    process.exit(1);
+                }
+            }
+            // Timeout
+            const msg = `Authentication timed out after ${timeoutMs / 1000} seconds.`;
+            if (useJson) {
+                console.log(JSON.stringify({ status: 'timeout', error: msg, serverName: name }));
+            }
+            else {
+                console.log(chalk.red(msg));
+            }
+            process.exit(1);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('MCP auth command failed', error);
+            if (useJson) {
+                console.log(JSON.stringify({ error: errorMessage }));
+            }
+            else {
+                console.log(chalk.red(`Failed to authenticate: ${errorMessage}`));
+            }
+            process.exit(1);
+        }
+    });
+    return command;
+}
+export default createMCPCommand;
+//# sourceMappingURL=mcp.js.map