@lanonasis/cli 1.4.2 → 1.5.0

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

@@ -0,0 +1,182 @@
+/**
+ * WebSocket MCP Client for Enterprise Connections
+ * Connects to mcp.lanonasis.com WebSocket server for real-time MCP operations
+ */
+import WebSocket from 'ws';
+import { EventEmitter } from 'events';
+import chalk from 'chalk';
+export class WebSocketMCPClient extends EventEmitter {
+    ws = null;
+    url;
+    apiKey;
+    reconnectInterval;
+    maxReconnectAttempts;
+    timeout;
+    reconnectAttempts = 0;
+    isConnected = false;
+    messageId = 0;
+    pendingRequests = new Map();
+    constructor(options) {
+        super();
+        this.url = options.url || 'wss://mcp.lanonasis.com/mcp';
+        this.apiKey = options.apiKey;
+        this.reconnectInterval = options.reconnectInterval || 5000;
+        this.maxReconnectAttempts = options.maxReconnectAttempts || 10;
+        this.timeout = options.timeout || 30000;
+    }
+    async connect() {
+        return new Promise((resolve, reject) => {
+            try {
+                this.ws = new WebSocket(this.url, {
+                    headers: {
+                        'Authorization': `Bearer ${this.apiKey}`,
+                        'X-API-Key': this.apiKey
+                    }
+                });
+                this.ws.on('open', () => {
+                    this.isConnected = true;
+                    this.reconnectAttempts = 0;
+                    this.emit('connected');
+                    // Send initialize message
+                    this.sendRequest('initialize', {
+                        protocolVersion: '2024-11-05',
+                        capabilities: {
+                            roots: { listChanged: true },
+                            sampling: {}
+                        },
+                        clientInfo: {
+                            name: '@lanonasis/cli',
+                            version: '1.2.0'
+                        }
+                    }).then(() => {
+                        resolve();
+                    }).catch(reject);
+                });
+                this.ws.on('message', (data) => {
+                    try {
+                        const message = JSON.parse(data.toString());
+                        this.handleMessage(message);
+                    }
+                    catch (error) {
+                        console.error(chalk.red('Failed to parse WebSocket message:'), error);
+                    }
+                });
+                this.ws.on('close', (code, reason) => {
+                    this.isConnected = false;
+                    this.emit('disconnected', { code, reason: reason.toString() });
+                    if (this.reconnectAttempts < this.maxReconnectAttempts) {
+                        this.reconnectAttempts++;
+                        console.log(chalk.yellow(`WebSocket disconnected. Reconnecting... (${this.reconnectAttempts}/${this.maxReconnectAttempts})`));
+                        setTimeout(() => this.connect(), this.reconnectInterval);
+                    }
+                    else {
+                        console.error(chalk.red('Max reconnection attempts reached. Connection failed.'));
+                        this.emit('error', new Error('Max reconnection attempts reached'));
+                    }
+                });
+                this.ws.on('error', (error) => {
+                    console.error('Failed to parse message:', error instanceof Error ? error.message : 'Unknown error');
+                    this.emit('error', error);
+                    reject(error);
+                });
+                // Connection timeout
+                setTimeout(() => {
+                    if (!this.isConnected) {
+                        reject(new Error('WebSocket connection timeout'));
+                    }
+                }, this.timeout);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    handleMessage(message) {
+        if (message.id && this.pendingRequests.has(message.id)) {
+            const pending = this.pendingRequests.get(message.id);
+            if (pending) {
+                clearTimeout(pending.timeout);
+                this.pendingRequests.delete(message.id);
+                if (message.type === 'error' || message.error) {
+                    pending.reject(new Error(message.error?.message || 'Unknown error'));
+                }
+                else {
+                    pending.resolve(message.result);
+                }
+            }
+        }
+        else if (message.type === 'notification') {
+            this.emit('notification', message);
+        }
+    }
+    async sendRequest(method, params) {
+        if (!this.isConnected) {
+            throw new Error('WebSocket not connected');
+        }
+        return new Promise((resolve, reject) => {
+            const id = `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+            const request = {
+                id,
+                type: 'request',
+                method,
+                params: params || {}
+            };
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`Request timeout: ${method}`));
+            }, this.timeout);
+            this.pendingRequests.set(id, { resolve, reject, timeout });
+            if (this.ws?.readyState === WebSocket.OPEN) {
+                this.ws.send(JSON.stringify(request));
+            }
+            else {
+                this.pendingRequests.delete(id);
+                clearTimeout(timeout);
+                reject(new Error('WebSocket not connected'));
+            }
+        });
+    }
+    async listTools() {
+        const result = await this.sendRequest('tools/list');
+        return result;
+    }
+    async callTool(name, arguments_ = {}) {
+        const result = await this.sendRequest('tools/call', { name, arguments: arguments_ });
+        return result;
+    }
+    async deleteMemory(id) {
+        return this.callTool('delete_memory', { id });
+    }
+    async searchMemories(args) {
+        return this.callTool('search_memories', args);
+    }
+    async listResources() {
+        const result = await this.sendRequest('resources/list');
+        return result;
+    }
+    async getMemories(query) {
+        const result = await this.sendRequest('resources/read', { uri: query });
+        return result;
+    }
+    disconnect() {
+        if (this.ws) {
+            this.isConnected = false;
+            this.ws.close();
+            this.ws = null;
+        }
+        // Clear all pending requests
+        for (const [, pending] of this.pendingRequests) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error('Connection closed'));
+        }
+        this.pendingRequests.clear();
+    }
+    getConnectionStatus() {
+        return {
+            connected: this.isConnected,
+            url: this.url,
+            reconnectAttempts: this.reconnectAttempts,
+            pendingRequests: this.pendingRequests.size
+        };
+    }
+}

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

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

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

@@ -0,0 +1,126 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { WebSocketMCPClient } from './websocket-mcp-client';
+import WebSocket from 'ws';
+// Mock WebSocket for testing
+class MockWebSocket extends WebSocket {
+    constructor(url) {
+        super(url);
+        // Override for testing
+    }
+    send(data) {
+        // Mock send implementation
+        this.emit('message', JSON.stringify({
+            id: '1',
+            type: 'response',
+            result: { success: true }
+        }));
+    }
+}
+describe('WebSocketMCPClient', () => {
+    let client;
+    const mockOptions = {
+        url: 'ws://localhost:8081',
+        apiKey: 'test-api-key'
+    };
+    beforeEach(() => {
+        client = new WebSocketMCPClient(mockOptions);
+    });
+    afterEach(() => {
+        if (client) {
+            client.disconnect();
+        }
+    });
+    describe('constructor', () => {
+        it('should create client with correct options', () => {
+            expect(client).toBeDefined();
+            expect(client.isConnected()).toBe(false);
+        });
+        it('should use default URL when not provided', () => {
+            const clientWithDefaults = new WebSocketMCPClient({ apiKey: 'test' });
+            expect(clientWithDefaults).toBeDefined();
+        });
+    });
+    describe('connection management', () => {
+        it('should report disconnected state initially', () => {
+            expect(client.isConnected()).toBe(false);
+        });
+        it('should handle connection attempts', async () => {
+            // Mock successful connection
+            const connectPromise = client.connect();
+            // Simulate connection success
+            setTimeout(() => {
+                client.emit('connected');
+            }, 10);
+            await expect(connectPromise).resolves.toBe(true);
+        });
+        it('should handle disconnection', () => {
+            client.disconnect();
+            expect(client.isConnected()).toBe(false);
+        });
+    });
+    describe('message handling', () => {
+        it('should handle MCP request/response cycle', async () => {
+            // This would require more sophisticated mocking
+            // For now, test basic message structure
+            const message = {
+                id: '1',
+                type: 'request',
+                method: 'test_method',
+                params: { test: 'data' }
+            };
+            expect(message.type).toBe('request');
+            expect(message.method).toBe('test_method');
+        });
+        it('should generate unique message IDs', () => {
+            // Test ID generation logic
+            const client1 = new WebSocketMCPClient(mockOptions);
+            const client2 = new WebSocketMCPClient(mockOptions);
+            // Both should start with different internal state
+            expect(client1).not.toBe(client2);
+        });
+    });
+    describe('error handling', () => {
+        it('should handle connection errors gracefully', () => {
+            const errorHandler = jest.fn();
+            client.on('error', errorHandler);
+            // Simulate error
+            client.emit('error', new Error('Test error'));
+            expect(errorHandler).toHaveBeenCalledWith(new Error('Test error'));
+        });
+        it('should handle malformed messages', () => {
+            // Test error handling for invalid JSON
+            expect(() => {
+                JSON.parse('invalid json');
+            }).toThrow();
+        });
+    });
+    describe('MCP protocol compliance', () => {
+        it('should create valid MCP message structure', () => {
+            const message = {
+                id: '123',
+                type: 'request',
+                method: 'memory/create',
+                params: {
+                    title: 'Test Memory',
+                    content: 'Test content'
+                }
+            };
+            expect(message).toHaveProperty('id');
+            expect(message).toHaveProperty('type');
+            expect(message).toHaveProperty('method');
+            expect(message).toHaveProperty('params');
+        });
+        it('should handle MCP response format', () => {
+            const response = {
+                id: '123',
+                type: 'response',
+                result: {
+                    memory_id: 'mem_123',
+                    success: true
+                }
+            };
+            expect(response.type).toBe('response');
+            expect(response.result).toHaveProperty('success');
+        });
+    });
+});

package/package.json

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

package/dist/commands/api-keys.d.ts

@@ -1,3 +0,0 @@
-import { Command } from 'commander';
-declare const apiKeysCommand: Command;
-export default apiKeysCommand;