@lanonasis/cli 1.2.2 → 1.3.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,281 @@
+#!/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';
+// Redirect all console output to stderr to avoid polluting stdout with non-JSON
+const originalConsoleLog = console.log;
+const originalConsoleError = console.error;
+const originalConsoleWarn = console.warn;
+const originalConsoleInfo = console.info;
+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);
+// Silence ora spinner and chalk output by redirecting to stderr
+process.env.FORCE_COLOR = '0'; // Disable colors for cleaner stderr output
+class LanonasisMCPServer {
+    server;
+    config;
+    constructor() {
+        this.config = new CLIConfig();
+        this.server = new Server({
+            name: 'lanonasis-mcp-server',
+            version: '1.2.0',
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        // List available tools
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: [
+                    {
+                        name: 'create_memory',
+                        description: 'Create a new memory entry',
+                        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: ['note', 'task', 'reference'] },
+                                tags: { type: 'array', items: { type: 'string' }, description: 'Memory tags' }
+                            },
+                            required: ['title', 'content']
+                        }
+                    },
+                    {
+                        name: 'search_memories',
+                        description: 'Search through memories',
+                        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 }
+                            },
+                            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']
+                        }
+                    }
+                ]
+            };
+        });
+        // Handle tool calls
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                switch (name) {
+                    case 'create_memory':
+                        return await this.createMemory(args);
+                    case 'search_memories':
+                        return await this.searchMemories(args);
+                    case 'get_memory':
+                        return await this.getMemory(args);
+                    case 'update_memory':
+                        return await this.updateMemory(args);
+                    case 'delete_memory':
+                        return await this.deleteMemory(args);
+                    default:
+                        throw new Error(`Unknown tool: ${name}`);
+                }
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`
+                        }
+                    ]
+                };
+            }
+        });
+    }
+    async createMemory(args) {
+        const apiUrl = process.env.LANONASIS_API_URL || 'https://api.lanonasis.com';
+        const apiKey = process.env.LANONASIS_API_KEY || this.config.get('token');
+        if (!apiKey) {
+            throw new Error('No API key found. Please authenticate first.');
+        }
+        const response = await fetch(`${apiUrl}/api/memories`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey}`
+            },
+            body: JSON.stringify(args)
+        });
+        if (!response.ok) {
+            throw new Error(`API request failed: ${response.statusText}`);
+        }
+        const result = await response.json();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Memory created successfully with ID: ${result.id}`
+                }
+            ]
+        };
+    }
+    async searchMemories(args) {
+        const apiUrl = process.env.LANONASIS_API_URL || 'https://api.lanonasis.com';
+        const apiKey = process.env.LANONASIS_API_KEY || this.config.get('token');
+        if (!apiKey) {
+            throw new Error('No API key found. Please authenticate first.');
+        }
+        const params = new URLSearchParams();
+        if (args.query)
+            params.append('query', args.query);
+        if (args.memory_type)
+            params.append('memory_type', args.memory_type);
+        if (args.limit)
+            params.append('limit', args.limit.toString());
+        const response = await fetch(`${apiUrl}/api/memories/search?${params}`, {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`API request failed: ${response.statusText}`);
+        }
+        const results = await response.json();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Found ${results.length} memories:\n\n${results.map((m) => `ID: ${m.id}\nTitle: ${m.title}\nType: ${m.memory_type}\nContent: ${m.content.substring(0, 100)}...\n`).join('\n')}`
+                }
+            ]
+        };
+    }
+    async getMemory(args) {
+        const apiUrl = process.env.LANONASIS_API_URL || 'https://api.lanonasis.com';
+        const apiKey = process.env.LANONASIS_API_KEY || this.config.get('token');
+        if (!apiKey) {
+            throw new Error('No API key found. Please authenticate first.');
+        }
+        const response = await fetch(`${apiUrl}/api/memories/${args.id}`, {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`API request failed: ${response.statusText}`);
+        }
+        const memory = await response.json();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Memory Details:\nID: ${memory.id}\nTitle: ${memory.title}\nType: ${memory.memory_type}\nContent: ${memory.content}\nTags: ${memory.tags?.join(', ') || 'None'}\nCreated: ${memory.created_at}`
+                }
+            ]
+        };
+    }
+    async updateMemory(args) {
+        const apiUrl = process.env.LANONASIS_API_URL || 'https://api.lanonasis.com';
+        const apiKey = process.env.LANONASIS_API_KEY || this.config.get('token');
+        if (!apiKey) {
+            throw new Error('No API key found. Please authenticate first.');
+        }
+        const { id, ...updateData } = args;
+        const response = await fetch(`${apiUrl}/api/memories/${id}`, {
+            method: 'PUT',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey}`
+            },
+            body: JSON.stringify(updateData)
+        });
+        if (!response.ok) {
+            throw new Error(`API request failed: ${response.statusText}`);
+        }
+        const result = await response.json();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Memory ${id} updated successfully`
+                }
+            ]
+        };
+    }
+    async deleteMemory(args) {
+        const apiUrl = process.env.LANONASIS_API_URL || 'https://api.lanonasis.com';
+        const apiKey = process.env.LANONASIS_API_KEY || this.config.get('token');
+        if (!apiKey) {
+            throw new Error('No API key found. Please authenticate first.');
+        }
+        const response = await fetch(`${apiUrl}/api/memories/${args.id}`, {
+            method: 'DELETE',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`API request failed: ${response.statusText}`);
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Memory ${args.id} deleted successfully`
+                }
+            ]
+        };
+    }
+    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.3.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",