@lanonasis/cli 3.8.0 → 3.9.0

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/mcp/server/lanonasis-server.js

@@ -407,7 +407,15 @@ export class LanonasisMCPServer {
                             text: `Authentication Error: ${error instanceof Error ? error.message : 'Authentication failed'}`
                         }
                     ],
-                    isError: true
+                    isError: true,
+                    task: {
+                        taskId: `${clientId}-${Date.now()}`,
+                        status: 'failed',
+                        ttl: null,
+                        createdAt: new Date().toISOString(),
+                        lastUpdatedAt: new Date().toISOString(),
+                        statusMessage: 'Authentication failed'
+                    }
                 };
             }
             this.updateConnectionActivity(clientId);
@@ -419,7 +427,14 @@ export class LanonasisMCPServer {
                             type: 'text',
                             text: JSON.stringify(result, null, 2)
                         }
-                    ]
+                    ],
+                    task: {
+                        taskId: `${clientId}-${Date.now()}`,
+                        status: 'completed',
+                        ttl: null,
+                        createdAt: new Date().toISOString(),
+                        lastUpdatedAt: new Date().toISOString()
+                    }
                 };
             }
             catch (error) {
@@ -430,7 +445,15 @@ export class LanonasisMCPServer {
                             text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`
                         }
                     ],
-                    isError: true
+                    isError: true,
+                    task: {
+                        taskId: `${clientId}-${Date.now()}`,
+                        status: 'failed',
+                        ttl: null,
+                        createdAt: new Date().toISOString(),
+                        lastUpdatedAt: new Date().toISOString(),
+                        statusMessage: error instanceof Error ? error.message : 'Unknown error'
+                    }
                 };
             }
         });

package/dist/utils/api.js

@@ -99,40 +99,40 @@ export class APIClient {
         });
         return response.data;
     }
-    // Memory operations - aligned with existing schema
-    // All memory endpoints use /api/v1/memory path
+    // Memory operations - aligned with REST API canonical endpoints
+    // All memory endpoints use /api/v1/memories path (plural, per REST conventions)
     async createMemory(data) {
-        const response = await this.client.post('/api/v1/memory', data);
+        const response = await this.client.post('/api/v1/memories', data);
         return response.data;
     }
     async getMemories(params = {}) {
-        const response = await this.client.get('/api/v1/memory', { params });
+        const response = await this.client.get('/api/v1/memories', { params });
         return response.data;
     }
     async getMemory(id) {
-        const response = await this.client.get(`/api/v1/memory/${id}`);
+        const response = await this.client.get(`/api/v1/memories/${id}`);
         return response.data;
     }
     async updateMemory(id, data) {
-        const response = await this.client.put(`/api/v1/memory/${id}`, data);
+        const response = await this.client.put(`/api/v1/memories/${id}`, data);
         return response.data;
     }
     async deleteMemory(id) {
-        await this.client.delete(`/api/v1/memory/${id}`);
+        await this.client.delete(`/api/v1/memories/${id}`);
     }
     async searchMemories(query, options = {}) {
-        const response = await this.client.post('/api/v1/memory/search', {
+        const response = await this.client.post('/api/v1/memories/search', {
             query,
             ...options
         });
         return response.data;
     }
     async getMemoryStats() {
-        const response = await this.client.get('/api/v1/memory/stats');
+        const response = await this.client.get('/api/v1/memories/stats');
         return response.data;
     }
     async bulkDeleteMemories(memoryIds) {
-        const response = await this.client.post('/api/v1/memory/bulk/delete', {
+        const response = await this.client.post('/api/v1/memories/bulk/delete', {
             memory_ids: memoryIds
         });
         return response.data;

package/dist/utils/config.js

@@ -499,7 +499,11 @@ export class CLIConfig {
         }
         // Store a reference marker in config (not the actual key)
         this.config.vendorKey = 'stored_in_api_key_storage';
-        this.config.authMethod = 'vendor_key';
+        // Only set authMethod to 'vendor_key' if not already set to OAuth
+        // This prevents overwriting OAuth auth method when storing the token for MCP access
+        if (!this.config.authMethod || !['oauth', 'oauth2', 'jwt'].includes(this.config.authMethod)) {
+            this.config.authMethod = 'vendor_key';
+        }
         this.config.lastValidated = new Date().toISOString();
         await this.resetFailureCount(); // Reset failure count on successful auth
         await this.save();
@@ -692,11 +696,41 @@ export class CLIConfig {
                 this.authCheckCache = { isValid: true, timestamp: Date.now() };
                 return true;
             }
-            // For vendor keys, we trust that they were validated during setVendorKey()
-            // and rely on the lastValidated timestamp. For additional security,
-            // the server should revoke keys that are invalid.
-            this.authCheckCache = { isValid: true, timestamp: Date.now() };
-            return true;
+            // Vendor key not recently validated - verify with server
+            try {
+                await this.discoverServices();
+                const authBase = this.config.discoveredServices?.auth_base || 'https://auth.lanonasis.com';
+                // Ping auth health with vendor key to verify it's still valid
+                await this.pingAuthHealth(axios, authBase, {
+                    'X-API-Key': vendorKey,
+                    'X-Auth-Method': 'vendor_key',
+                    'X-Project-Scope': 'lanonasis-maas'
+                }, { timeout: 5000, proxy: false });
+                // Update last validated timestamp on success
+                this.config.lastValidated = new Date().toISOString();
+                await this.save().catch(() => { }); // Don't fail auth check if save fails
+                this.authCheckCache = { isValid: true, timestamp: Date.now() };
+                return true;
+            }
+            catch (error) {
+                // Server validation failed - check for grace period (7 days offline)
+                const gracePeriod = 7 * 24 * 60 * 60 * 1000;
+                const withinGracePeriod = lastValidated &&
+                    (Date.now() - new Date(lastValidated).getTime()) < gracePeriod;
+                if (withinGracePeriod) {
+                    if (process.env.CLI_VERBOSE === 'true') {
+                        console.warn('⚠️  Unable to validate vendor key with server, using cached validation');
+                    }
+                    this.authCheckCache = { isValid: true, timestamp: Date.now() };
+                    return true;
+                }
+                // Grace period expired - require server validation
+                if (process.env.CLI_VERBOSE === 'true') {
+                    console.warn('⚠️  Vendor key validation failed and grace period expired');
+                }
+                this.authCheckCache = { isValid: false, timestamp: Date.now() };
+                return false;
+            }
         }
         // Handle token-based authentication
         const token = this.getToken();

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;

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;
+}