@lanonasis/cli 3.1.13 → 3.3.15

package/dist/utils/mcp-client.js

@@ -5,16 +5,18 @@ import { CLIConfig } from './config.js';
 import * as path from 'path';
 import * as fs from 'fs';
 import { EventSource } from 'eventsource';
-import { fileURLToPath } from 'url';
 import WebSocket from 'ws';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
 export class MCPClient {
     client = null;
     config;
     isConnected = false;
     sseConnection = null;
     wsConnection = null;
+    retryAttempts = 0;
+    maxRetries = 3;
+    healthCheckInterval = null;
+    connectionStartTime = 0;
+    lastHealthCheck = null;
     constructor() {
         this.config = new CLIConfig();
     }
@@ -25,12 +27,22 @@ export class MCPClient {
         await this.config.init();
     }
     /**
-     * Connect to MCP server (local or remote)
+     * Connect to MCP server with retry logic
      */
     async connect(options = {}) {
+        this.retryAttempts = 0;
+        return this.connectWithRetry(options);
+    }
+    /**
+     * Connect to MCP server with retry logic and exponential backoff
+     */
+    async connectWithRetry(options = {}) {
         try {
+            this.connectionStartTime = Date.now();
             // Initialize config if not already done
             await this.init();
+            // Validate authentication before attempting connection
+            await this.validateAuthBeforeConnect();
             // Determine connection mode with priority to explicit mode option
             // Default to 'remote' for better user experience
             const connectionMode = options.connectionMode ??
@@ -49,10 +61,17 @@ export class MCPClient {
                         this.config.getMCPServerUrl() ??
                         'wss://mcp.lanonasis.com/ws';
                     wsUrl = wsUrlValue;
-                    console.log(chalk.cyan(`Connecting to WebSocket MCP server at ${wsUrl}...`));
+                    if (this.retryAttempts === 0) {
+                        console.log(chalk.cyan(`Connecting to WebSocket MCP server at ${wsUrl}...`));
+                    }
+                    else {
+                        console.log(chalk.yellow(`Retry ${this.retryAttempts}/${this.maxRetries}: Connecting to WebSocket MCP server...`));
+                    }
                     // Initialize WebSocket connection
                     await this.initializeWebSocket(wsUrl);
                     this.isConnected = true;
+                    this.retryAttempts = 0;
+                    this.startHealthMonitoring();
                     return true;
                 }
                 case 'remote': {
@@ -62,17 +81,24 @@ export class MCPClient {
                         this.config.getMCPRestUrl() ??
                         'https://mcp.lanonasis.com/api/v1';
                     serverUrl = serverUrlValue;
-                    console.log(chalk.cyan(`Connecting to remote MCP server at ${serverUrl}...`));
+                    if (this.retryAttempts === 0) {
+                        console.log(chalk.cyan(`Connecting to remote MCP server at ${serverUrl}...`));
+                    }
+                    else {
+                        console.log(chalk.yellow(`Retry ${this.retryAttempts}/${this.maxRetries}: Connecting to remote MCP server...`));
+                    }
                     // Initialize SSE connection for real-time updates
                     await this.initializeSSE(serverUrl);
                     this.isConnected = true;
+                    this.retryAttempts = 0;
+                    this.startHealthMonitoring();
                     return true;
                 }
                 default: {
                     // Local MCP server connection (default)
                     const serverPathValue = options.serverPath ??
                         this.config.get('mcpServerPath') ??
-                        path.join(__dirname, '../../../../onasis-gateway/mcp-server/server.js');
+                        path.join(path.resolve(), '../../../../onasis-gateway/mcp-server/server.js');
                     serverPath = serverPathValue;
                     // Check if the server file exists
                     if (!fs.existsSync(serverPath)) {
@@ -81,7 +107,12 @@ export class MCPClient {
                         console.log(chalk.cyan('💡 Or install local server: npm install -g @lanonasis/mcp-server'));
                         throw new Error(`MCP server not found at ${serverPath}`);
                     }
-                    console.log(chalk.cyan(`Connecting to local MCP server at ${serverPath}...`));
+                    if (this.retryAttempts === 0) {
+                        console.log(chalk.cyan(`Connecting to local MCP server at ${serverPath}...`));
+                    }
+                    else {
+                        console.log(chalk.yellow(`Retry ${this.retryAttempts}/${this.maxRetries}: Connecting to local MCP server...`));
+                    }
                     const localTransport = new StdioClientTransport({
                         command: 'node',
                         args: [serverPath]
@@ -92,16 +123,231 @@ export class MCPClient {
                     });
                     await this.client.connect(localTransport);
                     this.isConnected = true;
+                    this.retryAttempts = 0;
                     console.log(chalk.green('✓ Connected to MCP server'));
+                    this.startHealthMonitoring();
                     return true;
                 }
             }
         }
         catch (error) {
-            console.error(chalk.red('Failed to connect to MCP server:'), error);
+            return this.handleConnectionFailure(error, options);
+        }
+    }
+    /**
+     * Handle connection failures with retry logic and specific error messages
+     */
+    async handleConnectionFailure(error, options) {
+        // Check if this is an authentication error (don't retry these)
+        if (this.isAuthenticationError(error)) {
+            console.error(chalk.red('Authentication failed:'), error.message);
+            this.provideAuthenticationGuidance(error);
             this.isConnected = false;
             return false;
         }
+        this.retryAttempts++;
+        if (this.retryAttempts >= this.maxRetries) {
+            console.error(chalk.red(`Failed to connect after ${this.maxRetries} attempts`));
+            this.provideNetworkTroubleshootingGuidance(error);
+            this.isConnected = false;
+            return false;
+        }
+        // For network errors, retry with exponential backoff
+        const delay = await this.exponentialBackoff(this.retryAttempts);
+        console.log(chalk.yellow(`Network error, retrying in ${delay}ms... (${this.retryAttempts}/${this.maxRetries})`));
+        console.log(chalk.gray(`Error: ${error.message}`));
+        await new Promise(resolve => setTimeout(resolve, delay));
+        return this.connectWithRetry(options);
+    }
+    /**
+     * Check if error is authentication-related
+     */
+    isAuthenticationError(error) {
+        const errorMessage = error.message?.toLowerCase() || '';
+        return errorMessage.includes('authentication_required') ||
+            errorMessage.includes('authentication_invalid') ||
+            errorMessage.includes('unauthorized') ||
+            errorMessage.includes('invalid token') ||
+            errorMessage.includes('token is invalid') ||
+            errorMessage.includes('401') ||
+            errorMessage.includes('403') ||
+            (error.response?.status >= 401 && error.response?.status <= 403);
+    }
+    /**
+     * Provide authentication-specific guidance
+     */
+    provideAuthenticationGuidance(error) {
+        console.log(chalk.yellow('\n🔐 Authentication Issue Detected:'));
+        if (error.message?.includes('AUTHENTICATION_REQUIRED')) {
+            console.log(chalk.cyan('• No credentials found. Run: lanonasis auth login'));
+            console.log(chalk.cyan('• Or set vendor key: lanonasis auth login --vendor-key pk_xxx.sk_xxx'));
+        }
+        else if (error.message?.includes('AUTHENTICATION_INVALID')) {
+            console.log(chalk.cyan('• Invalid credentials. Check your vendor key format'));
+            console.log(chalk.cyan('• Expected format: pk_xxx.sk_xxx'));
+            console.log(chalk.cyan('• Try: lanonasis auth logout && lanonasis auth login'));
+        }
+        else if (error.message?.includes('expired')) {
+            console.log(chalk.cyan('• Token expired. Re-authenticate: lanonasis auth login'));
+            console.log(chalk.cyan('• Or refresh: lanonasis auth refresh (if available)'));
+        }
+        else {
+            console.log(chalk.cyan('• Check authentication status: lanonasis auth status'));
+            console.log(chalk.cyan('• Re-authenticate: lanonasis auth login'));
+            console.log(chalk.cyan('• Verify vendor key: lanonasis auth login --vendor-key pk_xxx.sk_xxx'));
+        }
+    }
+    /**
+     * Provide network troubleshooting guidance
+     */
+    provideNetworkTroubleshootingGuidance(error) {
+        console.log(chalk.yellow('\n🌐 Network Issue Detected:'));
+        if (error.message?.includes('ECONNREFUSED') || error.message?.includes('connect ECONNREFUSED')) {
+            console.log(chalk.cyan('• Connection refused. Service may be down:'));
+            console.log(chalk.cyan('  - For remote: Check https://mcp.lanonasis.com/health'));
+            console.log(chalk.cyan('  - For WebSocket: Check wss://mcp.lanonasis.com/ws'));
+            console.log(chalk.cyan('  - For local: Install local MCP server'));
+        }
+        else if (error.message?.includes('timeout') || error.message?.includes('ETIMEDOUT')) {
+            console.log(chalk.cyan('• Connection timeout. Check network:'));
+            console.log(chalk.cyan('  - Verify internet connectivity'));
+            console.log(chalk.cyan('  - Check firewall settings'));
+            console.log(chalk.cyan('  - Try different connection mode: --mode remote'));
+        }
+        else if (error.message?.includes('ENOTFOUND') || error.message?.includes('getaddrinfo')) {
+            console.log(chalk.cyan('• DNS resolution failed:'));
+            console.log(chalk.cyan('  - Check DNS settings'));
+            console.log(chalk.cyan('  - Verify server URL is correct'));
+            console.log(chalk.cyan('  - Try using IP address instead of hostname'));
+        }
+        else if (error.message?.includes('certificate') || error.message?.includes('SSL') || error.message?.includes('TLS')) {
+            console.log(chalk.cyan('• SSL/TLS certificate issue:'));
+            console.log(chalk.cyan('  - Check system time and date'));
+            console.log(chalk.cyan('  - Update CA certificates'));
+            console.log(chalk.cyan('  - Try different connection mode'));
+        }
+        else {
+            console.log(chalk.cyan('• General network error:'));
+            console.log(chalk.cyan('  - Check server status'));
+            console.log(chalk.cyan('  - Verify network connectivity'));
+            console.log(chalk.cyan('  - Try: lanonasis mcp diagnose (when available)'));
+        }
+    }
+    /**
+     * Calculate exponential backoff delay with jitter
+     */
+    async exponentialBackoff(attempt) {
+        // Base delay of 1 second, exponentially increasing
+        const baseDelay = 1000;
+        const exponentialDelay = baseDelay * Math.pow(2, attempt - 1);
+        // Cap at 10 seconds maximum
+        const cappedDelay = Math.min(exponentialDelay, 10000);
+        // Add jitter (±25% randomization) to avoid thundering herd
+        const jitter = cappedDelay * 0.25 * (Math.random() - 0.5);
+        return Math.round(cappedDelay + jitter);
+    }
+    /**
+     * Validate authentication credentials before attempting MCP connection
+     */
+    async validateAuthBeforeConnect() {
+        const token = this.config.get('token');
+        const vendorKey = this.config.get('vendorKey');
+        // Check if we have any authentication credentials
+        if (!token && !vendorKey) {
+            throw new Error('AUTHENTICATION_REQUIRED: No authentication credentials found. Run "lanonasis auth login" first.');
+        }
+        // If we have a token, check if it's expired or needs refresh
+        if (token) {
+            try {
+                await this.validateAndRefreshToken(token);
+            }
+            catch (error) {
+                throw new Error(`AUTHENTICATION_INVALID: ${error instanceof Error ? error.message : 'Token validation failed'}`);
+            }
+        }
+        // If we have a vendor key, validate its format
+        if (vendorKey && !token) {
+            if (!this.validateVendorKeyFormat(vendorKey)) {
+                throw new Error('AUTHENTICATION_INVALID: Invalid vendor key format. Expected format: pk_xxx.sk_xxx');
+            }
+        }
+    }
+    /**
+     * Validate vendor key format
+     */
+    validateVendorKeyFormat(vendorKey) {
+        // Vendor key should be in format: pk_xxx.sk_xxx
+        const vendorKeyPattern = /^pk_[a-zA-Z0-9]+\.sk_[a-zA-Z0-9]+$/;
+        return vendorKeyPattern.test(vendorKey);
+    }
+    /**
+     * Validate and refresh token if needed
+     */
+    async validateAndRefreshToken(token) {
+        try {
+            // Try to decode the JWT token to check expiration
+            const tokenParts = token.split('.');
+            if (tokenParts.length === 3) {
+                const payload = JSON.parse(Buffer.from(tokenParts[1], 'base64').toString());
+                const currentTime = Math.floor(Date.now() / 1000);
+                // Check if token is expired or expires within 5 minutes
+                if (payload.exp && payload.exp < currentTime + 300) {
+                    console.log(chalk.yellow('Token is expired or expiring soon, attempting refresh...'));
+                    await this.refreshTokenIfNeeded();
+                }
+            }
+        }
+        catch (error) {
+            // If we can't decode the token, try to validate it with the server
+            await this.validateTokenWithServer(token);
+        }
+    }
+    /**
+     * Refresh token if needed
+     */
+    async refreshTokenIfNeeded() {
+        const refreshToken = this.config.get('refreshToken');
+        if (!refreshToken) {
+            throw new Error('No refresh token available. Please re-authenticate.');
+        }
+        try {
+            const axios = (await import('axios')).default;
+            const authUrl = this.config.get('authUrl') ?? 'https://api.lanonasis.com';
+            const response = await axios.post(`${authUrl}/auth/refresh`, {
+                refresh_token: refreshToken
+            }, {
+                timeout: 10000
+            });
+            if (response.data.access_token) {
+                await this.config.setAndSave('token', response.data.access_token);
+                console.log(chalk.green('✓ Token refreshed successfully'));
+            }
+        }
+        catch (error) {
+            throw new Error('Failed to refresh token. Please re-authenticate.');
+        }
+    }
+    /**
+     * Validate token with server
+     */
+    async validateTokenWithServer(token) {
+        try {
+            const axios = (await import('axios')).default;
+            const authUrl = this.config.get('authUrl') ?? 'https://api.lanonasis.com';
+            await axios.get(`${authUrl}/auth/validate`, {
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'x-api-key': String(token)
+                },
+                timeout: 10000
+            });
+        }
+        catch (error) {
+            if (error.response?.status === 401 || error.response?.status === 403) {
+                throw new Error('Token is invalid or expired. Please re-authenticate.');
+            }
+            throw new Error(`Token validation failed: ${error.message}`);
+        }
     }
     /**
      * Initialize SSE connection for real-time updates
@@ -208,10 +454,142 @@ export class MCPClient {
         }
         this.wsConnection.send(JSON.stringify(message));
     }
+    /**
+     * Start health monitoring for the connection
+     */
+    startHealthMonitoring() {
+        // Clear any existing health check interval
+        this.stopHealthMonitoring();
+        // Start health monitoring every 30 seconds
+        this.healthCheckInterval = setInterval(async () => {
+            await this.performHealthCheck();
+        }, 30000);
+        // Perform initial health check
+        setTimeout(() => this.performHealthCheck(), 5000);
+    }
+    /**
+     * Stop health monitoring
+     */
+    stopHealthMonitoring() {
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+            this.healthCheckInterval = null;
+        }
+    }
+    /**
+     * Perform a health check on the current connection
+     */
+    async performHealthCheck() {
+        if (!this.isConnected) {
+            return;
+        }
+        try {
+            this.lastHealthCheck = new Date();
+            const connectionMode = this.config.get('mcpConnectionMode') ?? 'remote';
+            switch (connectionMode) {
+                case 'websocket':
+                    await this.checkWebSocketHealth();
+                    break;
+                case 'remote':
+                    await this.checkRemoteHealth();
+                    break;
+                default:
+                    await this.checkLocalHealth();
+                    break;
+            }
+        }
+        catch (error) {
+            console.log(chalk.yellow('⚠️  Health check failed, attempting reconnection...'));
+            await this.handleHealthCheckFailure();
+        }
+    }
+    /**
+     * Check WebSocket connection health
+     */
+    async checkWebSocketHealth() {
+        if (!this.wsConnection || this.wsConnection.readyState !== WebSocket.OPEN) {
+            throw new Error('WebSocket connection not open');
+        }
+        // Send a ping message to check connectivity
+        this.sendWebSocketMessage({
+            id: Date.now(),
+            method: 'ping',
+            params: {}
+        });
+    }
+    /**
+     * Check remote connection health
+     */
+    async checkRemoteHealth() {
+        const apiUrl = this.config.getMCPRestUrl() ?? 'https://mcp.lanonasis.com/api/v1';
+        const token = this.config.get('token');
+        if (!token) {
+            throw new Error('No authentication token available');
+        }
+        try {
+            const axios = (await import('axios')).default;
+            await axios.get(`${apiUrl}/health`, {
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'x-api-key': String(token)
+                },
+                timeout: 5000
+            });
+        }
+        catch (error) {
+            throw new Error(`Remote health check failed: ${error}`);
+        }
+    }
+    /**
+     * Check local connection health
+     */
+    async checkLocalHealth() {
+        if (!this.client) {
+            throw new Error('Local MCP client not initialized');
+        }
+        // Try to list tools as a health check
+        try {
+            await this.client.listTools();
+        }
+        catch (error) {
+            throw new Error(`Local health check failed: ${error}`);
+        }
+    }
+    /**
+     * Handle health check failure by attempting reconnection
+     */
+    async handleHealthCheckFailure() {
+        this.isConnected = false;
+        this.stopHealthMonitoring();
+        // Attempt to reconnect with current configuration
+        const connectionMode = this.config.get('mcpConnectionMode') ?? 'remote';
+        const options = {
+            connectionMode: connectionMode
+        };
+        // Add specific URLs if available
+        if (connectionMode === 'websocket') {
+            options.serverUrl = this.config.get('mcpWebSocketUrl');
+        }
+        else if (connectionMode === 'remote') {
+            options.serverUrl = this.config.get('mcpServerUrl');
+        }
+        else {
+            options.serverPath = this.config.get('mcpServerPath');
+        }
+        // Attempt reconnection
+        const reconnected = await this.connect(options);
+        if (reconnected) {
+            console.log(chalk.green('✓ Reconnected to MCP server'));
+        }
+        else {
+            console.log(chalk.red('✗ Failed to reconnect to MCP server'));
+        }
+    }
     /**
      * Disconnect from MCP server
      */
     async disconnect() {
+        this.stopHealthMonitoring();
         if (this.client) {
             await this.client.close();
             this.client = null;
@@ -220,6 +598,10 @@ export class MCPClient {
             this.sseConnection.close();
             this.sseConnection = null;
         }
+        if (this.wsConnection) {
+            this.wsConnection.close();
+            this.wsConnection = null;
+        }
         this.isConnected = false;
     }
     /**
@@ -372,16 +754,33 @@ export class MCPClient {
         return this.isConnected;
     }
     /**
-     * Get connection status details
+     * Get connection status details with health information
      */
     getConnectionStatus() {
-        const useRemote = this.config.get('mcpUseRemote') ?? false;
+        const connectionMode = this.config.get('mcpConnectionMode') ??
+            (this.config.get('mcpUseRemote') ? 'remote' : 'local');
+        let server;
+        switch (connectionMode) {
+            case 'websocket':
+                server = this.config.get('mcpWebSocketUrl') ?? 'wss://mcp.lanonasis.com/ws';
+                break;
+            case 'remote':
+                server = this.config.get('mcpServerUrl') ?? 'https://mcp.lanonasis.com/api/v1';
+                break;
+            default:
+                server = this.config.get('mcpServerPath') ?? 'local MCP server';
+                break;
+        }
+        const connectionUptime = this.connectionStartTime > 0
+            ? Date.now() - this.connectionStartTime
+            : undefined;
         return {
             connected: this.isConnected,
-            mode: useRemote ? 'remote' : 'local',
-            server: useRemote
-                ? (this.config.get('mcpServerUrl') ?? 'https://api.lanonasis.com')
-                : (this.config.get('mcpServerPath') ?? 'local MCP server')
+            mode: connectionMode,
+            server,
+            lastHealthCheck: this.lastHealthCheck ?? undefined,
+            connectionUptime,
+            failureCount: this.retryAttempts
         };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lanonasis/cli",
-  "version": "3.1.13",
+  "version": "3.3.15",
   "description": "LanOnasis Enterprise CLI - Memory as a Service, API Key Management, and Infrastructure Orchestration",
   "main": "dist/index-simple.js",
   "bin": {
@@ -21,8 +21,8 @@
     "build:mcp-client": "tsc src/mcp/client/enhanced-client.ts --outDir dist/mcp/client",
     "start": "node dist/index.js",
     "start:mcp-server": "node dist/mcp/server/lanonasis-server.js",
-    "test": "jest",
-    "test:mcp": "jest --testPathPattern=mcp",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest",
+    "test:mcp": "NODE_OPTIONS=--experimental-vm-modules jest --testPathPattern=mcp",
     "test:integration": "npm run build:mcp && npm run test:mcp",
     "lint": "eslint src/**/*.ts",
     "type-check": "tsc --noEmit",
@@ -55,7 +55,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/lanonasis/lanonasis-maas.git",
+    "url": "git+https://github.com/lanonasis/lanonasis-maas.git",
     "directory": "cli"
   },
   "bugs": {
@@ -84,11 +84,15 @@
     "ws": "^8.18.3"
   },
   "devDependencies": {
+    "@jest/globals": "^29.7.0",
     "@types/inquirer": "^9.0.7",
+    "@types/jest": "^29.5.14",
     "@types/node": "^22.10.2",
     "@typescript-eslint/eslint-plugin": "^8.18.1",
     "@typescript-eslint/parser": "^8.18.1",
     "eslint": "^9.17.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
     "tsx": "^4.19.2",
     "typescript": "^5.7.2"
   },