@lanonasis/cli 3.8.1 → 3.9.1

package/dist/mcp/schemas/tool-schemas.d.ts

@@ -201,14 +201,14 @@ export declare const SystemConfigSchema: z.ZodObject<{
     scope: z.ZodDefault<z.ZodEnum<["user", "global"]>>;
 }, "strip", z.ZodTypeAny, {
     value?: any;
+    key?: string;
     action?: "get" | "set" | "reset";
     scope?: "user" | "global";
-    key?: string;
 }, {
     value?: any;
+    key?: string;
     action?: "get" | "set" | "reset";
     scope?: "user" | "global";
-    key?: string;
 }>;
 export declare const BulkOperationSchema: z.ZodObject<{
     operation: z.ZodEnum<["create", "update", "delete"]>;
@@ -579,14 +579,14 @@ export declare const MCPSchemas: {
             scope: z.ZodDefault<z.ZodEnum<["user", "global"]>>;
         }, "strip", z.ZodTypeAny, {
             value?: any;
+            key?: string;
             action?: "get" | "set" | "reset";
             scope?: "user" | "global";
-            key?: string;
         }, {
             value?: any;
+            key?: string;
             action?: "get" | "set" | "reset";
             scope?: "user" | "global";
-            key?: string;
         }>;
     };
     operations: {

package/dist/utils/api.js

@@ -60,7 +60,17 @@ export class APIClient {
                 const { status, data } = error.response;
                 if (status === 401) {
                     console.error(chalk.red('✖ Authentication failed'));
-                    console.log(chalk.yellow('Please run:'), chalk.white('memory login'));
+                    // Check if user is using OAuth - OAuth tokens only work with MCP, not direct API
+                    const authMethod = this.config.get('authMethod');
+                    if (authMethod === 'oauth') {
+                        console.log(chalk.yellow('\nNote: OAuth tokens are for MCP integration only.'));
+                        console.log(chalk.gray('For direct API access, you have two options:'));
+                        console.log(chalk.gray('  1. Get a vendor key from the dashboard: ') + chalk.cyan('lanonasis auth login --vendor'));
+                        console.log(chalk.gray('  2. Login with username/password: ') + chalk.cyan('lanonasis auth login --credentials'));
+                    }
+                    else {
+                        console.log(chalk.yellow('Please run:'), chalk.white('lanonasis auth login'));
+                    }
                     process.exit(1);
                 }
                 if (status === 403) {

package/dist/utils/mcp-client.d.ts

@@ -53,6 +53,8 @@ export declare class MCPClient {
     private retryAttempts;
     private maxRetries;
     private healthCheckInterval;
+    private healthCheckTimeout;
+    private wsReconnectTimeout;
     private connectionStartTime;
     private lastHealthCheck;
     private activeConnectionMode;
@@ -189,6 +191,11 @@ export declare class MCPClient {
      * Check if connected to MCP server
      */
     isConnectedToServer(): boolean;
+    /**
+     * Determine whether tool operations should use the remote REST bridge.
+     * WebSocket mode uses the same bridge for tool list/call operations.
+     */
+    private shouldUseRemoteToolBridge;
     /**
      * Get connection status details with health information
      */

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
@@ -66,6 +68,7 @@ export class MCPClient {
             // Save the successful connection mode as preference
             this.config.set('mcpConnectionMode', mode);
             this.config.set('mcpPreference', mode);
+            this.config.set('mcpUseRemote', mode === 'remote' || mode === 'websocket');
             // Save the specific URL that worked
             if (url) {
                 if (mode === 'websocket') {
@@ -152,6 +155,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 +179,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 +253,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 +361,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 +461,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 +485,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.');
@@ -521,7 +526,12 @@ export class MCPClient {
                 this.wsConnection.on('message', (data) => {
                     try {
                         const message = JSON.parse(data.toString());
-                        console.log(chalk.blue('📡 MCP message:'), message.id, message.method || 'response');
+                        const messageId = message.id ?? 'event';
+                        const messageType = message.method
+                            || (message.error ? 'error' : undefined)
+                            || (message.result ? 'result' : undefined)
+                            || 'response';
+                        console.log(chalk.blue('📡 MCP message:'), messageId, messageType);
                     }
                     catch (error) {
                         console.error('Failed to parse WebSocket message:', error);
@@ -534,8 +544,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 +582,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 +593,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 +643,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 +718,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 +733,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
     }
     /**
@@ -722,7 +746,7 @@ export class MCPClient {
         if (!this.isConnected) {
             throw new Error('Not connected to MCP server. Run "lanonasis mcp connect" first.');
         }
-        const useRemote = this.config.get('mcpUseRemote') ?? false;
+        const useRemote = this.shouldUseRemoteToolBridge();
         if (useRemote) {
             // Remote MCP calls are translated to REST API calls
             return await this.callRemoteTool(toolName, args);
@@ -755,7 +779,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.');
@@ -836,7 +860,7 @@ export class MCPClient {
         if (!this.isConnected) {
             throw new Error('Not connected to MCP server');
         }
-        const useRemote = this.config.get('mcpUseRemote') ?? false;
+        const useRemote = this.shouldUseRemoteToolBridge();
         if (useRemote) {
             // Return hardcoded list for remote mode
             return [
@@ -865,6 +889,16 @@ export class MCPClient {
     isConnectedToServer() {
         return this.isConnected;
     }
+    /**
+     * Determine whether tool operations should use the remote REST bridge.
+     * WebSocket mode uses the same bridge for tool list/call operations.
+     */
+    shouldUseRemoteToolBridge() {
+        if (this.activeConnectionMode === 'remote' || this.activeConnectionMode === 'websocket') {
+            return true;
+        }
+        return this.config.get('mcpUseRemote') ?? false;
+    }
     /**
      * Get connection status details with health information
      */
@@ -897,7 +931,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;
+}