@lanonasis/cli 3.8.1 → 3.9.0

package/dist/utils/mcp-client.js

@@ -14,6 +14,8 @@ export class MCPClient {
     retryAttempts = 0;
     maxRetries = 3;
     healthCheckInterval = null;
+    healthCheckTimeout = null;
+    wsReconnectTimeout = null;
     connectionStartTime = 0;
     lastHealthCheck = null;
     activeConnectionMode = 'local'; // Track actual connection mode
@@ -152,6 +154,8 @@ export class MCPClient {
                     else {
                         console.log(chalk.yellow(`Retry ${this.retryAttempts}/${this.maxRetries}: Connecting to remote MCP server...`));
                     }
+                    // Verify remote health before establishing SSE
+                    await this.checkRemoteHealth(serverUrl);
                     // Initialize SSE connection for real-time updates
                     await this.initializeSSE(serverUrl);
                     this.isConnected = true;
@@ -174,7 +178,7 @@ export class MCPClient {
                     // Check if the server file exists
                     if (!fs.existsSync(serverPath)) {
                         console.log(chalk.yellow(`⚠️  Local MCP server not found at ${serverPath}`));
-                        console.log(chalk.cyan('💡 For remote use WebSocket: lanonasis mcp connect --mode websocket --url wss://mcp.lanonasis.com/ws'));
+                        console.log(chalk.cyan('💡 For remote connection, use: lanonasis mcp connect --mode websocket --url wss://mcp.lanonasis.com/ws'));
                         throw new Error(`MCP server not found at ${serverPath}`);
                     }
                     if (this.retryAttempts === 0) {
@@ -248,8 +252,8 @@ export class MCPClient {
             return false;
         }
         this.retryAttempts++;
-        if (this.retryAttempts >= this.maxRetries) {
-            console.error(chalk.red(`Failed to connect after ${this.maxRetries} attempts`));
+        if (this.retryAttempts > this.maxRetries) {
+            console.error(chalk.red(`Failed to connect after ${this.maxRetries + 1} attempts`));
             this.provideNetworkTroubleshootingGuidance(error);
             this.isConnected = false;
             return false;
@@ -356,7 +360,7 @@ export class MCPClient {
      */
     async validateAuthBeforeConnect() {
         const token = this.config.get('token');
-        const vendorKey = this.config.get('vendorKey');
+        const vendorKey = await this.config.getVendorKeyAsync();
         // Check if we have any authentication credentials
         if (!token && !vendorKey) {
             throw new Error('AUTHENTICATION_REQUIRED: No authentication credentials found. Run "lanonasis auth login" first.');
@@ -456,7 +460,7 @@ export class MCPClient {
         // Use the proper SSE endpoint from config
         const sseUrl = this.config.getMCPSSEUrl() ?? `${serverUrl}/events`;
         const token = this.config.get('token');
-        const vendorKey = this.config.get('vendorKey');
+        const vendorKey = await this.config.getVendorKeyAsync();
         const authKey = token || vendorKey || process.env.LANONASIS_API_KEY;
         if (authKey) {
             // EventSource doesn't support headers directly, append token to URL
@@ -480,7 +484,7 @@ export class MCPClient {
      */
     async initializeWebSocket(wsUrl) {
         const token = this.config.get('token');
-        const vendorKey = this.config.get('vendorKey');
+        const vendorKey = await this.config.getVendorKeyAsync();
         const authKey = token || vendorKey || process.env.LANONASIS_API_KEY;
         if (!authKey) {
             throw new Error('API key required for WebSocket mode. Set LANONASIS_API_KEY or login first.');
@@ -534,8 +538,11 @@ export class MCPClient {
                 this.wsConnection.on('close', (code, reason) => {
                     console.log(chalk.yellow(`WebSocket connection closed (${code}): ${reason}`));
                     // Auto-reconnect after delay
-                    setTimeout(() => {
-                        if (this.isConnected) {
+                    if (this.wsReconnectTimeout) {
+                        clearTimeout(this.wsReconnectTimeout);
+                    }
+                    this.wsReconnectTimeout = setTimeout(() => {
+                        if (this.isConnected && process.env.NODE_ENV !== 'test') {
                             console.log(chalk.blue('🔄 Attempting to reconnect to WebSocket...'));
                             this.initializeWebSocket(wsUrl).catch(err => {
                                 console.error('Failed to reconnect:', err);
@@ -569,7 +576,8 @@ export class MCPClient {
             await this.performHealthCheck();
         }, 30000);
         // Perform initial health check
-        setTimeout(() => this.performHealthCheck(), 5000);
+        const initialDelay = process.env.NODE_ENV === 'test' ? 50 : 5000;
+        this.healthCheckTimeout = setTimeout(() => this.performHealthCheck(), initialDelay);
     }
     /**
      * Stop health monitoring
@@ -579,6 +587,10 @@ export class MCPClient {
             clearInterval(this.healthCheckInterval);
             this.healthCheckInterval = null;
         }
+        if (this.healthCheckTimeout) {
+            clearTimeout(this.healthCheckTimeout);
+            this.healthCheckTimeout = null;
+        }
     }
     /**
      * Perform a health check on the current connection
@@ -625,10 +637,10 @@ export class MCPClient {
     /**
      * Check remote connection health
      */
-    async checkRemoteHealth() {
-        const apiUrl = this.config.getMCPRestUrl() ?? 'https://mcp.lanonasis.com/api/v1';
+    async checkRemoteHealth(serverUrl) {
+        const apiUrl = serverUrl ?? this.config.getMCPRestUrl() ?? 'https://mcp.lanonasis.com/api/v1';
         const token = this.config.get('token');
-        const vendorKey = this.config.get('vendorKey');
+        const vendorKey = await this.config.getVendorKeyAsync();
         const authKey = token || vendorKey || process.env.LANONASIS_API_KEY;
         if (!authKey) {
             throw new Error('No authentication token available');
@@ -700,11 +712,14 @@ export class MCPClient {
      */
     async disconnect() {
         this.stopHealthMonitoring();
+        this.isConnected = false;
         if (this.client) {
             await this.client.close();
             this.client = null;
         }
         if (this.sseConnection) {
+            this.sseConnection.onmessage = null;
+            this.sseConnection.onerror = null;
             this.sseConnection.close();
             this.sseConnection = null;
         }
@@ -712,7 +727,10 @@ export class MCPClient {
             this.wsConnection.close();
             this.wsConnection = null;
         }
-        this.isConnected = false;
+        if (this.wsReconnectTimeout) {
+            clearTimeout(this.wsReconnectTimeout);
+            this.wsReconnectTimeout = null;
+        }
         this.activeConnectionMode = 'websocket'; // Reset to default
     }
     /**
@@ -755,7 +773,7 @@ export class MCPClient {
     async callRemoteTool(toolName, args) {
         const apiUrl = this.config.getMCPRestUrl() ?? 'https://mcp.lanonasis.com/api/v1';
         const token = this.config.get('token');
-        const vendorKey = this.config.get('vendorKey');
+        const vendorKey = await this.config.getVendorKeyAsync();
         const authKey = token || vendorKey || process.env.LANONASIS_API_KEY;
         if (!authKey) {
             throw new Error('Authentication required. Run "lanonasis auth login" first.');
@@ -897,7 +915,7 @@ export class MCPClient {
                 break;
         }
         const connectionUptime = this.connectionStartTime > 0
-            ? Date.now() - this.connectionStartTime
+            ? Math.max(Date.now() - this.connectionStartTime, this.isConnected ? 1 : 0)
             : undefined;
         return {
             connected: this.isConnected,

package/dist/ux/implementations/ConnectionManagerImpl.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Connection Manager Implementation
+ *
+ * Manages MCP server discovery, configuration, and connection lifecycle
+ * Implementation of the ConnectionManager interface.
+ */
+import { ConnectionManager, ConnectionResult, ConfigResult, ServerInstance, ConnectionStatus, MCPConfig } from '../interfaces/ConnectionManager.js';
+/**
+ * ConnectionManagerImpl manages MCP server discovery, configuration, and connection lifecycle
+ *
+ * This implementation automatically detects the embedded MCP server location within the CLI package,
+ * generates configuration files with correct server paths, and manages server processes.
+ */
+export declare class ConnectionManagerImpl implements ConnectionManager {
+    private config;
+    private connectionStatus;
+    private serverProcess;
+    private configPath;
+    constructor(configPath?: string);
+    /**
+     * Initialize the connection manager by loading persisted configuration
+     */
+    init(): Promise<void>;
+    /**
+     * Connect to the local embedded MCP server
+     */
+    connectLocal(): Promise<ConnectionResult>;
+    /**
+     * Automatically configure the local MCP server with correct paths
+     */
+    autoConfigureLocalServer(): Promise<ConfigResult>;
+    /**
+     * Detect the embedded MCP server path within the CLI package
+     */
+    detectServerPath(): Promise<string | null>;
+    /**
+     * Start the local MCP server process
+     */
+    startLocalServer(): Promise<ServerInstance>;
+    /**
+     * Verify that the MCP server connection is working
+     */
+    verifyConnection(serverPath: string): Promise<boolean>;
+    /**
+     * Get the current connection status
+     */
+    getConnectionStatus(): ConnectionStatus;
+    /**
+     * Stop the local MCP server if running
+     */
+    stopLocalServer(): Promise<void>;
+    /**
+     * Get the current MCP configuration
+     */
+    getConfig(): MCPConfig;
+    /**
+     * Update the MCP configuration
+     */
+    updateConfig(config: Partial<MCPConfig>): Promise<void>;
+    /**
+     * Check if the server is currently running
+     */
+    private isServerRunning;
+    /**
+     * Save the current configuration to disk
+     */
+    private saveConfig;
+    /**
+     * Load configuration from disk
+     */
+    private loadConfig;
+}

package/dist/ux/implementations/ConnectionManagerImpl.js

@@ -0,0 +1,352 @@
+/**
+ * Connection Manager Implementation
+ *
+ * Manages MCP server discovery, configuration, and connection lifecycle
+ * Implementation of the ConnectionManager interface.
+ */
+import { promises as fs, createWriteStream } from 'fs';
+import { join, dirname, resolve } from 'path';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+/**
+ * Default MCP configuration
+ */
+const DEFAULT_MCP_CONFIG = {
+    localServerPath: '',
+    serverPort: 3000,
+    autoStart: true,
+    connectionTimeout: 10000,
+    retryAttempts: 3,
+    logLevel: 'info',
+};
+/**
+ * ConnectionManagerImpl manages MCP server discovery, configuration, and connection lifecycle
+ *
+ * This implementation automatically detects the embedded MCP server location within the CLI package,
+ * generates configuration files with correct server paths, and manages server processes.
+ */
+export class ConnectionManagerImpl {
+    config;
+    connectionStatus;
+    serverProcess = null;
+    configPath;
+    constructor(configPath) {
+        this.config = { ...DEFAULT_MCP_CONFIG };
+        this.configPath = configPath || join(process.cwd(), '.lanonasis', 'mcp-config.json');
+        this.connectionStatus = {
+            isConnected: false,
+            connectionAttempts: 0,
+        };
+    }
+    /**
+     * Initialize the connection manager by loading persisted configuration
+     */
+    async init() {
+        await this.loadConfig();
+    }
+    /**
+     * Connect to the local embedded MCP server
+     */
+    async connectLocal() {
+        try {
+            // Load persisted configuration first
+            await this.loadConfig();
+            // First, try to detect the server path
+            const configuredPath = this.config.localServerPath?.trim();
+            const serverPath = configuredPath || (await this.detectServerPath());
+            if (!serverPath) {
+                return {
+                    success: false,
+                    error: 'Could not detect local MCP server path',
+                    suggestions: [
+                        'Ensure the CLI package is properly installed',
+                        'Check that the MCP server files are present',
+                        'Try running: lanonasis init',
+                    ],
+                };
+            }
+            // Update configuration with detected path
+            this.config.localServerPath = serverPath;
+            await this.saveConfig();
+            // Start the server if not already running
+            if (!this.isServerRunning()) {
+                const serverInstance = await this.startLocalServer();
+                this.connectionStatus.serverInstance = serverInstance;
+            }
+            // Verify the connection
+            const isConnected = await this.verifyConnection(serverPath);
+            if (isConnected) {
+                this.connectionStatus.isConnected = true;
+                this.connectionStatus.lastConnected = new Date();
+                this.connectionStatus.connectionAttempts++;
+                return {
+                    success: true,
+                    serverPath,
+                };
+            }
+            else {
+                this.connectionStatus.connectionAttempts++;
+                return {
+                    success: false,
+                    error: 'Failed to verify MCP server connection',
+                    suggestions: [
+                        'Check server logs for errors',
+                        'Ensure no other process is using the port',
+                        'Try restarting the CLI',
+                    ],
+                };
+            }
+        }
+        catch (error) {
+            this.connectionStatus.connectionAttempts++;
+            this.connectionStatus.lastError = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
+                suggestions: [
+                    'Check your network connection',
+                    'Verify the MCP server is installed correctly',
+                    'Try running: lanonasis mcp diagnose',
+                ],
+            };
+        }
+    }
+    /**
+     * Automatically configure the local MCP server with correct paths
+     */
+    async autoConfigureLocalServer() {
+        try {
+            const serverPath = await this.detectServerPath();
+            if (!serverPath) {
+                return {
+                    success: false,
+                    error: 'Could not detect MCP server path for auto-configuration',
+                };
+            }
+            // Update configuration
+            this.config.localServerPath = serverPath;
+            // Ensure config directory exists
+            await fs.mkdir(dirname(this.configPath), { recursive: true });
+            // Save configuration
+            await this.saveConfig();
+            return {
+                success: true,
+                configPath: this.configPath,
+                serverPath,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Auto-configuration failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    /**
+     * Detect the embedded MCP server path within the CLI package
+     */
+    async detectServerPath() {
+        try {
+            // Get the current module directory
+            const currentDir = dirname(fileURLToPath(import.meta.url));
+            // Common paths to check for the MCP server
+            const candidatePaths = [
+                // Relative to current CLI source
+                resolve(currentDir, '../../mcp-server-entry.js'),
+                resolve(currentDir, '../../../dist/mcp-server-entry.js'),
+                // Relative to CLI package root
+                resolve(currentDir, '../../../mcp-server-entry.js'),
+                resolve(currentDir, '../../dist/mcp-server-entry.js'),
+                // In node_modules (if installed as dependency)
+                resolve(process.cwd(), 'node_modules/@lanonasis/cli/dist/mcp-server-entry.js'),
+                // Global installation paths
+                resolve(process.cwd(), 'dist/mcp-server-entry.js'),
+                // Development paths
+                resolve(process.cwd(), 'cli/dist/mcp-server-entry.js'),
+                resolve(process.cwd(), '../cli/dist/mcp-server-entry.js'),
+            ];
+            // Check each candidate path
+            for (const candidatePath of candidatePaths) {
+                try {
+                    await fs.access(candidatePath);
+                    // Verify it's actually the MCP server by checking file content
+                    const content = await fs.readFile(candidatePath, 'utf-8');
+                    if (content.includes('mcp') || content.includes('server')) {
+                        return candidatePath;
+                    }
+                }
+                catch {
+                    // Path doesn't exist or isn't accessible, continue
+                }
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('Error detecting server path:', error);
+            return null;
+        }
+    }
+    /**
+     * Start the local MCP server process
+     */
+    async startLocalServer() {
+        if (!this.config.localServerPath) {
+            throw new Error('No local server path configured');
+        }
+        return new Promise((resolve, reject) => {
+            const serverProcess = spawn('node', [this.config.localServerPath], {
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: {
+                    ...process.env,
+                    PORT: this.config.serverPort?.toString() || '3000',
+                    LOG_LEVEL: this.config.logLevel,
+                },
+            });
+            const serverInstance = {
+                pid: serverProcess.pid,
+                port: this.config.serverPort || 3000,
+                status: 'starting',
+                startTime: new Date(),
+                logPath: join(dirname(this.configPath), 'mcp-server.log'),
+            };
+            // Set up logging
+            const logStream = createWriteStream(serverInstance.logPath, { flags: 'a' });
+            serverProcess.stdout?.pipe(logStream);
+            serverProcess.stderr?.pipe(logStream);
+            // Handle server startup
+            const startupTimeout = setTimeout(() => {
+                serverInstance.status = 'error';
+                reject(new Error('Server startup timeout'));
+            }, this.config.connectionTimeout);
+            serverProcess.on('spawn', () => {
+                clearTimeout(startupTimeout);
+                serverInstance.status = 'running';
+                this.serverProcess = serverProcess;
+                resolve(serverInstance);
+            });
+            serverProcess.on('error', (error) => {
+                clearTimeout(startupTimeout);
+                serverInstance.status = 'error';
+                reject(error);
+            });
+            serverProcess.on('exit', (code) => {
+                serverInstance.status = code === 0 ? 'stopped' : 'error';
+                this.serverProcess = null;
+            });
+        });
+    }
+    /**
+     * Verify that the MCP server connection is working
+     */
+    async verifyConnection(serverPath) {
+        try {
+            // Simple verification - check if server path exists and is accessible
+            await fs.access(serverPath);
+            // If we have a running server instance, check if it's responsive
+            if (this.connectionStatus.serverInstance) {
+                const { status, pid } = this.connectionStatus.serverInstance;
+                // Explicitly check for error/stopped states
+                if (status === 'error' || status === 'stopped') {
+                    return false;
+                }
+                // Only verify process for running servers
+                if (status === 'running') {
+                    try {
+                        process.kill(pid, 0); // Signal 0 checks if process exists
+                        return true;
+                    }
+                    catch {
+                        // Process doesn't exist despite status being 'running'
+                        this.connectionStatus.serverInstance.status = 'stopped';
+                        return false;
+                    }
+                }
+                // Starting state is not yet ready
+                if (status === 'starting') {
+                    return false;
+                }
+            }
+            // No server instance means we haven't started it yet
+            // This is okay for initial connection attempts
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get the current connection status
+     */
+    getConnectionStatus() {
+        return { ...this.connectionStatus };
+    }
+    /**
+     * Stop the local MCP server if running
+     */
+    async stopLocalServer() {
+        if (this.serverProcess) {
+            return new Promise((resolve) => {
+                const forceKillTimeout = setTimeout(() => {
+                    if (this.serverProcess) {
+                        this.serverProcess.kill('SIGKILL');
+                    }
+                }, 5000);
+                this.serverProcess.on('exit', () => {
+                    clearTimeout(forceKillTimeout);
+                    this.serverProcess = null;
+                    if (this.connectionStatus.serverInstance) {
+                        this.connectionStatus.serverInstance.status = 'stopped';
+                    }
+                    this.connectionStatus.isConnected = false;
+                    resolve();
+                });
+                this.serverProcess.kill('SIGTERM');
+            });
+        }
+    }
+    /**
+     * Get the current MCP configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update the MCP configuration
+     */
+    async updateConfig(config) {
+        this.config = { ...this.config, ...config };
+        await this.saveConfig();
+    }
+    /**
+     * Check if the server is currently running
+     */
+    isServerRunning() {
+        return (this.serverProcess !== null && this.connectionStatus.serverInstance?.status === 'running');
+    }
+    /**
+     * Save the current configuration to disk
+     */
+    async saveConfig() {
+        try {
+            await fs.mkdir(dirname(this.configPath), { recursive: true });
+            await fs.writeFile(this.configPath, JSON.stringify(this.config, null, 2));
+        }
+        catch (error) {
+            throw new Error(`Failed to save configuration: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Load configuration from disk
+     */
+    async loadConfig() {
+        try {
+            const configData = await fs.readFile(this.configPath, 'utf-8');
+            const loadedConfig = JSON.parse(configData);
+            this.config = { ...DEFAULT_MCP_CONFIG, ...loadedConfig };
+        }
+        catch {
+            // Config file doesn't exist or is invalid, use defaults
+            this.config = { ...DEFAULT_MCP_CONFIG };
+        }
+    }
+}

package/dist/ux/implementations/OnboardingFlowImpl.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Onboarding Flow Implementation
+ *
+ * Guides new users through initial setup and configuration
+ * Implementation of the OnboardingFlow interface.
+ */
+import { OnboardingFlow, SetupResult, TestResult, UserPreferences, OnboardingState } from '../interfaces/OnboardingFlow.js';
+/**
+ * OnboardingFlowImpl guides new users through initial setup and configuration
+ *
+ * This implementation detects first-run scenarios, creates working default configurations,
+ * tests all major functionality, and provides interactive demonstrations.
+ */
+export declare class OnboardingFlowImpl implements OnboardingFlow {
+    private onboardingState;
+    private configPath;
+    private connectionManager;
+    private textInputHandler;
+    constructor(configPath?: string);
+    /**
+     * Run the complete initial setup process for new users
+     */
+    runInitialSetup(): Promise<SetupResult>;
+    /**
+     * Detect if this is a first-run scenario
+     */
+    detectFirstRun(): boolean;
+    /**
+     * Configure working default settings for immediate productivity
+     */
+    configureDefaults(): Promise<void>;
+    /**
+     * Test connectivity and functionality of all major components
+     */
+    testConnectivity(): Promise<TestResult[]>;
+    /**
+     * Show welcome demonstration of key features
+     */
+    showWelcomeDemo(): Promise<void>;
+    /**
+     * Get the current onboarding state
+     */
+    getOnboardingState(): OnboardingState;
+    /**
+     * Update user preferences during onboarding
+     */
+    updateUserPreferences(preferences: Partial<UserPreferences>): Promise<void>;
+    /**
+     * Skip the current onboarding step
+     */
+    skipCurrentStep(reason?: string): Promise<void>;
+    /**
+     * Complete the onboarding process
+     */
+    completeOnboarding(): Promise<void>;
+    /**
+     * Reset onboarding state (for testing or re-running)
+     */
+    resetOnboarding(): Promise<void>;
+    /**
+     * Gather user preferences interactively
+     */
+    private gatherUserPreferences;
+    /**
+     * Save the current onboarding state to disk
+     */
+    private saveOnboardingState;
+    /**
+     * Load onboarding state from disk
+     */
+    private loadOnboardingState;
+}