@lanonasis/cli 1.5.0 → 1.5.2

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

@@ -1,182 +0,0 @@
-/**
- * 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

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

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

@@ -1,126 +0,0 @@
-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');
-        });
-    });
-});