@lanonasis/cli 2.0.7 → 3.0.1

package/dist/mcp/transports/transport-manager.d.ts

@@ -0,0 +1,82 @@
+/**
+ * MCP Transport Manager
+ * Handles multiple transport types for MCP connections
+ */
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+export type TransportType = 'stdio' | 'http' | 'websocket' | 'sse';
+export interface TransportConfig {
+    type: TransportType;
+    url?: string;
+    command?: string;
+    args?: string[];
+    headers?: Record<string, string>;
+    auth?: {
+        type: 'bearer' | 'apikey' | 'basic';
+        value: string;
+    };
+    reconnect?: {
+        enabled: boolean;
+        maxAttempts?: number;
+        delay?: number;
+    };
+    timeout?: number;
+}
+export interface Transport {
+    send(data: any): Promise<void>;
+    on(event: string, handler: Function): void;
+    off(event: string, handler: Function): void;
+    close(): Promise<void>;
+    isConnected(): boolean;
+}
+/**
+ * Transport Manager class
+ */
+export declare class MCPTransportManager {
+    private transports;
+    private configs;
+    /**
+     * Create a transport based on configuration
+     */
+    createTransport(name: string, config: TransportConfig): Promise<Transport>;
+    /**
+     * Setup event forwarding for monitoring
+     */
+    private setupEventForwarding;
+    /**
+     * Get a transport by name
+     */
+    getTransport(name: string): Transport | undefined;
+    /**
+     * Create stdio transport helper
+     */
+    createStdioTransport(command: string, args?: string[]): Promise<StdioClientTransport>;
+    /**
+     * Create HTTP transport helper
+     */
+    createHttpTransport(url: string, headers?: Record<string, string>, auth?: TransportConfig['auth']): Promise<Transport>;
+    /**
+     * Create WebSocket transport helper
+     */
+    createWebSocketTransport(url: string, options?: {
+        headers?: Record<string, string>;
+        auth?: TransportConfig['auth'];
+        reconnect?: TransportConfig['reconnect'];
+    }): Promise<Transport>;
+    /**
+     * Close all transports
+     */
+    closeAll(): Promise<void>;
+    /**
+     * Close a specific transport
+     */
+    closeTransport(name: string): Promise<void>;
+    /**
+     * Get all transport statuses
+     */
+    getStatuses(): Record<string, boolean>;
+    /**
+     * Reconnect a transport
+     */
+    reconnect(name: string): Promise<Transport>;
+}
+export declare const transportManager: MCPTransportManager;

package/dist/mcp/transports/transport-manager.js

@@ -0,0 +1,434 @@
+/**
+ * MCP Transport Manager
+ * Handles multiple transport types for MCP connections
+ */
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { EventEmitter } from 'events';
+import WebSocket from 'ws';
+import chalk from 'chalk';
+/**
+ * StdIO Transport wrapper
+ */
+class StdioTransport extends EventEmitter {
+    transport;
+    connected = false;
+    constructor(config) {
+        super();
+        if (!config.command) {
+            throw new Error('Command required for stdio transport');
+        }
+        this.transport = new StdioClientTransport({
+            command: config.command,
+            args: config.args || []
+        });
+        this.connected = true;
+    }
+    async send(data) {
+        if (!this.connected) {
+            throw new Error('Transport not connected');
+        }
+        // StdioClientTransport handles this internally
+        this.emit('send', data);
+    }
+    async close() {
+        this.connected = false;
+        this.removeAllListeners();
+    }
+    isConnected() {
+        return this.connected;
+    }
+    getInternalTransport() {
+        return this.transport;
+    }
+}
+/**
+ * HTTP Transport wrapper
+ */
+class HttpTransport extends EventEmitter {
+    url;
+    headers;
+    connected = false;
+    auth;
+    constructor(config) {
+        super();
+        if (!config.url) {
+            throw new Error('URL required for HTTP transport');
+        }
+        this.url = config.url;
+        this.headers = config.headers || {};
+        this.auth = config.auth;
+        if (this.auth) {
+            this.setupAuthentication();
+        }
+        this.connected = true;
+    }
+    setupAuthentication() {
+        if (!this.auth)
+            return;
+        switch (this.auth.type) {
+            case 'bearer':
+                this.headers['Authorization'] = `Bearer ${this.auth.value}`;
+                break;
+            case 'apikey':
+                this.headers['X-API-Key'] = this.auth.value;
+                break;
+            case 'basic':
+                this.headers['Authorization'] = `Basic ${this.auth.value}`;
+                break;
+        }
+    }
+    async send(data) {
+        if (!this.connected) {
+            throw new Error('Transport not connected');
+        }
+        try {
+            const response = await fetch(this.url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...this.headers
+                },
+                body: JSON.stringify(data)
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
+            }
+            const result = await response.json();
+            this.emit('message', result);
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    async close() {
+        this.connected = false;
+        this.removeAllListeners();
+    }
+    isConnected() {
+        return this.connected;
+    }
+}
+/**
+ * WebSocket Transport wrapper
+ */
+class WebSocketTransport extends EventEmitter {
+    ws = null;
+    url;
+    connected = false;
+    reconnectConfig;
+    reconnectAttempts = 0;
+    reconnectTimer;
+    headers;
+    constructor(config) {
+        super();
+        if (!config.url) {
+            throw new Error('URL required for WebSocket transport');
+        }
+        this.url = config.url;
+        this.reconnectConfig = config.reconnect;
+        this.headers = config.headers || {};
+        if (config.auth) {
+            this.setupAuthentication(config.auth);
+        }
+    }
+    setupAuthentication(auth) {
+        if (!auth)
+            return;
+        switch (auth.type) {
+            case 'bearer':
+                this.headers['Authorization'] = `Bearer ${auth.value}`;
+                break;
+            case 'apikey':
+                this.headers['X-API-Key'] = auth.value;
+                break;
+        }
+    }
+    async connect() {
+        return new Promise((resolve, reject) => {
+            try {
+                this.ws = new WebSocket(this.url, {
+                    headers: this.headers
+                });
+                this.ws.on('open', () => {
+                    this.connected = true;
+                    this.reconnectAttempts = 0;
+                    this.emit('connected');
+                    console.log(chalk.green(`✅ WebSocket connected to ${this.url}`));
+                    resolve();
+                });
+                this.ws.on('message', (data) => {
+                    try {
+                        const message = JSON.parse(data.toString());
+                        this.emit('message', message);
+                    }
+                    catch (error) {
+                        this.emit('error', new Error('Failed to parse WebSocket message'));
+                    }
+                });
+                this.ws.on('error', (error) => {
+                    this.emit('error', error);
+                    if (!this.connected) {
+                        reject(error);
+                    }
+                });
+                this.ws.on('close', (code, reason) => {
+                    this.connected = false;
+                    this.emit('disconnected', { code, reason: reason.toString() });
+                    if (this.shouldReconnect()) {
+                        this.scheduleReconnect();
+                    }
+                });
+                // Set connection timeout
+                setTimeout(() => {
+                    if (!this.connected) {
+                        reject(new Error('WebSocket connection timeout'));
+                    }
+                }, 10000);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    shouldReconnect() {
+        if (!this.reconnectConfig?.enabled)
+            return false;
+        const maxAttempts = this.reconnectConfig.maxAttempts || 5;
+        return this.reconnectAttempts < maxAttempts;
+    }
+    scheduleReconnect() {
+        const delay = this.reconnectConfig?.delay || 5000;
+        const backoff = Math.min(delay * Math.pow(2, this.reconnectAttempts), 30000);
+        this.reconnectAttempts++;
+        console.log(chalk.yellow(`⏳ Reconnecting WebSocket in ${backoff}ms (attempt ${this.reconnectAttempts})...`));
+        this.reconnectTimer = setTimeout(() => {
+            this.connect().catch(error => {
+                console.error(chalk.red('Reconnection failed:'), error);
+            });
+        }, backoff);
+    }
+    async send(data) {
+        if (!this.connected || !this.ws) {
+            throw new Error('WebSocket not connected');
+        }
+        return new Promise((resolve, reject) => {
+            this.ws.send(JSON.stringify(data), (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    async close() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+        }
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.connected = false;
+        this.removeAllListeners();
+    }
+    isConnected() {
+        return this.connected;
+    }
+}
+/**
+ * Server-Sent Events Transport
+ */
+class SSETransport extends EventEmitter {
+    eventSource = null;
+    url;
+    connected = false;
+    headers;
+    constructor(config) {
+        super();
+        if (!config.url) {
+            throw new Error('URL required for SSE transport');
+        }
+        this.url = config.url;
+        this.headers = config.headers || {};
+    }
+    async connect() {
+        // Dynamic import for EventSource
+        const { EventSource } = await import('eventsource');
+        // EventSource doesn't support headers directly
+        this.eventSource = new EventSource(this.url);
+        return new Promise((resolve, reject) => {
+            this.eventSource.onopen = () => {
+                this.connected = true;
+                this.emit('connected');
+                resolve();
+            };
+            this.eventSource.onmessage = (event) => {
+                try {
+                    const data = JSON.parse(event.data);
+                    this.emit('message', data);
+                }
+                catch (error) {
+                    this.emit('error', new Error('Failed to parse SSE message'));
+                }
+            };
+            this.eventSource.onerror = (error) => {
+                this.emit('error', error);
+                if (!this.connected) {
+                    reject(error);
+                }
+            };
+        });
+    }
+    async send(data) {
+        // SSE is receive-only, but we can send data via HTTP POST
+        throw new Error('SSE transport is read-only. Use HTTP for sending data.');
+    }
+    async close() {
+        if (this.eventSource) {
+            this.eventSource.close();
+            this.eventSource = null;
+        }
+        this.connected = false;
+        this.removeAllListeners();
+    }
+    isConnected() {
+        return this.connected;
+    }
+}
+/**
+ * Transport Manager class
+ */
+export class MCPTransportManager {
+    transports = new Map();
+    configs = new Map();
+    /**
+     * Create a transport based on configuration
+     */
+    async createTransport(name, config) {
+        // Store config for potential reconnection
+        this.configs.set(name, config);
+        let transport;
+        switch (config.type) {
+            case 'stdio':
+                transport = new StdioTransport(config);
+                break;
+            case 'http':
+                transport = new HttpTransport(config);
+                break;
+            case 'websocket':
+                transport = new WebSocketTransport(config);
+                await transport.connect();
+                break;
+            case 'sse':
+                transport = new SSETransport(config);
+                await transport.connect();
+                break;
+            default:
+                throw new Error(`Unsupported transport type: ${config.type}`);
+        }
+        this.transports.set(name, transport);
+        // Setup event forwarding
+        this.setupEventForwarding(name, transport);
+        return transport;
+    }
+    /**
+     * Setup event forwarding for monitoring
+     */
+    setupEventForwarding(name, transport) {
+        transport.on('connected', () => {
+            console.log(chalk.green(`✅ Transport '${name}' connected`));
+        });
+        transport.on('disconnected', (reason) => {
+            console.log(chalk.yellow(`⚠️ Transport '${name}' disconnected:`, reason));
+        });
+        transport.on('error', (error) => {
+            console.log(chalk.red(`❌ Transport '${name}' error:`, error.message));
+        });
+    }
+    /**
+     * Get a transport by name
+     */
+    getTransport(name) {
+        return this.transports.get(name);
+    }
+    /**
+     * Create stdio transport helper
+     */
+    async createStdioTransport(command, args = []) {
+        const transport = new StdioTransport({
+            type: 'stdio',
+            command,
+            args
+        });
+        return transport.getInternalTransport();
+    }
+    /**
+     * Create HTTP transport helper
+     */
+    async createHttpTransport(url, headers, auth) {
+        return this.createTransport('http-default', {
+            type: 'http',
+            url,
+            headers,
+            auth
+        });
+    }
+    /**
+     * Create WebSocket transport helper
+     */
+    async createWebSocketTransport(url, options) {
+        return this.createTransport('websocket-default', {
+            type: 'websocket',
+            url,
+            ...options
+        });
+    }
+    /**
+     * Close all transports
+     */
+    async closeAll() {
+        const closePromises = Array.from(this.transports.values()).map(transport => transport.close());
+        await Promise.all(closePromises);
+        this.transports.clear();
+        this.configs.clear();
+    }
+    /**
+     * Close a specific transport
+     */
+    async closeTransport(name) {
+        const transport = this.transports.get(name);
+        if (transport) {
+            await transport.close();
+            this.transports.delete(name);
+            this.configs.delete(name);
+        }
+    }
+    /**
+     * Get all transport statuses
+     */
+    getStatuses() {
+        const statuses = {};
+        for (const [name, transport] of this.transports) {
+            statuses[name] = transport.isConnected();
+        }
+        return statuses;
+    }
+    /**
+     * Reconnect a transport
+     */
+    async reconnect(name) {
+        const config = this.configs.get(name);
+        if (!config) {
+            throw new Error(`No configuration found for transport: ${name}`);
+        }
+        // Close existing if any
+        await this.closeTransport(name);
+        // Create new transport
+        return this.createTransport(name, config);
+    }
+}
+// Export singleton instance
+export const transportManager = new MCPTransportManager();

package/dist/utils/api.js

@@ -15,9 +15,14 @@ export class APIClient {
             await this.config.discoverServices();
             // Use appropriate base URL based on endpoint
             const isAuthEndpoint = config.url?.includes('/auth/') || config.url?.includes('/login') || config.url?.includes('/register');
+            const discoveredServices = this.config.get('discoveredServices');
             config.baseURL = isAuthEndpoint ?
-                (this.config.get('discoveredServices')?.auth_base || 'https://api.lanonasis.com/auth') :
+                (discoveredServices?.auth_base || 'https://api.lanonasis.com') :
                 this.config.getApiUrl();
+            // Add project scope header for auth endpoints
+            if (isAuthEndpoint) {
+                config.headers['X-Project-Scope'] = 'lanonasis-maas';
+            }
             // Enhanced Authentication Support
             const token = this.config.getToken();
             const vendorKey = this.config.getVendorKey();
@@ -77,17 +82,17 @@ export class APIClient {
     }
     // Authentication - aligned with Supabase auth
     async login(email, password) {
-        const response = await this.client.post('/api/v1/auth/login', {
+        const response = await this.client.post('/v1/auth/login', {
             email,
             password
         });
         return response.data;
     }
     async register(email, password, organizationName) {
-        const response = await this.client.post('/api/v1/auth/register', {
+        const response = await this.client.post('/v1/auth/signup', {
             email,
             password,
-            organization_name: organizationName
+            name: organizationName
         });
         return response.data;
     }

package/dist/utils/config.d.ts

@@ -27,9 +27,9 @@ export declare class CLIConfig {
     clear(): Promise<void>;
     getConfigPath(): string;
     exists(): Promise<boolean>;
-    get(key: string): any;
-    set(key: string, value: any): void;
-    setAndSave(key: string, value: any): Promise<void>;
+    get<T = unknown>(key: string): T;
+    set(key: string, value: unknown): void;
+    setAndSave(key: string, value: unknown): Promise<void>;
     getMCPServerPath(): string;
     getMCPServerUrl(): string;
     shouldUseRemoteMCP(): boolean;

package/dist/utils/config.js

@@ -118,6 +118,22 @@ export class CLIConfig {
         const token = this.getToken();
         if (!token)
             return false;
+        // Handle simple CLI tokens (format: cli_xxx_timestamp)
+        if (token.startsWith('cli_')) {
+            // Extract timestamp from CLI token
+            const parts = token.split('_');
+            if (parts.length >= 3) {
+                const timestamp = parseInt(parts[parts.length - 1]);
+                if (!isNaN(timestamp)) {
+                    // CLI tokens are valid for 30 days
+                    const thirtyDaysInMs = 30 * 24 * 60 * 60 * 1000;
+                    return (Date.now() - timestamp) < thirtyDaysInMs;
+                }
+            }
+            // If we can't parse timestamp, assume valid (fallback)
+            return true;
+        }
+        // Handle JWT tokens
         try {
             const decoded = jwtDecode(token);
             const now = Date.now() / 1000;

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

@@ -50,6 +50,10 @@ export declare class MCPClient {
     private sseConnection;
     private wsConnection;
     constructor();
+    /**
+     * Initialize the MCP client configuration
+     */
+    init(): Promise<void>;
     /**
      * Connect to MCP server (local or remote)
      */