@lanonasis/cli 1.0.1 → 1.2.0

package/dist/utils/api.d.ts

@@ -1,24 +1,164 @@
 import { AxiosRequestConfig } from 'axios';
+export interface AuthResponse {
+    user: {
+        id: string;
+        email: string;
+        organization_id: string;
+        role: 'admin' | 'user' | 'viewer';
+        plan: 'free' | 'pro' | 'enterprise';
+        created_at: string;
+        updated_at: string;
+    };
+    token: string;
+    expires_at: string;
+}
+export interface RegisterRequest {
+    email: string;
+    password: string;
+    organization_name?: string;
+}
+export interface LoginRequest {
+    email: string;
+    password: string;
+}
+export type MemoryType = 'context' | 'project' | 'knowledge' | 'reference' | 'personal' | 'workflow';
+export interface MemoryEntry {
+    id: string;
+    title: string;
+    content: string;
+    memory_type: MemoryType;
+    tags: string[];
+    topic_id?: string | null;
+    user_id: string;
+    organization_id: string;
+    metadata?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+    last_accessed?: string;
+    access_count: number;
+}
+export interface CreateMemoryRequest {
+    title: string;
+    content: string;
+    memory_type?: MemoryType;
+    tags?: string[];
+    topic_id?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface UpdateMemoryRequest {
+    title?: string;
+    content?: string;
+    memory_type?: MemoryType;
+    tags?: string[];
+    topic_id?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface GetMemoriesParams {
+    limit?: number;
+    offset?: number;
+    memory_type?: MemoryType;
+    tags?: string[];
+    topic_id?: string;
+    sort_by?: 'created_at' | 'updated_at' | 'last_accessed' | 'access_count';
+    sort_order?: 'asc' | 'desc';
+}
+export interface SearchMemoryRequest {
+    query: string;
+    memory_types?: MemoryType[];
+    tags?: string[];
+    topic_id?: string;
+    limit?: number;
+    threshold?: number;
+}
+export interface MemorySearchResult extends MemoryEntry {
+    relevance_score: number;
+}
+export interface MemoryStats {
+    total_memories: number;
+    memories_by_type: Record<MemoryType, number>;
+    total_size_bytes: number;
+    avg_access_count: number;
+    most_accessed_memory?: MemoryEntry;
+    recent_memories: MemoryEntry[];
+}
+export interface BulkDeleteRequest {
+    memory_ids: string[];
+}
+export interface BulkDeleteResponse {
+    deleted_count: number;
+    failed_deletes?: string[];
+}
+export interface MemoryTopic {
+    id: string;
+    name: string;
+    description?: string;
+    color?: string;
+    icon?: string;
+    user_id: string;
+    parent_topic_id?: string;
+    is_system: boolean;
+    metadata?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+export interface CreateTopicRequest {
+    name: string;
+    description?: string;
+    color?: string;
+    icon?: string;
+    parent_topic_id?: string;
+}
+export interface UpdateTopicRequest {
+    name?: string;
+    description?: string;
+    color?: string;
+    icon?: string;
+    parent_topic_id?: string;
+}
+export interface HealthStatus {
+    status: 'healthy' | 'unhealthy';
+    version: string;
+    timestamp: string;
+    dependencies: Record<string, {
+        status: string;
+        latency_ms?: number;
+    }>;
+}
+export interface PaginatedResponse<T> {
+    data: T[];
+    pagination: {
+        total: number;
+        limit: number;
+        offset: number;
+        has_more: boolean;
+    };
+}
+export interface ApiErrorResponse {
+    error: string;
+    message: string;
+    status_code: number;
+    details?: Record<string, unknown>;
+}
 export declare class APIClient {
     private client;
     private config;
     constructor();
-    login(email: string, password: string): Promise<any>;
-    register(email: string, password: string, organizationName?: string): Promise<any>;
-    createMemory(data: any): Promise<any>;
-    getMemories(params?: any): Promise<any>;
-    getMemory(id: string): Promise<any>;
-    updateMemory(id: string, data: any): Promise<any>;
+    login(email: string, password: string): Promise<AuthResponse>;
+    register(email: string, password: string, organizationName?: string): Promise<AuthResponse>;
+    createMemory(data: CreateMemoryRequest): Promise<MemoryEntry>;
+    getMemories(params?: GetMemoriesParams): Promise<PaginatedResponse<MemoryEntry>>;
+    getMemory(id: string): Promise<MemoryEntry>;
+    updateMemory(id: string, data: UpdateMemoryRequest): Promise<MemoryEntry>;
     deleteMemory(id: string): Promise<void>;
-    searchMemories(query: string, options?: any): Promise<any>;
-    getMemoryStats(): Promise<any>;
-    bulkDeleteMemories(memoryIds: string[]): Promise<any>;
-    createTopic(data: any): Promise<any>;
-    getTopics(): Promise<any>;
-    getTopic(id: string): Promise<any>;
-    updateTopic(id: string, data: any): Promise<any>;
+    searchMemories(query: string, options?: Omit<SearchMemoryRequest, 'query'>): Promise<PaginatedResponse<MemorySearchResult>>;
+    getMemoryStats(): Promise<MemoryStats>;
+    bulkDeleteMemories(memoryIds: string[]): Promise<BulkDeleteResponse>;
+    createTopic(data: CreateTopicRequest): Promise<MemoryTopic>;
+    getTopics(): Promise<MemoryTopic[]>;
+    getTopic(id: string): Promise<MemoryTopic>;
+    updateTopic(id: string, data: UpdateTopicRequest): Promise<MemoryTopic>;
     deleteTopic(id: string): Promise<void>;
-    getHealth(): Promise<any>;
-    request<T = any>(config: AxiosRequestConfig): Promise<T>;
+    getHealth(): Promise<HealthStatus>;
+    request<T = Record<string, unknown>>(config: AxiosRequestConfig): Promise<T>;
 }
 export declare const apiClient: APIClient;

package/dist/utils/config.d.ts

@@ -22,5 +22,11 @@ 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>;
+    getMCPServerPath(): string;
+    getMCPServerUrl(): string;
+    shouldUseRemoteMCP(): boolean;
 }
 export {};

package/dist/utils/config.js

@@ -1,7 +1,10 @@
-import fs from 'fs/promises';
-import path from 'path';
-import os from 'os';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
 import { jwtDecode } from 'jwt-decode';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 export class CLIConfig {
     configDir;
     configPath;
@@ -15,7 +18,7 @@ export class CLIConfig {
             await fs.mkdir(this.configDir, { recursive: true });
             await this.load();
         }
-        catch (error) {
+        catch {
             // Config doesn't exist yet, that's ok
         }
     }
@@ -24,7 +27,7 @@ export class CLIConfig {
             const data = await fs.readFile(this.configPath, 'utf-8');
             this.config = JSON.parse(data);
         }
-        catch (error) {
+        catch {
             this.config = {};
         }
     }
@@ -50,13 +53,13 @@ export class CLIConfig {
             // We'll need to fetch full user details from the API
             // For now, store what we can decode
             this.config.user = {
-                email: decoded.email || '',
-                organization_id: decoded.organizationId || '',
-                role: decoded.role || '',
-                plan: decoded.plan || ''
+                email: String(decoded.email || ''),
+                organization_id: String(decoded.organizationId || ''),
+                role: String(decoded.role || ''),
+                plan: String(decoded.plan || '')
             };
         }
-        catch (error) {
+        catch {
             // Invalid token, don't store user info
         }
         await this.save();
@@ -74,9 +77,9 @@ export class CLIConfig {
         try {
             const decoded = jwtDecode(token);
             const now = Date.now() / 1000;
-            return decoded.exp > now;
+            return typeof decoded.exp === 'number' && decoded.exp > now;
         }
-        catch (error) {
+        catch {
             return false;
         }
     }
@@ -101,4 +104,35 @@ export class CLIConfig {
             return false;
         }
     }
+    // Generic get/set methods for MCP and other dynamic config
+    get(key) {
+        return this.config[key];
+    }
+    set(key, value) {
+        this.config[key] = value;
+    }
+    async setAndSave(key, value) {
+        this.set(key, value);
+        await this.save();
+    }
+    // MCP-specific helpers
+    getMCPServerPath() {
+        return this.config.mcpServerPath || path.join(__dirname, '../../../../onasis-gateway/mcp-server/server.js');
+    }
+    getMCPServerUrl() {
+        return this.config.mcpServerUrl || 'https://api.lanonasis.com';
+    }
+    shouldUseRemoteMCP() {
+        const preference = this.config.mcpPreference || 'auto';
+        switch (preference) {
+            case 'remote':
+                return true;
+            case 'local':
+                return false;
+            case 'auto':
+            default:
+                // Use remote if authenticated, otherwise local
+                return !!this.config.token;
+        }
+    }
 }

package/dist/utils/formatting.d.ts

@@ -1,4 +1,4 @@
-export declare function formatOutput(data: any, format?: string): void;
+export declare function formatOutput(data: unknown, format?: string): void;
 export declare function formatBytes(bytes: number): string;
 export declare function truncateText(text: string, maxLength: number): string;
 export declare function formatDuration(ms: number): string;

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

@@ -0,0 +1,53 @@
+interface MCPConnectionOptions {
+    serverPath?: string;
+    serverUrl?: string;
+    useRemote?: boolean;
+}
+export declare class MCPClient {
+    private client;
+    private config;
+    private isConnected;
+    private sseConnection;
+    constructor();
+    /**
+     * Connect to MCP server (local or remote)
+     */
+    connect(options?: MCPConnectionOptions): Promise<boolean>;
+    /**
+     * Initialize SSE connection for real-time updates
+     */
+    private initializeSSE;
+    /**
+     * Disconnect from MCP server
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Call an MCP tool
+     */
+    callTool(toolName: string, args: any): Promise<any>;
+    /**
+     * Call remote tool via REST API with MCP interface
+     */
+    private callRemoteTool;
+    /**
+     * List available tools
+     */
+    listTools(): Promise<Array<{
+        name: string;
+        description: string;
+    }>>;
+    /**
+     * Check if connected to MCP server
+     */
+    isConnectedToServer(): boolean;
+    /**
+     * Get connection status details
+     */
+    getConnectionStatus(): {
+        connected: boolean;
+        mode: string;
+        server?: string;
+    };
+}
+export declare function getMCPClient(): MCPClient;
+export {};

package/dist/utils/mcp-client.js

@@ -0,0 +1,249 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import chalk from 'chalk';
+import { CLIConfig } from './config.js';
+import * as path from 'path';
+import { EventSource } from 'eventsource';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class MCPClient {
+    client = null;
+    config;
+    isConnected = false;
+    sseConnection = null;
+    constructor() {
+        this.config = new CLIConfig();
+    }
+    /**
+     * Connect to MCP server (local or remote)
+     */
+    async connect(options = {}) {
+        try {
+            const useRemote = options.useRemote ?? this.config.get('mcpUseRemote') ?? false;
+            if (useRemote) {
+                // For remote MCP, we'll use the REST API with MCP-style interface
+                const serverUrl = options.serverUrl ?? this.config.get('mcpServerUrl') ?? 'https://api.lanonasis.com';
+                console.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;
+            }
+            else {
+                // Local MCP server connection
+                const 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 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;
+                console.log(chalk.green('✓ Connected to MCP server'));
+                return true;
+            }
+        }
+        catch (error) {
+            console.error(chalk.red('Failed to connect to MCP server:'), error);
+            this.isConnected = false;
+            return false;
+        }
+    }
+    /**
+     * Initialize SSE connection for real-time updates
+     */
+    async initializeSSE(serverUrl) {
+        const sseUrl = `${serverUrl}/sse`;
+        const token = this.config.get('token');
+        if (token) {
+            // EventSource doesn't support headers directly, append token to URL
+            this.sseConnection = new EventSource(`${sseUrl}?token=${encodeURIComponent(token)}`);
+            this.sseConnection.onmessage = (event) => {
+                try {
+                    const data = JSON.parse(event.data);
+                    console.log(chalk.blue('📡 Real-time update:'), data.type);
+                }
+                catch (error) {
+                    // Ignore parse errors
+                }
+            };
+            this.sseConnection.onerror = (error) => {
+                console.error(chalk.yellow('⚠️  SSE connection error (will retry)'));
+            };
+        }
+    }
+    /**
+     * Disconnect from MCP server
+     */
+    async disconnect() {
+        if (this.client) {
+            await this.client.close();
+            this.client = null;
+        }
+        if (this.sseConnection) {
+            this.sseConnection.close();
+            this.sseConnection = null;
+        }
+        this.isConnected = false;
+    }
+    /**
+     * Call an MCP tool
+     */
+    async callTool(toolName, args) {
+        if (!this.isConnected) {
+            throw new Error('Not connected to MCP server. Run "lanonasis mcp connect" first.');
+        }
+        const useRemote = this.config.get('mcpUseRemote') ?? false;
+        if (useRemote) {
+            // Remote MCP calls are translated to REST API calls
+            return await this.callRemoteTool(toolName, args);
+        }
+        else {
+            // Local MCP server call
+            if (!this.client) {
+                throw new Error('MCP client not initialized');
+            }
+            try {
+                const result = await this.client.callTool({
+                    name: toolName,
+                    arguments: args
+                });
+                return result;
+            }
+            catch (error) {
+                throw new Error(`MCP tool call failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }
+    }
+    /**
+     * Call remote tool via REST API with MCP interface
+     */
+    async callRemoteTool(toolName, args) {
+        const apiUrl = this.config.get('apiUrl') ?? 'https://api.lanonasis.com';
+        const token = this.config.get('token');
+        if (!token) {
+            throw new Error('Authentication required. Run "lanonasis auth login" first.');
+        }
+        // Map MCP tool names to REST API endpoints
+        const toolMappings = {
+            'memory_create_memory': {
+                method: 'POST',
+                endpoint: '/api/v1/memory',
+                transform: (args) => args
+            },
+            'memory_search_memories': {
+                method: 'POST',
+                endpoint: '/api/v1/memory/search',
+                transform: (args) => args
+            },
+            'memory_get_memory': {
+                method: 'GET',
+                endpoint: `/api/v1/memory/${args.memory_id}`,
+                transform: () => undefined
+            },
+            'memory_update_memory': {
+                method: 'PUT',
+                endpoint: `/api/v1/memory/${args.memory_id}`,
+                transform: (args) => {
+                    const { memory_id, ...data } = args;
+                    return data;
+                }
+            },
+            'memory_delete_memory': {
+                method: 'DELETE',
+                endpoint: `/api/v1/memory/${args.memory_id}`,
+                transform: () => undefined
+            },
+            'memory_list_memories': {
+                method: 'GET',
+                endpoint: '/api/v1/memory',
+                transform: (args) => args
+            }
+        };
+        const mapping = toolMappings[toolName];
+        if (!mapping) {
+            throw new Error(`Unknown tool: ${toolName}`);
+        }
+        try {
+            const axios = (await import('axios')).default;
+            const response = await axios({
+                method: mapping.method,
+                url: `${apiUrl}${mapping.endpoint}`,
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'Content-Type': 'application/json'
+                },
+                data: mapping.transform ? mapping.transform(args) : undefined,
+                params: mapping.method === 'GET' ? args : undefined
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw new Error(`Remote tool call failed: ${error.response?.data?.error || error.message}`);
+        }
+    }
+    /**
+     * List available tools
+     */
+    async listTools() {
+        if (!this.isConnected) {
+            throw new Error('Not connected to MCP server');
+        }
+        const useRemote = this.config.get('mcpUseRemote') ?? false;
+        if (useRemote) {
+            // Return hardcoded list for remote mode
+            return [
+                { name: 'memory_create_memory', description: 'Create a new memory entry' },
+                { name: 'memory_search_memories', description: 'Search memories using semantic search' },
+                { name: 'memory_get_memory', description: 'Get a specific memory by ID' },
+                { name: 'memory_update_memory', description: 'Update an existing memory' },
+                { name: 'memory_delete_memory', description: 'Delete a memory' },
+                { name: 'memory_list_memories', description: 'List all memories with pagination' }
+            ];
+        }
+        else {
+            if (!this.client) {
+                throw new Error('MCP client not initialized');
+            }
+            const tools = await this.client.listTools();
+            return tools.tools.map(tool => ({
+                name: tool.name,
+                description: tool.description || 'No description available'
+            }));
+        }
+    }
+    /**
+     * Check if connected to MCP server
+     */
+    isConnectedToServer() {
+        return this.isConnected;
+    }
+    /**
+     * Get connection status details
+     */
+    getConnectionStatus() {
+        const useRemote = this.config.get('mcpUseRemote') ?? false;
+        return {
+            connected: this.isConnected,
+            mode: useRemote ? 'remote' : 'local',
+            server: useRemote
+                ? (this.config.get('mcpServerUrl') ?? 'https://api.lanonasis.com')
+                : (this.config.get('mcpServerPath') ?? 'local MCP server')
+        };
+    }
+}
+// Singleton instance
+let mcpClientInstance = null;
+export function getMCPClient() {
+    if (!mcpClientInstance) {
+        mcpClientInstance = new MCPClient();
+    }
+    return mcpClientInstance;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lanonasis/cli",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "Lanonasis Enterprise CLI - Memory as a Service and Infrastructure Management",
   "main": "dist/index-simple.js",
   "bin": {
@@ -34,11 +34,24 @@
     "README.md"
   ],
   "dependencies": {
-    "commander": "^12.1.0"
+    "@modelcontextprotocol/sdk": "^1.17.0",
+    "@types/eventsource": "^1.1.15",
+    "axios": "^1.11.0",
+    "chalk": "^5.4.1",
+    "commander": "^12.1.0",
+    "date-fns": "^4.1.0",
+    "dotenv": "^17.2.1",
+    "eventsource": "^4.0.0",
+    "inquirer": "^12.9.0",
+    "jwt-decode": "^4.0.0",
+    "open": "^10.2.0",
+    "ora": "^8.2.0",
+    "table": "^6.9.0",
+    "word-wrap": "^1.2.5"
   },
   "devDependencies": {
-    "@types/node": "^22.10.2",
     "@types/inquirer": "^9.0.7",
+    "@types/node": "^22.10.2",
     "@typescript-eslint/eslint-plugin": "^8.18.1",
     "@typescript-eslint/parser": "^8.18.1",
     "eslint": "^9.17.0",
@@ -48,4 +61,4 @@
   "engines": {
     "node": ">=18.0.0"
   }
-}
+}