@lanonasis/cli 1.5.0 → 1.5.1

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

@@ -2,27 +2,70 @@ interface MCPConnectionOptions {
     serverPath?: string;
     serverUrl?: string;
     useRemote?: boolean;
-    mode?: 'local' | 'remote' | 'websocket';
+    useWebSocket?: boolean;
+    connectionMode?: 'local' | 'remote' | 'websocket';
+}
+/**
+ * Interface for MCP tool arguments
+ */
+interface MCPToolArgs {
+    [key: string]: unknown;
+}
+/**
+ * Interface for MCP tool response
+ */
+export interface MCPToolResponse {
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+    };
+    id?: string;
+    title?: string;
+    memory_type?: string;
+    length?: number;
+    forEach?: (callback: (item: any, index: number) => void) => void;
+    code?: number;
+    message?: string;
+    response?: any;
+}
+/**
+ * Interface for MCP WebSocket messages
+ */
+export interface MCPWebSocketMessage {
+    id: number;
+    method?: string;
+    params?: Record<string, unknown>;
+    result?: Record<string, unknown>;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
 }
 export declare class MCPClient {
     private client;
     private config;
     private isConnected;
     private sseConnection;
-    private wsClient;
+    private wsConnection;
     constructor();
     /**
      * Connect to MCP server (local or remote)
      */
     connect(options?: MCPConnectionOptions): Promise<boolean>;
     /**
-     * Initialize WebSocket MCP connection for enterprise users
+     * Initialize SSE connection for real-time updates
+     */
+    private initializeSSE;
+    /**
+     * Initialize WebSocket connection for enterprise MCP server
      */
     private initializeWebSocket;
     /**
-     * Initialize SSE connection for real-time updates
+     * Send a message over the WebSocket connection
      */
-    private initializeSSE;
+    private sendWebSocketMessage;
     /**
      * Disconnect from MCP server
      */
@@ -30,7 +73,7 @@ export declare class MCPClient {
     /**
      * Call an MCP tool
      */
-    callTool(toolName: string, args: any): Promise<any>;
+    callTool(toolName: string, args: MCPToolArgs): Promise<MCPToolResponse>;
     /**
      * Call remote tool via REST API with MCP interface
      */

package/dist/utils/mcp-client.js

@@ -5,7 +5,7 @@ import { CLIConfig } from './config.js';
 import * as path from 'path';
 import { EventSource } from 'eventsource';
 import { fileURLToPath } from 'url';
-import { output } from './output.js';
+import WebSocket from 'ws';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 export class MCPClient {
@@ -13,7 +13,7 @@ export class MCPClient {
     config;
     isConnected = false;
     sseConnection = null;
-    wsClient = null;
+    wsConnection = null;
     constructor() {
         this.config = new CLIConfig();
     }
@@ -22,81 +22,67 @@ export class MCPClient {
      */
     async connect(options = {}) {
         try {
-            // Support new mode parameter or fallback to legacy useRemote
-            const mode = options.mode ?? (options.useRemote ? 'remote' : 'local');
-            const useRemote = mode !== 'local';
-            if (useRemote) {
-                if (mode === 'websocket') {
-                    // WebSocket MCP connection for enterprise users
-                    const wsUrl = options.serverUrl ?? 'wss://mcp.lanonasis.com/mcp';
-                    if (!output.isSilent()) {
-                        output.log(chalk.cyan(`Connecting to WebSocket MCP server at ${wsUrl}...`));
-                    }
-                    // Initialize WebSocket MCP connection
+            // Determine connection mode with priority to explicit mode option
+            const connectionMode = options.connectionMode ??
+                (options.useWebSocket ? 'websocket' :
+                    options.useRemote ? 'remote' :
+                        this.config.get('mcpConnectionMode') ??
+                            this.config.get('mcpUseRemote') ? 'remote' : 'local');
+            let wsUrl;
+            let serverUrl;
+            let serverPath;
+            switch (connectionMode) {
+                case 'websocket':
+                    // WebSocket connection mode for enterprise users
+                    wsUrl = options.serverUrl ??
+                        this.config.get('mcpWebSocketUrl') ??
+                        'ws://localhost:8081/mcp/ws';
+                    console.log(chalk.cyan(`Connecting to WebSocket MCP server at ${wsUrl}...`));
+                    // Initialize WebSocket connection
                     await this.initializeWebSocket(wsUrl);
-                }
-                else {
-                    // SSE MCP connection for regular users
-                    const serverUrl = options.serverUrl ?? this.config.get('mcpServerUrl') ?? 'https://api.lanonasis.com';
-                    if (!output.isSilent()) {
-                        output.log(chalk.cyan(`Connecting to remote MCP server at ${serverUrl}...`));
-                    }
+                    this.isConnected = true;
+                    return true;
+                case 'remote':
+                    // For remote MCP, we'll use the REST API with MCP-style interface
+                    serverUrl = options.serverUrl ??
+                        this.config.get('mcpServerUrl') ??
+                        'https://api.lanonasis.com';
+                    console.log(chalk.cyan(`Connecting to remote MCP server at ${serverUrl}...`));
                     // Initialize SSE connection for real-time updates
                     await this.initializeSSE(serverUrl);
-                }
-                this.isConnected = true;
-                return true;
-            }
-            else {
-                // Local MCP server connection
-                const serverPath = options.serverPath ?? this.config.get('mcpServerPath') ?? path.join(__dirname, '../../../../onasis-gateway/mcp-server/server.js');
-                if (!output.isSilent()) {
-                    output.log(chalk.cyan(`Connecting to local MCP server at ${serverPath}...`));
-                }
-                const transport = new StdioClientTransport({
-                    command: 'node',
-                    args: [serverPath]
-                });
-                this.client = new Client({
-                    name: '@lanonasis/cli',
-                    version: '1.0.0'
-                }, {
-                    capabilities: {}
-                });
-                await this.client.connect(transport);
-                this.isConnected = true;
-                if (!output.isSilent()) {
-                    output.log(chalk.green('✓ Connected to MCP server'));
-                }
-                return true;
+                    this.isConnected = true;
+                    return true;
+                case 'local':
+                default:
+                    {
+                        // Local MCP server connection
+                        serverPath = options.serverPath ??
+                            this.config.get('mcpServerPath') ??
+                            path.join(__dirname, '../../../../onasis-gateway/mcp-server/server.js');
+                        console.log(chalk.cyan(`Connecting to local MCP server at ${serverPath}...`));
+                        const localTransport = new StdioClientTransport({
+                            command: 'node',
+                            args: [serverPath]
+                        });
+                        this.client = new Client({
+                            name: '@lanonasis/cli',
+                            version: '1.0.0'
+                        }, {
+                            capabilities: {}
+                        });
+                        await this.client.connect(localTransport);
+                    }
+                    this.isConnected = true;
+                    console.log(chalk.green('✓ Connected to MCP server'));
+                    return true;
             }
         }
         catch (error) {
-            if (!output.isSilent()) {
-                console.error(chalk.red('Failed to connect to MCP server:'), error);
-            }
+            console.error(chalk.red('Failed to connect to MCP server:'), error);
             this.isConnected = false;
             return false;
         }
     }
-    /**
-     * Initialize WebSocket MCP connection for enterprise users
-     */
-    async initializeWebSocket(wsUrl) {
-        const { WebSocketMCPClient } = await import('./websocket-mcp-client.js');
-        const apiKey = this.config.get('token');
-        if (!apiKey) {
-            throw new Error('API key required for WebSocket MCP connection');
-        }
-        this.wsClient = new WebSocketMCPClient({
-            url: wsUrl,
-            apiKey: apiKey
-        });
-        await this.wsClient.connect();
-        if (!output.isSilent()) {
-            output.log(chalk.green('✅ WebSocket MCP connection established'));
-        }
-    }
     /**
      * Initialize SSE connection for real-time updates
      */
@@ -109,21 +95,98 @@ export class MCPClient {
             this.sseConnection.onmessage = (event) => {
                 try {
                     const data = JSON.parse(event.data);
-                    if (!output.isSilent() && process.env.CLI_VERBOSE === 'true') {
-                        output.log(chalk.blue('📡 Real-time update:'), data.type);
-                    }
+                    console.log(chalk.blue('📡 Real-time update:'), data.type);
                 }
-                catch (error) {
+                catch {
                     // Ignore parse errors
                 }
             };
-            this.sseConnection.onerror = (error) => {
-                if (!output.isSilent() && process.env.CLI_VERBOSE === 'true') {
-                    console.error(chalk.yellow('⚠️  SSE connection error (will retry)'));
-                }
+            this.sseConnection.onerror = () => {
+                console.error(chalk.yellow('⚠️  SSE connection error (will retry)'));
             };
         }
     }
+    /**
+     * Initialize WebSocket connection for enterprise MCP server
+     */
+    async initializeWebSocket(wsUrl) {
+        const token = this.config.get('token');
+        if (!token) {
+            throw new Error('API key required for WebSocket mode. Set LANONASIS_API_KEY or login first.');
+        }
+        return new Promise((resolve, reject) => {
+            try {
+                // Close existing connection if any
+                if (this.wsConnection) {
+                    this.wsConnection.close();
+                    this.wsConnection = null;
+                }
+                // Create new WebSocket connection with authentication
+                this.wsConnection = new WebSocket(wsUrl, {
+                    headers: {
+                        'Authorization': `Bearer ${token}`,
+                        'X-API-Key': token
+                    }
+                });
+                this.wsConnection.on('open', () => {
+                    console.log(chalk.green('✅ Connected to MCP WebSocket server'));
+                    // Send initialization message
+                    this.sendWebSocketMessage({
+                        id: 1,
+                        method: 'initialize',
+                        params: {
+                            protocolVersion: '2024-11-05',
+                            capabilities: {
+                                tools: ['memory_management', 'workflow_orchestration']
+                            },
+                            clientInfo: {
+                                name: '@lanonasis/cli',
+                                version: '1.1.0'
+                            }
+                        }
+                    });
+                    resolve();
+                });
+                this.wsConnection.on('message', (data) => {
+                    try {
+                        const message = JSON.parse(data.toString());
+                        console.log(chalk.blue('📡 MCP message:'), message.id, message.method || 'response');
+                    }
+                    catch (error) {
+                        console.error('Failed to parse WebSocket message:', error);
+                    }
+                });
+                this.wsConnection.on('error', (error) => {
+                    console.error(chalk.red('WebSocket error:'), error);
+                    reject(error);
+                });
+                this.wsConnection.on('close', (code, reason) => {
+                    console.log(chalk.yellow(`WebSocket connection closed (${code}): ${reason}`));
+                    // Auto-reconnect after delay
+                    setTimeout(() => {
+                        if (this.isConnected) {
+                            console.log(chalk.blue('🔄 Attempting to reconnect to WebSocket...'));
+                            this.initializeWebSocket(wsUrl).catch(err => {
+                                console.error('Failed to reconnect:', err);
+                            });
+                        }
+                    }, 5000);
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Send a message over the WebSocket connection
+     */
+    sendWebSocketMessage(message) {
+        if (!this.wsConnection) {
+            throw new Error('WebSocket not connected');
+        }
+        this.wsConnection.send(JSON.stringify(message));
+    }
     /**
      * Disconnect from MCP server
      */
@@ -160,7 +223,12 @@ export class MCPClient {
                     name: toolName,
                     arguments: args
                 });
-                return result;
+                // Convert the SDK result to our expected MCPToolResponse format
+                return {
+                    result: result,
+                    code: 200,
+                    message: 'Success'
+                };
             }
             catch (error) {
                 throw new Error(`MCP tool call failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
@@ -190,20 +258,21 @@ export class MCPClient {
             },
             'memory_get_memory': {
                 method: 'GET',
-                endpoint: `/api/v1/memory/${args.memory_id}`,
+                endpoint: '/api/v1/memory/{id}',
                 transform: () => undefined
             },
             'memory_update_memory': {
                 method: 'PUT',
-                endpoint: `/api/v1/memory/${args.memory_id}`,
+                endpoint: '/api/v1/memory/{id}',
                 transform: (args) => {
-                    const { memory_id, ...data } = args;
+                    const data = { ...args };
+                    delete data.memory_id;
                     return data;
                 }
             },
             'memory_delete_memory': {
                 method: 'DELETE',
-                endpoint: `/api/v1/memory/${args.memory_id}`,
+                endpoint: '/api/v1/memory/{id}',
                 transform: () => undefined
             },
             'memory_list_memories': {
@@ -218,9 +287,15 @@ export class MCPClient {
         }
         try {
             const axios = (await import('axios')).default;
+            // Handle dynamic endpoint for memory operations that need ID
+            let endpoint = mapping.endpoint;
+            if (endpoint.includes('{id}') && args.memory_id) {
+                // Ensure memory_id is treated as a string for replacement
+                endpoint = endpoint.replace('{id}', String(args.memory_id));
+            }
             const response = await axios({
                 method: mapping.method,
-                url: `${apiUrl}${mapping.endpoint}`,
+                url: `${apiUrl}${endpoint}`,
                 headers: {
                     'Authorization': `Bearer ${token}`,
                     'Content-Type': 'application/json'
@@ -231,7 +306,11 @@ export class MCPClient {
             return response.data;
         }
         catch (error) {
-            throw new Error(`Remote tool call failed: ${error.response?.data?.error || error.message}`);
+            // Safely handle errors with type checking
+            const errorObj = error;
+            const errorMsg = errorObj.response?.data?.error ||
+                (errorObj.message ? errorObj.message : 'Unknown error');
+            throw new Error(`Remote tool call failed: ${errorMsg}`);
         }
     }
     /**

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@lanonasis/cli",
-  "version": "1.5.0",
-  "description": "Lanonasis Unified CLI - Enterprise AI Infrastructure & Memory as a Service",
-  "main": "dist/index.js",
+  "version": "1.5.1",
+  "description": "LanOnasis Enterprise CLI - Memory as a Service, API Key Management, and Infrastructure Orchestration",
+  "main": "dist/index-simple.js",
   "bin": {
-    "lanonasis": "dist/index.js",
-    "onasis": "dist/index.js",
-    "memory": "dist/index.js",
-    "maas": "dist/index.js"
+    "lanonasis": "dist/index-simple.js",
+    "lanonasis-mcp-server": "dist/mcp-server.js",
+    "memory": "dist/index-simple.js",
+    "maas": "dist/index-simple.js"
   },
   "type": "module",
   "scripts": {
     "dev": "tsx src/index.ts",
-    "build": "tsc && chmod +x dist/index.js",
+    "build": "tsc && chmod +x dist/index-simple.js",
     "start": "node dist/index.js",
     "test": "jest",
     "lint": "eslint src/**/*.ts",
@@ -26,7 +26,11 @@
     "maas",
     "enterprise",
     "infrastructure",
-    "orchestrator"
+    "orchestrator",
+    "api-keys",
+    "secrets",
+    "mcp",
+    "security"
   ],
   "author": "Lanonasis (Seye Derick)",
   "license": "MIT",
@@ -37,8 +41,10 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.17.0",
     "@types/eventsource": "^1.1.15",
+    "@types/ws": "^8.18.1",
     "axios": "^1.11.0",
     "chalk": "^5.4.1",
+    "cli-table3": "^0.6.5",
     "commander": "^12.1.0",
     "date-fns": "^4.1.0",
     "dotenv": "^17.2.1",
@@ -48,7 +54,8 @@
     "open": "^10.2.0",
     "ora": "^8.2.0",
     "table": "^6.9.0",
-    "word-wrap": "^1.2.5"
+    "word-wrap": "^1.2.5",
+    "ws": "^8.18.3"
   },
   "devDependencies": {
     "@types/inquirer": "^9.0.7",

package/dist/utils/completions.d.ts

@@ -1,28 +0,0 @@
-export interface CompletionData {
-    commands: string[];
-    memory: {
-        types: string[];
-        tags: string[];
-        recentIds: string[];
-    };
-    topics: string[];
-    organizations: string[];
-}
-export declare class TabCompletions {
-    private config;
-    private completionData;
-    constructor();
-    init(): Promise<void>;
-    private loadDynamicCompletions;
-    private loadRecentMemories;
-    private loadTopics;
-    private loadTags;
-    getCompletions(line: string, position: number): string[];
-    private getMemoryCompletions;
-    private getCreateCompletions;
-    private getSearchCompletions;
-    private getListCompletions;
-    private getTopicCompletions;
-    generateBashCompletion(): string;
-    generateZshCompletion(): string;
-}