@lanonasis/cli 1.2.2 → 1.4.0

package/dist/commands/mcp.js

@@ -54,41 +54,60 @@ export function mcpCommands(program) {
     });
     // Connect command
     mcp.command('connect')
-        .description('Connect to MCP server (local or remote)')
+        .description('Connect to MCP server (local, remote, or WebSocket)')
         .option('-l, --local', 'Connect to local MCP server')
         .option('-r, --remote', 'Connect to remote MCP server (api.lanonasis.com)')
+        .option('-w, --websocket', 'Connect using WebSocket mode for enterprise users')
         .option('-s, --server <path>', 'Local MCP server path')
-        .option('-u, --url <url>', 'Remote MCP server URL')
+        .option('-u, --url <url>', 'Remote/WebSocket server URL')
         .action(async (options) => {
         const spinner = ora('Connecting to MCP server...').start();
         const config = new CLIConfig();
         try {
-            // Determine connection mode
-            let useRemote = options.remote;
-            if (!options.local && !options.remote) {
+            let connectionMode;
+            // Determine connection mode - WebSocket takes precedence over remote and local
+            if (options.websocket) {
+                connectionMode = 'websocket';
+            }
+            else if (options.remote) {
+                connectionMode = 'remote';
+            }
+            else if (options.local) {
+                connectionMode = 'local';
+            }
+            else {
                 // Default to remote if authenticated, otherwise local
-                useRemote = !!config.get('token');
+                connectionMode = !!config.get('token') ? 'remote' : 'local';
             }
-            // Save preference
-            config.set('mcpUseRemote', useRemote);
+            // Save preferences
+            config.set('mcpConnectionMode', connectionMode);
             if (options.server) {
                 config.set('mcpServerPath', options.server);
             }
             if (options.url) {
-                config.set('mcpServerUrl', options.url);
+                if (connectionMode === 'websocket') {
+                    config.set('mcpWebSocketUrl', options.url);
+                }
+                else {
+                    config.set('mcpServerUrl', options.url);
+                }
             }
             const client = getMCPClient();
             const connected = await client.connect({
-                useRemote,
+                connectionMode,
                 serverPath: options.server,
                 serverUrl: options.url
             });
             if (connected) {
-                spinner.succeed(chalk.green(`Connected to ${useRemote ? 'remote' : 'local'} MCP server`));
-                if (useRemote) {
+                spinner.succeed(chalk.green(`Connected to MCP server in ${connectionMode} mode`));
+                if (connectionMode === 'remote') {
                     console.log(chalk.cyan('ℹ️  Using remote MCP via api.lanonasis.com'));
                     console.log(chalk.cyan('📡 SSE endpoint active for real-time updates'));
                 }
+                else if (connectionMode === 'websocket') {
+                    console.log(chalk.cyan('ℹ️  Using enterprise WebSocket MCP server'));
+                    console.log(chalk.cyan('📡 WebSocket connection active with auto-reconnect'));
+                }
             }
             else {
                 spinner.fail('Failed to connect to MCP server');

package/dist/mcp-server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/mcp-server.js

@@ -0,0 +1,519 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { CLIConfig } from './utils/config.js';
+// MCP Protocol Compliance: Redirect all console output to stderr
+// This prevents stdout pollution which breaks JSON-RPC communication
+const originalConsoleError = console.error;
+// Silent mode for MCP protocol compliance
+const isSilentMode = process.env.LANONASIS_SILENT === 'true' || process.argv.includes('--silent');
+if (isSilentMode) {
+    // Completely silence all output except JSON-RPC
+    console.log = () => { };
+    console.error = () => { };
+    console.warn = () => { };
+    console.info = () => { };
+    console.debug = () => { };
+}
+else {
+    // Redirect to stderr for debugging
+    console.log = (...args) => originalConsoleError('[MCP-LOG]', ...args);
+    console.error = (...args) => originalConsoleError('[MCP-ERROR]', ...args);
+    console.warn = (...args) => originalConsoleError('[MCP-WARN]', ...args);
+    console.info = (...args) => originalConsoleError('[MCP-INFO]', ...args);
+}
+// Disable colors and verbose output for MCP protocol compliance
+process.env.FORCE_COLOR = '0';
+process.env.DEBUG = '';
+process.env.NODE_ENV = process.env.NODE_ENV || 'production';
+class LanonasisMCPServer {
+    server;
+    config;
+    constructor() {
+        this.config = new CLIConfig();
+        this.server = new Server({
+            name: 'lanonasis-mcp-server',
+            version: '1.3.0',
+        }, {
+            capabilities: {
+                tools: {},
+                resources: {},
+            },
+        });
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        // List available tools - Comprehensive MCP toolset matching legacy CLI
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: [
+                    // Memory Management Tools
+                    {
+                        name: 'create_memory',
+                        description: 'Create a new memory entry with vector embedding',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                title: { type: 'string', description: 'Memory title' },
+                                content: { type: 'string', description: 'Memory content' },
+                                memory_type: { type: 'string', description: 'Type of memory', enum: ['context', 'project', 'knowledge', 'reference', 'personal', 'workflow'] },
+                                tags: { type: 'array', items: { type: 'string' }, description: 'Memory tags' },
+                                topic_id: { type: 'string', description: 'Topic ID for organization' }
+                            },
+                            required: ['title', 'content']
+                        }
+                    },
+                    {
+                        name: 'search_memories',
+                        description: 'Search through memories with semantic vector search',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                query: { type: 'string', description: 'Search query' },
+                                memory_type: { type: 'string', description: 'Filter by memory type' },
+                                limit: { type: 'number', description: 'Maximum results to return', default: 10 },
+                                threshold: { type: 'number', description: 'Similarity threshold (0.0-1.0)', default: 0.7 },
+                                tags: { type: 'array', items: { type: 'string' }, description: 'Filter by tags' }
+                            },
+                            required: ['query']
+                        }
+                    },
+                    {
+                        name: 'get_memory',
+                        description: 'Get a specific memory by ID',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                id: { type: 'string', description: 'Memory ID' }
+                            },
+                            required: ['id']
+                        }
+                    },
+                    {
+                        name: 'update_memory',
+                        description: 'Update an existing memory',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                id: { type: 'string', description: 'Memory ID' },
+                                title: { type: 'string', description: 'Memory title' },
+                                content: { type: 'string', description: 'Memory content' },
+                                memory_type: { type: 'string', description: 'Type of memory' },
+                                tags: { type: 'array', items: { type: 'string' }, description: 'Memory tags' }
+                            },
+                            required: ['id']
+                        }
+                    },
+                    {
+                        name: 'delete_memory',
+                        description: 'Delete a memory by ID',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                id: { type: 'string', description: 'Memory ID' }
+                            },
+                            required: ['id']
+                        }
+                    },
+                    {
+                        name: 'list_memories',
+                        description: 'List memories with pagination and filters',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                limit: { type: 'number', description: 'Number of memories to return', default: 20 },
+                                offset: { type: 'number', description: 'Offset for pagination', default: 0 },
+                                memory_type: { type: 'string', description: 'Filter by memory type' },
+                                tags: { type: 'array', items: { type: 'string' }, description: 'Filter by tags' }
+                            }
+                        }
+                    },
+                    // API Key Management Tools
+                    {
+                        name: 'create_api_key',
+                        description: 'Create a new API key',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                name: { type: 'string', description: 'API key name' },
+                                description: { type: 'string', description: 'API key description' },
+                                project_id: { type: 'string', description: 'Project ID' },
+                                access_level: { type: 'string', description: 'Access level', enum: ['public', 'authenticated', 'team', 'admin', 'enterprise'] },
+                                expires_in_days: { type: 'number', description: 'Expiration in days', default: 365 }
+                            },
+                            required: ['name']
+                        }
+                    },
+                    {
+                        name: 'list_api_keys',
+                        description: 'List API keys',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                project_id: { type: 'string', description: 'Filter by project ID' },
+                                active_only: { type: 'boolean', description: 'Show only active keys', default: true }
+                            }
+                        }
+                    },
+                    {
+                        name: 'rotate_api_key',
+                        description: 'Rotate an API key',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                key_id: { type: 'string', description: 'API key ID to rotate' }
+                            },
+                            required: ['key_id']
+                        }
+                    },
+                    {
+                        name: 'delete_api_key',
+                        description: 'Delete an API key',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                key_id: { type: 'string', description: 'API key ID to delete' }
+                            },
+                            required: ['key_id']
+                        }
+                    },
+                    // Project Management Tools
+                    {
+                        name: 'create_project',
+                        description: 'Create a new project',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                name: { type: 'string', description: 'Project name' },
+                                description: { type: 'string', description: 'Project description' },
+                                organization_id: { type: 'string', description: 'Organization ID' }
+                            },
+                            required: ['name']
+                        }
+                    },
+                    {
+                        name: 'list_projects',
+                        description: 'List projects',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                organization_id: { type: 'string', description: 'Filter by organization ID' }
+                            }
+                        }
+                    },
+                    // Organization Management Tools
+                    {
+                        name: 'get_organization_info',
+                        description: 'Get organization information',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {}
+                        }
+                    },
+                    // Authentication Tools
+                    {
+                        name: 'get_auth_status',
+                        description: 'Get authentication status',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {}
+                        }
+                    },
+                    // Configuration Tools
+                    {
+                        name: 'get_config',
+                        description: 'Get configuration settings',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                key: { type: 'string', description: 'Specific config key to retrieve' }
+                            }
+                        }
+                    },
+                    {
+                        name: 'set_config',
+                        description: 'Set configuration setting',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                key: { type: 'string', description: 'Configuration key' },
+                                value: { type: 'string', description: 'Configuration value' }
+                            },
+                            required: ['key', 'value']
+                        }
+                    },
+                    // Health and Status Tools
+                    {
+                        name: 'get_health_status',
+                        description: 'Get system health status',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {}
+                        }
+                    }
+                ]
+            };
+        });
+        // Handle tool calls - Comprehensive implementation
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                const apiKey = process.env.LANONASIS_API_KEY;
+                const apiUrl = process.env.LANONASIS_API_URL || 'https://api.lanonasis.com';
+                if (!apiKey) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'Error: LANONASIS_API_KEY environment variable is required'
+                            }
+                        ]
+                    };
+                }
+                const headers = {
+                    'Authorization': `Bearer ${apiKey}`,
+                    'Content-Type': 'application/json',
+                    'User-Agent': 'lanonasis-mcp-server/1.3.0'
+                };
+                switch (name) {
+                    // Memory Management Tools
+                    case 'create_memory': {
+                        const response = await fetch(`${apiUrl}/api/memory`, {
+                            method: 'POST',
+                            headers,
+                            body: JSON.stringify(args)
+                        });
+                        if (!response.ok) {
+                            const errorText = await response.text();
+                            throw new Error(`Memory creation failed: ${response.status} ${response.statusText} - ${errorText}`);
+                        }
+                        const result = await response.json();
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `✅ Memory created successfully:\n${JSON.stringify(result, null, 2)}`
+                                }
+                            ]
+                        };
+                    }
+                    case 'search_memories': {
+                        const queryParams = new URLSearchParams();
+                        if (args.query)
+                            queryParams.append('query', String(args.query));
+                        if (args.memory_type)
+                            queryParams.append('memory_type', String(args.memory_type));
+                        if (args.limit)
+                            queryParams.append('limit', args.limit.toString());
+                        if (args.threshold)
+                            queryParams.append('threshold', args.threshold.toString());
+                        if (args.tags && Array.isArray(args.tags)) {
+                            args.tags.forEach((tag) => queryParams.append('tags', String(tag)));
+                        }
+                        const response = await fetch(`${apiUrl}/api/memory/search?${queryParams}`, {
+                            method: 'GET',
+                            headers
+                        });
+                        if (!response.ok) {
+                            const errorText = await response.text();
+                            throw new Error(`Memory search failed: ${response.status} ${response.statusText} - ${errorText}`);
+                        }
+                        const result = await response.json();
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `🔍 Search results (${result.length || 0} found):\n${JSON.stringify(result, null, 2)}`
+                                }
+                            ]
+                        };
+                    }
+                    case 'get_memory': {
+                        const response = await fetch(`${apiUrl}/api/memory/${args.id}`, {
+                            method: 'GET',
+                            headers
+                        });
+                        if (!response.ok) {
+                            const errorText = await response.text();
+                            throw new Error(`Memory retrieval failed: ${response.status} ${response.statusText} - ${errorText}`);
+                        }
+                        const result = await response.json();
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `📄 Memory details:\n${JSON.stringify(result, null, 2)}`
+                                }
+                            ]
+                        };
+                    }
+                    case 'update_memory': {
+                        const { id, ...updateData } = args;
+                        const response = await fetch(`${apiUrl}/api/memory/${id}`, {
+                            method: 'PUT',
+                            headers,
+                            body: JSON.stringify(updateData)
+                        });
+                        if (!response.ok) {
+                            const errorText = await response.text();
+                            throw new Error(`Memory update failed: ${response.status} ${response.statusText} - ${errorText}`);
+                        }
+                        const result = await response.json();
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `✏️ Memory updated successfully:\n${JSON.stringify(result, null, 2)}`
+                                }
+                            ]
+                        };
+                    }
+                    case 'delete_memory': {
+                        const response = await fetch(`${apiUrl}/api/memory/${args.id}`, {
+                            method: 'DELETE',
+                            headers
+                        });
+                        if (!response.ok) {
+                            const errorText = await response.text();
+                            throw new Error(`Memory deletion failed: ${response.status} ${response.statusText} - ${errorText}`);
+                        }
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `🗑️ Memory deleted successfully (ID: ${args.id})`
+                                }
+                            ]
+                        };
+                    }
+                    case 'list_memories': {
+                        const queryParams = new URLSearchParams();
+                        if (args.limit)
+                            queryParams.append('limit', args.limit.toString());
+                        if (args.offset)
+                            queryParams.append('offset', args.offset.toString());
+                        if (args.memory_type)
+                            queryParams.append('memory_type', String(args.memory_type));
+                        if (args.tags && Array.isArray(args.tags)) {
+                            args.tags.forEach((tag) => queryParams.append('tags', String(tag)));
+                        }
+                        const response = await fetch(`${apiUrl}/api/memory?${queryParams}`, {
+                            method: 'GET',
+                            headers
+                        });
+                        if (!response.ok) {
+                            const errorText = await response.text();
+                            throw new Error(`Memory listing failed: ${response.status} ${response.statusText} - ${errorText}`);
+                        }
+                        const result = await response.json();
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `📋 Memory list (${result.length || 0} items):\n${JSON.stringify(result, null, 2)}`
+                                }
+                            ]
+                        };
+                    }
+                    // API Key Management Tools
+                    case 'create_api_key': {
+                        const response = await fetch(`${apiUrl}/api/api-keys`, {
+                            method: 'POST',
+                            headers,
+                            body: JSON.stringify(args)
+                        });
+                        if (!response.ok) {
+                            const errorText = await response.text();
+                            throw new Error(`API key creation failed: ${response.status} ${response.statusText} - ${errorText}`);
+                        }
+                        const result = await response.json();
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `🔑 API key created successfully:\n${JSON.stringify(result, null, 2)}`
+                                }
+                            ]
+                        };
+                    }
+                    case 'list_api_keys': {
+                        const queryParams = new URLSearchParams();
+                        if (args.project_id)
+                            queryParams.append('project_id', String(args.project_id));
+                        if (args.active_only !== undefined)
+                            queryParams.append('active_only', args.active_only.toString());
+                        const response = await fetch(`${apiUrl}/api/api-keys?${queryParams}`, {
+                            method: 'GET',
+                            headers
+                        });
+                        if (!response.ok) {
+                            const errorText = await response.text();
+                            throw new Error(`API key listing failed: ${response.status} ${response.statusText} - ${errorText}`);
+                        }
+                        const result = await response.json();
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `🔑 API keys (${result.length || 0} found):\n${JSON.stringify(result, null, 2)}`
+                                }
+                            ]
+                        };
+                    }
+                    case 'get_health_status': {
+                        const response = await fetch(`${apiUrl}/api/health`, {
+                            method: 'GET',
+                            headers
+                        });
+                        if (!response.ok) {
+                            const errorText = await response.text();
+                            throw new Error(`Health check failed: ${response.status} ${response.statusText} - ${errorText}`);
+                        }
+                        const result = await response.json();
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `💚 System health status:\n${JSON.stringify(result, null, 2)}`
+                                }
+                            ]
+                        };
+                    }
+                    default:
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `❌ Unknown tool: ${name}. Available tools: create_memory, search_memories, get_memory, update_memory, delete_memory, list_memories, create_api_key, list_api_keys, get_health_status`
+                                }
+                            ]
+                        };
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ Error: ${errorMessage}`
+                        }
+                    ]
+                };
+            }
+        });
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        // Log to stderr that server is ready
+        console.error('[MCP-INFO] Lanonasis MCP Server started and ready');
+    }
+}
+// Start the server
+const server = new LanonasisMCPServer();
+server.run().catch((error) => {
+    console.error('[MCP-ERROR] Failed to start server:', error);
+    process.exit(1);
+});

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

@@ -2,12 +2,53 @@ interface MCPConnectionOptions {
     serverPath?: string;
     serverUrl?: string;
     useRemote?: boolean;
+    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 wsConnection;
     constructor();
     /**
      * Connect to MCP server (local or remote)
@@ -17,6 +58,14 @@ export declare class MCPClient {
      * Initialize SSE connection for real-time updates
      */
     private initializeSSE;
+    /**
+     * Initialize WebSocket connection for enterprise MCP server
+     */
+    private initializeWebSocket;
+    /**
+     * Send a message over the WebSocket connection
+     */
+    private sendWebSocketMessage;
     /**
      * Disconnect from MCP server
      */
@@ -24,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,6 +5,7 @@ import { CLIConfig } from './config.js';
 import * as path from 'path';
 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 {
@@ -12,6 +13,7 @@ export class MCPClient {
     config;
     isConnected = false;
     sseConnection = null;
+    wsConnection = null;
     constructor() {
         this.config = new CLIConfig();
     }
@@ -20,34 +22,59 @@ export class MCPClient {
      */
     async connect(options = {}) {
         try {
-            const useRemote = options.useRemote ?? this.config.get('mcpUseRemote') ?? false;
-            if (useRemote) {
-                // For remote MCP, we'll use the REST API with MCP-style interface
-                const 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');
-                console.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;
-                console.log(chalk.green('✓ Connected to MCP server'));
-                return true;
+            // 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);
+                    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;
+                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) {
@@ -79,6 +106,87 @@ export class MCPClient {
             };
         }
     }
+    /**
+     * 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
      */
@@ -115,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'}`);
@@ -177,7 +290,8 @@ export class MCPClient {
             // Handle dynamic endpoint for memory operations that need ID
             let endpoint = mapping.endpoint;
             if (endpoint.includes('{id}') && args.memory_id) {
-                endpoint = endpoint.replace('{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,
@@ -192,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,10 +1,11 @@
 {
   "name": "@lanonasis/cli",
-  "version": "1.2.2",
+  "version": "1.4.0",
   "description": "LanOnasis Enterprise CLI - Memory as a Service, API Key Management, and Infrastructure Orchestration",
   "main": "dist/index-simple.js",
   "bin": {
     "lanonasis": "dist/index-simple.js",
+    "lanonasis-mcp-server": "dist/mcp-server.js",
     "memory": "dist/index-simple.js",
     "maas": "dist/index-simple.js"
   },
@@ -40,6 +41,7 @@
   "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",
@@ -52,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",