@lanonasis/cli 1.4.2 → 1.5.0

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 WebSocket from 'ws';
+import { output } from './output.js';
 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;
-    wsConnection = null;
+    wsClient = null;
     constructor() {
         this.config = new CLIConfig();
     }
@@ -22,67 +22,81 @@ export class MCPClient {
      */
     async connect(options = {}) {
         try {
-            // 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
+            // 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
                     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}...`));
+                }
+                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}...`));
+                    }
                     // 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;
+                }
+                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;
             }
         }
         catch (error) {
-            console.error(chalk.red('Failed to connect to MCP server:'), error);
+            if (!output.isSilent()) {
+                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
      */
@@ -95,97 +109,20 @@ export class MCPClient {
             this.sseConnection.onmessage = (event) => {
                 try {
                     const data = JSON.parse(event.data);
-                    console.log(chalk.blue('📡 Real-time update:'), data.type);
+                    if (!output.isSilent() && process.env.CLI_VERBOSE === 'true') {
+                        output.log(chalk.blue('📡 Real-time update:'), data.type);
+                    }
                 }
-                catch {
+                catch (error) {
                     // Ignore parse errors
                 }
             };
-            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;
+            this.sseConnection.onerror = (error) => {
+                if (!output.isSilent() && process.env.CLI_VERBOSE === 'true') {
+                    console.error(chalk.yellow('⚠️  SSE connection error (will retry)'));
                 }
-                // 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
@@ -223,12 +160,7 @@ export class MCPClient {
                     name: toolName,
                     arguments: args
                 });
-                // Convert the SDK result to our expected MCPToolResponse format
-                return {
-                    result: result,
-                    code: 200,
-                    message: 'Success'
-                };
+                return result;
             }
             catch (error) {
                 throw new Error(`MCP tool call failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
@@ -258,21 +190,20 @@ export class MCPClient {
             },
             'memory_get_memory': {
                 method: 'GET',
-                endpoint: '/api/v1/memory/{id}',
+                endpoint: `/api/v1/memory/${args.memory_id}`,
                 transform: () => undefined
             },
             'memory_update_memory': {
                 method: 'PUT',
-                endpoint: '/api/v1/memory/{id}',
+                endpoint: `/api/v1/memory/${args.memory_id}`,
                 transform: (args) => {
-                    const data = { ...args };
-                    delete data.memory_id;
+                    const { memory_id, ...data } = args;
                     return data;
                 }
             },
             'memory_delete_memory': {
                 method: 'DELETE',
-                endpoint: '/api/v1/memory/{id}',
+                endpoint: `/api/v1/memory/${args.memory_id}`,
                 transform: () => undefined
             },
             'memory_list_memories': {
@@ -287,15 +218,9 @@ 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}${endpoint}`,
+                url: `${apiUrl}${mapping.endpoint}`,
                 headers: {
                     'Authorization': `Bearer ${token}`,
                     'Content-Type': 'application/json'
@@ -306,11 +231,7 @@ export class MCPClient {
             return response.data;
         }
         catch (error) {
-            // 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}`);
+            throw new Error(`Remote tool call failed: ${error.response?.data?.error || error.message}`);
         }
     }
     /**

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

@@ -0,0 +1 @@
+export {};

package/dist/utils/mcp-client.test.js

@@ -0,0 +1,125 @@
+import { describe, it, expect, beforeEach } from 'bun:test';
+import { MCPClient } from './mcp-client';
+describe('MCPClient', () => {
+    let client;
+    beforeEach(() => {
+        client = new MCPClient();
+    });
+    describe('constructor', () => {
+        it('should create client instance', () => {
+            expect(client).toBeDefined();
+            expect(client.isConnected()).toBe(false);
+        });
+    });
+    describe('connection modes', () => {
+        it('should support local connection mode', async () => {
+            const result = await client.connect({ mode: 'local' });
+            // Local mode may fail without actual server, but should not throw
+            expect(typeof result).toBe('boolean');
+        });
+        it('should support remote connection mode', async () => {
+            const result = await client.connect({ mode: 'remote' });
+            // Remote mode may fail without credentials, but should not throw
+            expect(typeof result).toBe('boolean');
+        });
+        it('should support websocket connection mode', async () => {
+            const result = await client.connect({ mode: 'websocket' });
+            // WebSocket mode may fail without server, but should not throw
+            expect(typeof result).toBe('boolean');
+        });
+    });
+    describe('connection options', () => {
+        it('should handle server path option', async () => {
+            const options = {
+                mode: 'local',
+                serverPath: '/custom/path/to/server'
+            };
+            const result = await client.connect(options);
+            expect(typeof result).toBe('boolean');
+        });
+        it('should handle server URL option', async () => {
+            const options = {
+                mode: 'websocket',
+                serverUrl: 'ws://custom.server.com:8081'
+            };
+            const result = await client.connect(options);
+            expect(typeof result).toBe('boolean');
+        });
+    });
+    describe('tool operations', () => {
+        it('should handle list tools request', async () => {
+            // Mock successful connection first
+            client.isConnected = () => true;
+            try {
+                const tools = await client.listTools();
+                expect(Array.isArray(tools)).toBe(true);
+            }
+            catch (error) {
+                // Expected if no actual connection
+                expect(error).toBeDefined();
+            }
+        });
+        it('should handle call tool request', async () => {
+            // Mock successful connection first
+            client.isConnected = () => true;
+            try {
+                const result = await client.callTool('test_tool', { param: 'value' });
+                expect(result).toBeDefined();
+            }
+            catch (error) {
+                // Expected if no actual connection
+                expect(error).toBeDefined();
+            }
+        });
+    });
+    describe('memory operations', () => {
+        it('should handle create memory request', async () => {
+            // Mock successful connection first
+            client.isConnected = () => true;
+            try {
+                const result = await client.createMemory({
+                    title: 'Test Memory',
+                    content: 'Test content',
+                    tags: ['test']
+                });
+                expect(result).toBeDefined();
+            }
+            catch (error) {
+                // Expected if no actual connection
+                expect(error).toBeDefined();
+            }
+        });
+        it('should handle search memories request', async () => {
+            // Mock successful connection first
+            client.isConnected = () => true;
+            try {
+                const result = await client.searchMemories({
+                    query: 'test query',
+                    limit: 10
+                });
+                expect(result).toBeDefined();
+            }
+            catch (error) {
+                // Expected if no actual connection
+                expect(error).toBeDefined();
+            }
+        });
+    });
+    describe('error handling', () => {
+        it('should handle connection failures gracefully', async () => {
+            const result = await client.connect({
+                mode: 'websocket',
+                serverUrl: 'ws://nonexistent.server:9999'
+            });
+            expect(result).toBe(false);
+        });
+        it('should handle invalid connection modes', async () => {
+            try {
+                await client.connect({ mode: 'invalid' });
+            }
+            catch (error) {
+                expect(error).toBeDefined();
+            }
+        });
+    });
+});

package/dist/utils/output.d.ts

@@ -0,0 +1,23 @@
+export interface OutputOptions {
+    format?: string;
+    silent?: boolean;
+    json?: boolean;
+}
+export declare class OutputManager {
+    private static instance;
+    private options;
+    static getInstance(): OutputManager;
+    setOptions(options: OutputOptions): void;
+    isJsonOutput(): boolean;
+    isSilent(): boolean;
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+    json(data: any): void;
+    table(data: any[]): void;
+    success(message: string): void;
+    warning(message: string): void;
+    info(message: string): void;
+}
+export declare const output: OutputManager;
+export declare function showOutput(format?: string): boolean;
+export declare function formatOutput(data: any, format?: string): string;

package/dist/utils/output.js

@@ -0,0 +1,97 @@
+import chalk from 'chalk';
+export class OutputManager {
+    static instance;
+    options = {};
+    static getInstance() {
+        if (!OutputManager.instance) {
+            OutputManager.instance = new OutputManager();
+        }
+        return OutputManager.instance;
+    }
+    setOptions(options) {
+        this.options = { ...this.options, ...options };
+    }
+    isJsonOutput() {
+        return this.options.format === 'json' ||
+            this.options.json === true ||
+            process.env.CLI_OUTPUT_FORMAT === 'json';
+    }
+    isSilent() {
+        return this.options.silent === true ||
+            this.isJsonOutput() ||
+            process.env.CLI_SILENT === 'true';
+    }
+    log(...args) {
+        if (!this.isSilent()) {
+            console.log(...args);
+        }
+    }
+    error(...args) {
+        if (this.isJsonOutput()) {
+            console.error(JSON.stringify({
+                error: true,
+                message: args.join(' ').replace(/\x1b\[[0-9;]*m/g, '') // Strip ANSI codes
+            }));
+        }
+        else {
+            console.error(...args);
+        }
+    }
+    json(data) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    table(data) {
+        if (this.isJsonOutput()) {
+            this.json(data);
+        }
+        else {
+            console.table(data);
+        }
+    }
+    success(message) {
+        if (this.isJsonOutput()) {
+            this.json({ success: true, message });
+        }
+        else {
+            this.log(chalk.green('✓'), message);
+        }
+    }
+    warning(message) {
+        if (this.isJsonOutput()) {
+            this.json({ warning: true, message });
+        }
+        else {
+            this.log(chalk.yellow('⚠️'), message);
+        }
+    }
+    info(message) {
+        if (!this.isSilent()) {
+            if (this.isJsonOutput()) {
+                this.json({ info: true, message });
+            }
+            else {
+                this.log(chalk.blue('ℹ'), message);
+            }
+        }
+    }
+}
+export const output = OutputManager.getInstance();
+// Helper to conditionally show output
+export function showOutput(format) {
+    return format !== 'json' && process.env.CLI_OUTPUT_FORMAT !== 'json';
+}
+// Helper to format output based on format
+export function formatOutput(data, format) {
+    const outputFormat = format || process.env.CLI_OUTPUT_FORMAT || 'table';
+    switch (outputFormat) {
+        case 'json':
+            return JSON.stringify(data, null, 2);
+        case 'yaml':
+            // Simple YAML-like format
+            return Object.entries(data)
+                .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+                .join('\n');
+        default:
+            return data;
+    }
+}

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

@@ -0,0 +1,60 @@
+/**
+ * WebSocket MCP Client for Enterprise Connections
+ * Connects to mcp.lanonasis.com WebSocket server for real-time MCP operations
+ */
+import { EventEmitter } from 'events';
+export interface MCPParams {
+    [key: string]: unknown;
+}
+export interface MCPResult {
+    [key: string]: unknown;
+}
+export interface MCPError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export interface MCPMessage {
+    id?: string;
+    type: 'request' | 'response' | 'notification' | 'error';
+    method?: string;
+    params?: MCPParams;
+    result?: MCPResult;
+    error?: MCPError;
+}
+export interface WebSocketMCPClientOptions {
+    url?: string;
+    apiKey: string;
+    reconnectInterval?: number;
+    maxReconnectAttempts?: number;
+    timeout?: number;
+}
+export declare class WebSocketMCPClient extends EventEmitter {
+    private ws;
+    private url;
+    private apiKey;
+    private reconnectInterval;
+    private maxReconnectAttempts;
+    private timeout;
+    private reconnectAttempts;
+    private isConnected;
+    private messageId;
+    private pendingRequests;
+    constructor(options: WebSocketMCPClientOptions);
+    connect(): Promise<void>;
+    private handleMessage;
+    sendRequest(method: string, params?: MCPParams): Promise<MCPResult>;
+    listTools(): Promise<MCPResult>;
+    callTool(name: string, arguments_?: MCPParams): Promise<MCPResult>;
+    deleteMemory(id: string): Promise<MCPResult>;
+    searchMemories(args: MCPParams): Promise<MCPResult>;
+    listResources(): Promise<MCPResult>;
+    getMemories(query?: string): Promise<MCPResult>;
+    disconnect(): void;
+    getConnectionStatus(): {
+        connected: boolean;
+        url: string;
+        reconnectAttempts: number;
+        pendingRequests: number;
+    };
+}