@lanonasis/cli 2.0.6 → 2.0.9

package/README.md

@@ -1,11 +1,11 @@
-# @lanonasis/cli v2.0.1 - Enhanced Interactive CLI Experience
+# @lanonasis/cli v2.0.9 - Enhanced MCP & Interactive CLI Experience
 
 [![NPM Version](https://img.shields.io/npm/v/@lanonasis/cli)](https://www.npmjs.com/package/@lanonasis/cli)
 [![Downloads](https://img.shields.io/npm/dt/@lanonasis/cli)](https://www.npmjs.com/package/@lanonasis/cli)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Golden Contract](https://img.shields.io/badge/Onasis--Core-v0.1%20Compliant-gold)](https://api.lanonasis.com/.well-known/onasis.json)
 
-🚀 **NEW IN v2.0**: Revolutionary interactive CLI experience with guided workflows, smart suggestions, achievement system, and power user mode. Professional command-line interface for LanOnasis Memory as a Service (MaaS) platform with **Golden Contract compliance**.
+🚀 **NEW IN v2.0.9**: Advanced Model Context Protocol (MCP) support with multi-server connections, enhanced error handling, and enterprise-grade transport protocols. Revolutionary interactive CLI experience with guided workflows, smart suggestions, achievement system, and power user mode. Professional command-line interface for LanOnasis Memory as a Service (MaaS) platform with **Golden Contract compliance**.
 
 ## 🚀 Quick Start
 
@@ -152,13 +152,36 @@ onasis api-keys revoke <id>               # Revoke API key
 onasis api-keys rotate <id>               # Rotate API key
 ```
 
-### MCP Integration
+### MCP Integration (Enhanced in v2.0.9)
 ```bash
-onasis mcp status                         # MCP server status
+# Connection Management
+onasis mcp status                         # MCP server status with health info
 onasis mcp connect --remote              # Connect to remote MCP server
+onasis mcp connect --local               # Connect to local MCP server
 onasis mcp disconnect                     # Disconnect from MCP
+onasis mcp list-servers                   # List all connected servers
+
+# Tool & Resource Management  
 onasis mcp tools                          # List available MCP tools
 onasis mcp resources                      # List MCP resources
+onasis mcp call <tool> --args             # Execute MCP tool directly
+
+# Advanced Features (v2.0.9)
+onasis mcp health                         # Detailed health check with latency
+onasis mcp server start                   # Start local MCP server
+onasis mcp server stop                    # Stop local MCP server
+```
+
+### 🆕 MCP Server Mode (v2.0.9)
+Run the CLI as a standalone MCP server:
+```bash
+# Start MCP server for IDE integrations
+lanonasis-mcp-server --verbose
+
+# Use with environment variables
+LANONASIS_API_URL=https://api.lanonasis.com \
+LANONASIS_TOKEN=your-token \
+lanonasis-mcp-server
 ```
 
 ### Configuration Management  

package/dist/commands/auth.js

@@ -21,11 +21,24 @@ export async function loginCommand(options) {
     console.log(chalk.blue.bold('🔐 Onasis-Core Golden Contract Authentication'));
     console.log(colors.info('━'.repeat(50)));
     console.log();
+    // Debug: Check options
+    if (process.env.CLI_VERBOSE === 'true') {
+        console.log('Debug - Login options:', {
+            hasEmail: !!options.email,
+            hasPassword: !!options.password,
+            hasVendorKey: !!options.vendorKey
+        });
+    }
     // Enhanced authentication flow - check for vendor key first
     if (options.vendorKey) {
         await handleVendorKeyAuth(options.vendorKey, config);
         return;
     }
+    // Check for email/password for direct credentials flow
+    if (options.email && options.password) {
+        await handleCredentialsFlow(options, config);
+        return;
+    }
     // Show authentication options
     const authChoice = await inquirer.prompt([
         {

package/dist/index-simple.js

@@ -45,7 +45,7 @@ program
     .alias(isOnasisInvocation ? 'lanonasis' : 'memory')
     .alias(isOnasisInvocation ? 'memory' : 'maas')
     .description(colors.info(`🧠 ${isOnasisInvocation ? 'Onasis-Core Golden Contract CLI' : 'LanOnasis Enterprise CLI'} - Memory as a Service, API Management & Infrastructure Orchestration`))
-    .version('2.0.1', '-v, --version', 'display version number')
+    .version('2.0.6', '-v, --version', 'display version number')
     .option('-V, --verbose', 'enable verbose logging')
     .option('--api-url <url>', 'override API URL')
     .option('--output <format>', 'output format (json, table, yaml)', 'table')
@@ -133,6 +133,8 @@ const healthCheck = async () => {
     console.log(colors.primary('🏥 LanOnasis System Health Check'));
     console.log(colors.info('═'.repeat(40)));
     console.log();
+    // Initialize config
+    await cliConfig.init();
     // Authentication status
     process.stdout.write('Authentication status: ');
     const isAuth = await cliConfig.isAuthenticated();
@@ -195,10 +197,11 @@ const healthCheck = async () => {
 // Check if user is authenticated for protected commands
 const requireAuth = (command) => {
     command.hook('preAction', async () => {
+        await cliConfig.init();
         const isAuthenticated = await cliConfig.isAuthenticated();
         if (!isAuthenticated) {
             console.error(chalk.red('✖ Authentication required'));
-            console.log(chalk.yellow('Please run:'), chalk.white('memory login'));
+            console.log(chalk.yellow('Please run:'), chalk.white('lanonasis auth login'));
             process.exit(1);
         }
     });
@@ -646,7 +649,7 @@ async function main() {
                 console.log(script);
                 return;
             }
-            catch (error) {
+            catch {
                 console.error(colors.error('Failed to read completion script'));
                 process.exit(1);
             }

package/dist/index.js

@@ -104,6 +104,8 @@ const healthCheck = async () => {
     console.log(colors.primary('🏥 LanOnasis System Health Check'));
     console.log(colors.info('═'.repeat(40)));
     console.log();
+    // Initialize config
+    await cliConfig.init();
     // Authentication status
     process.stdout.write('Authentication status: ');
     const isAuth = await cliConfig.isAuthenticated();
@@ -166,10 +168,11 @@ const healthCheck = async () => {
 // Check if user is authenticated for protected commands
 const requireAuth = (command) => {
     command.hook('preAction', async () => {
+        await cliConfig.init();
         const isAuthenticated = await cliConfig.isAuthenticated();
         if (!isAuthenticated) {
             console.error(chalk.red('✖ Authentication required'));
-            console.log(chalk.yellow('Please run:'), chalk.white('memory login'));
+            console.log(chalk.yellow('Please run:'), chalk.white('lanonasis auth login'));
             process.exit(1);
         }
     });

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

@@ -0,0 +1,116 @@
+/**
+ * Enhanced MCP Client with advanced features
+ * Provides multi-server support, connection pooling, and better error handling
+ */
+import { EventEmitter } from 'events';
+export interface MCPServerConfig {
+    name: string;
+    url?: string;
+    command?: string;
+    args?: string[];
+    type: 'stdio' | 'http' | 'websocket';
+    timeout?: number;
+    maxRetries?: number;
+    priority?: number;
+}
+export interface ToolChain {
+    tools: Array<{
+        name: string;
+        args: Record<string, any>;
+        waitForCompletion?: boolean;
+    }>;
+    mode: 'sequential' | 'parallel';
+}
+export interface ConnectionStatus {
+    server: string;
+    status: 'connected' | 'disconnected' | 'error' | 'connecting';
+    lastPing?: Date;
+    latency?: number;
+    error?: string;
+}
+export declare class EnhancedMCPClient extends EventEmitter {
+    private clients;
+    private transports;
+    private connectionStatus;
+    private retryAttempts;
+    private healthCheckIntervals;
+    private spinner;
+    constructor();
+    /**
+     * Setup internal event handlers
+     */
+    private setupEventHandlers;
+    /**
+     * Connect to multiple MCP servers
+     */
+    connectMultiple(servers: MCPServerConfig[]): Promise<Map<string, boolean>>;
+    /**
+     * Connect to a single MCP server with retry logic
+     */
+    connectSingle(config: MCPServerConfig): Promise<boolean>;
+    /**
+     * Create client with timeout
+     */
+    private createClientWithTimeout;
+    /**
+     * Create MCP client based on config
+     */
+    private createClient;
+    /**
+     * Create WebSocket transport
+     */
+    private createWebSocketTransport;
+    /**
+     * Execute a chain of tools
+     */
+    executeToolChain(chain: ToolChain): Promise<any[]>;
+    /**
+     * Execute a single tool with automatic server selection
+     */
+    executeTool(toolName: string, args: Record<string, any>): Promise<any>;
+    /**
+     * Select the best server for a tool based on availability and latency
+     */
+    private selectBestServer;
+    /**
+     * Select a failover server
+     */
+    private selectFailoverServer;
+    /**
+     * Wait for tool completion (for async operations)
+     */
+    private waitForToolCompletion;
+    /**
+     * Start health monitoring for a server
+     */
+    private startHealthMonitoring;
+    /**
+     * Perform health check for a server
+     */
+    private performHealthCheck;
+    /**
+     * Update connection status
+     */
+    private updateConnectionStatus;
+    /**
+     * Get server configuration (placeholder - should be stored during connect)
+     */
+    private getServerConfig;
+    /**
+     * Get all connection statuses
+     */
+    getConnectionStatuses(): ConnectionStatus[];
+    /**
+     * Disconnect from all servers
+     */
+    disconnectAll(): Promise<void>;
+    /**
+     * Disconnect from a specific server
+     */
+    disconnect(serverName: string): Promise<void>;
+    /**
+     * Utility delay function
+     */
+    private delay;
+}
+export declare const enhancedMCPClient: EnhancedMCPClient;

package/dist/mcp/client/enhanced-client.js

@@ -0,0 +1,379 @@
+/**
+ * Enhanced MCP Client with advanced features
+ * Provides multi-server support, connection pooling, and better error handling
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import chalk from 'chalk';
+import { EventEmitter } from 'events';
+export class EnhancedMCPClient extends EventEmitter {
+    clients = new Map();
+    transports = new Map();
+    connectionStatus = new Map();
+    retryAttempts = new Map();
+    healthCheckIntervals = new Map();
+    spinner = null;
+    constructor() {
+        super();
+        this.setupEventHandlers();
+    }
+    /**
+     * Setup internal event handlers
+     */
+    setupEventHandlers() {
+        this.on('connection:established', (server) => {
+            console.log(chalk.green(`✅ Connected to ${server}`));
+        });
+        this.on('connection:lost', (server) => {
+            console.log(chalk.yellow(`⚠️ Lost connection to ${server}`));
+        });
+        this.on('connection:error', (server, error) => {
+            console.log(chalk.red(`❌ Connection error for ${server}: ${error.message}`));
+        });
+    }
+    /**
+     * Connect to multiple MCP servers
+     */
+    async connectMultiple(servers) {
+        const results = new Map();
+        // Sort servers by priority
+        const sortedServers = servers.sort((a, b) => (a.priority || 999) - (b.priority || 999));
+        // Connect in parallel with controlled concurrency
+        const connectionPromises = sortedServers.map(server => this.connectSingle(server).then(success => {
+            results.set(server.name, success);
+            return { server: server.name, success };
+        }));
+        await Promise.allSettled(connectionPromises);
+        // Start health monitoring for connected servers
+        for (const [name, success] of results) {
+            if (success) {
+                this.startHealthMonitoring(name);
+            }
+        }
+        return results;
+    }
+    /**
+     * Connect to a single MCP server with retry logic
+     */
+    async connectSingle(config) {
+        const maxRetries = config.maxRetries || 3;
+        const timeout = config.timeout || 30000;
+        let attempts = 0;
+        while (attempts < maxRetries) {
+            try {
+                this.updateConnectionStatus(config.name, 'connecting');
+                const client = await this.createClientWithTimeout(config, timeout);
+                this.clients.set(config.name, client);
+                this.updateConnectionStatus(config.name, 'connected');
+                this.emit('connection:established', config.name);
+                return true;
+            }
+            catch (error) {
+                attempts++;
+                this.retryAttempts.set(config.name, attempts);
+                if (attempts >= maxRetries) {
+                    this.updateConnectionStatus(config.name, 'error', error);
+                    this.emit('connection:error', config.name, error);
+                    return false;
+                }
+                // Exponential backoff
+                const delay = Math.min(1000 * Math.pow(2, attempts), 10000);
+                console.log(chalk.yellow(`⏳ Retrying connection to ${config.name} in ${delay}ms...`));
+                await this.delay(delay);
+            }
+        }
+        return false;
+    }
+    /**
+     * Create client with timeout
+     */
+    async createClientWithTimeout(config, timeout) {
+        return Promise.race([
+            this.createClient(config),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`Connection timeout after ${timeout}ms`)), timeout))
+        ]);
+    }
+    /**
+     * Create MCP client based on config
+     */
+    async createClient(config) {
+        let transport;
+        switch (config.type) {
+            case 'stdio':
+                if (!config.command) {
+                    throw new Error('Command required for stdio transport');
+                }
+                transport = new StdioClientTransport({
+                    command: config.command,
+                    args: config.args || []
+                });
+                break;
+            case 'http':
+                if (!config.url) {
+                    throw new Error('URL required for http transport');
+                }
+                // HTTP transport is not directly supported by MCP SDK
+                // Use stdio or websocket instead
+                throw new Error('HTTP transport not directly supported. Use websocket or stdio transport.');
+                break;
+            case 'websocket':
+                if (!config.url) {
+                    throw new Error('URL required for websocket transport');
+                }
+                transport = await this.createWebSocketTransport(config.url);
+                break;
+            default:
+                throw new Error(`Unsupported transport type: ${config.type}`);
+        }
+        this.transports.set(config.name, transport);
+        const client = new Client({
+            name: `lanonasis-cli-${config.name}`,
+            version: '2.0.8'
+        }, {
+            capabilities: {
+                tools: {},
+                resources: {},
+                prompts: {}
+            }
+        });
+        await client.connect(transport);
+        return client;
+    }
+    /**
+     * Create WebSocket transport
+     */
+    async createWebSocketTransport(url) {
+        // Custom WebSocket transport implementation
+        const WebSocket = (await import('ws')).default;
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(url);
+            ws.on('open', () => {
+                resolve({
+                    send: (data) => ws.send(JSON.stringify(data)),
+                    on: (event, handler) => ws.on(event, handler),
+                    close: () => ws.close()
+                });
+            });
+            ws.on('error', reject);
+        });
+    }
+    /**
+     * Execute a chain of tools
+     */
+    async executeToolChain(chain) {
+        const results = [];
+        if (chain.mode === 'sequential') {
+            for (const tool of chain.tools) {
+                const result = await this.executeTool(tool.name, tool.args);
+                results.push(result);
+                if (tool.waitForCompletion) {
+                    await this.waitForToolCompletion(tool.name, result);
+                }
+            }
+        }
+        else {
+            // Parallel execution
+            const promises = chain.tools.map(tool => this.executeTool(tool.name, tool.args));
+            const parallelResults = await Promise.allSettled(promises);
+            parallelResults.forEach((result, index) => {
+                if (result.status === 'fulfilled') {
+                    results.push(result.value);
+                }
+                else {
+                    results.push({ error: result.reason, tool: chain.tools[index].name });
+                }
+            });
+        }
+        return results;
+    }
+    /**
+     * Execute a single tool with automatic server selection
+     */
+    async executeTool(toolName, args) {
+        // Find the best available server for this tool
+        const server = await this.selectBestServer(toolName);
+        if (!server) {
+            throw new Error(`No available server for tool: ${toolName}`);
+        }
+        const client = this.clients.get(server);
+        if (!client) {
+            throw new Error(`Client not found for server: ${server}`);
+        }
+        try {
+            const result = await client.callTool({
+                name: toolName,
+                arguments: args
+            });
+            return result;
+        }
+        catch (error) {
+            // Try failover to another server
+            const failoverServer = await this.selectFailoverServer(server, toolName);
+            if (failoverServer) {
+                console.log(chalk.yellow(`⚠️ Failing over to ${failoverServer}...`));
+                const failoverClient = this.clients.get(failoverServer);
+                if (failoverClient) {
+                    return failoverClient.callTool({
+                        name: toolName,
+                        arguments: args
+                    });
+                }
+            }
+            throw error;
+        }
+    }
+    /**
+     * Select the best server for a tool based on availability and latency
+     */
+    async selectBestServer(toolName) {
+        const availableServers = Array.from(this.clients.keys()).filter(name => {
+            const status = this.connectionStatus.get(name);
+            return status?.status === 'connected';
+        });
+        if (availableServers.length === 0) {
+            return null;
+        }
+        // For now, return the first available server
+        // TODO: Implement smarter selection based on tool availability and latency
+        return availableServers[0];
+    }
+    /**
+     * Select a failover server
+     */
+    async selectFailoverServer(excludeServer, toolName) {
+        const availableServers = Array.from(this.clients.keys()).filter(name => {
+            const status = this.connectionStatus.get(name);
+            return name !== excludeServer && status?.status === 'connected';
+        });
+        return availableServers.length > 0 ? availableServers[0] : null;
+    }
+    /**
+     * Wait for tool completion (for async operations)
+     */
+    async waitForToolCompletion(toolName, initialResult) {
+        // Implementation depends on the specific tool
+        // This is a placeholder for tools that return operation IDs
+        if (initialResult.operationId) {
+            let completed = false;
+            let attempts = 0;
+            const maxAttempts = 60; // 1 minute with 1 second intervals
+            while (!completed && attempts < maxAttempts) {
+                await this.delay(1000);
+                // Check operation status (implementation specific)
+                // completed = await this.checkOperationStatus(initialResult.operationId);
+                attempts++;
+            }
+        }
+    }
+    /**
+     * Start health monitoring for a server
+     */
+    startHealthMonitoring(serverName) {
+        // Clear existing interval if any
+        const existingInterval = this.healthCheckIntervals.get(serverName);
+        if (existingInterval) {
+            clearInterval(existingInterval);
+        }
+        const interval = setInterval(async () => {
+            await this.performHealthCheck(serverName);
+        }, 30000); // Check every 30 seconds
+        this.healthCheckIntervals.set(serverName, interval);
+    }
+    /**
+     * Perform health check for a server
+     */
+    async performHealthCheck(serverName) {
+        const client = this.clients.get(serverName);
+        if (!client)
+            return;
+        const startTime = Date.now();
+        try {
+            // Use a simple tool call as a health check
+            await client.listTools();
+            const latency = Date.now() - startTime;
+            this.updateConnectionStatus(serverName, 'connected', undefined, latency);
+        }
+        catch (error) {
+            this.updateConnectionStatus(serverName, 'error', error);
+            // Attempt reconnection
+            const config = this.getServerConfig(serverName);
+            if (config) {
+                console.log(chalk.yellow(`⚠️ Attempting to reconnect to ${serverName}...`));
+                await this.connectSingle(config);
+            }
+        }
+    }
+    /**
+     * Update connection status
+     */
+    updateConnectionStatus(server, status, error, latency) {
+        this.connectionStatus.set(server, {
+            server,
+            status,
+            lastPing: new Date(),
+            latency,
+            error: error?.message
+        });
+    }
+    /**
+     * Get server configuration (placeholder - should be stored during connect)
+     */
+    getServerConfig(serverName) {
+        // TODO: Store and retrieve server configs
+        return null;
+    }
+    /**
+     * Get all connection statuses
+     */
+    getConnectionStatuses() {
+        return Array.from(this.connectionStatus.values());
+    }
+    /**
+     * Disconnect from all servers
+     */
+    async disconnectAll() {
+        // Stop all health monitoring
+        for (const interval of this.healthCheckIntervals.values()) {
+            clearInterval(interval);
+        }
+        this.healthCheckIntervals.clear();
+        // Disconnect all clients
+        for (const [name, client] of this.clients) {
+            try {
+                await client.close();
+                console.log(chalk.gray(`Disconnected from ${name}`));
+            }
+            catch (error) {
+                console.log(chalk.yellow(`Warning: Error disconnecting from ${name}`));
+            }
+        }
+        this.clients.clear();
+        this.transports.clear();
+        this.connectionStatus.clear();
+    }
+    /**
+     * Disconnect from a specific server
+     */
+    async disconnect(serverName) {
+        const interval = this.healthCheckIntervals.get(serverName);
+        if (interval) {
+            clearInterval(interval);
+            this.healthCheckIntervals.delete(serverName);
+        }
+        const client = this.clients.get(serverName);
+        if (client) {
+            await client.close();
+            this.clients.delete(serverName);
+        }
+        this.transports.delete(serverName);
+        this.connectionStatus.delete(serverName);
+    }
+    /**
+     * Utility delay function
+     */
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+// Export singleton instance
+export const enhancedMCPClient = new EnhancedMCPClient();