@lanonasis/cli 1.5.0 → 1.5.1

package/dist/mcp-server.js

@@ -0,0 +1,519 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { CLIConfig } from './utils/config.js';
+// MCP Protocol Compliance: Redirect all console output to stderr
+// This prevents stdout pollution which breaks JSON-RPC communication
+const originalConsoleError = console.error;
+// Silent mode for MCP protocol compliance
+const isSilentMode = process.env.LANONASIS_SILENT === 'true' || process.argv.includes('--silent');
+if (isSilentMode) {
+    // Completely silence all output except JSON-RPC
+    console.log = () => { };
+    console.error = () => { };
+    console.warn = () => { };
+    console.info = () => { };
+    console.debug = () => { };
+}
+else {
+    // Redirect to stderr for debugging
+    console.log = (...args) => originalConsoleError('[MCP-LOG]', ...args);
+    console.error = (...args) => originalConsoleError('[MCP-ERROR]', ...args);
+    console.warn = (...args) => originalConsoleError('[MCP-WARN]', ...args);
+    console.info = (...args) => originalConsoleError('[MCP-INFO]', ...args);
+}
+// Disable colors and verbose output for MCP protocol compliance
+process.env.FORCE_COLOR = '0';
+process.env.DEBUG = '';
+process.env.NODE_ENV = process.env.NODE_ENV || 'production';
+class LanonasisMCPServer {
+    server;
+    config;
+    constructor() {
+        this.config = new CLIConfig();
+        this.server = new Server({
+            name: 'lanonasis-mcp-server',
+            version: '1.3.0',
+        }, {
+            capabilities: {
+                tools: {},
+                resources: {},
+            },
+        });
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        // List available tools - Comprehensive MCP toolset matching legacy CLI
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: [
+                    // Memory Management Tools
+                    {
+                        name: 'create_memory',
+                        description: 'Create a new memory entry with vector embedding',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                title: { type: 'string', description: 'Memory title' },
+                                content: { type: 'string', description: 'Memory content' },
+                                memory_type: { type: 'string', description: 'Type of memory', enum: ['context', 'project', 'knowledge', 'reference', 'personal', 'workflow'] },
+                                tags: { type: 'array', items: { type: 'string' }, description: 'Memory tags' },
+                                topic_id: { type: 'string', description: 'Topic ID for organization' }
+                            },
+                            required: ['title', 'content']
+                        }
+                    },
+                    {
+                        name: 'search_memories',
+                        description: 'Search through memories with semantic vector search',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                query: { type: 'string', description: 'Search query' },
+                                memory_type: { type: 'string', description: 'Filter by memory type' },
+                                limit: { type: 'number', description: 'Maximum results to return', default: 10 },
+                                threshold: { type: 'number', description: 'Similarity threshold (0.0-1.0)', default: 0.7 },
+                                tags: { type: 'array', items: { type: 'string' }, description: 'Filter by tags' }
+                            },
+                            required: ['query']
+                        }
+                    },
+                    {
+                        name: 'get_memory',
+                        description: 'Get a specific memory by ID',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                id: { type: 'string', description: 'Memory ID' }
+                            },
+                            required: ['id']
+                        }
+                    },
+                    {
+                        name: 'update_memory',
+                        description: 'Update an existing memory',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                id: { type: 'string', description: 'Memory ID' },
+                                title: { type: 'string', description: 'Memory title' },
+                                content: { type: 'string', description: 'Memory content' },
+                                memory_type: { type: 'string', description: 'Type of memory' },
+                                tags: { type: 'array', items: { type: 'string' }, description: 'Memory tags' }
+                            },
+                            required: ['id']
+                        }
+                    },
+                    {
+                        name: 'delete_memory',
+                        description: 'Delete a memory by ID',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                id: { type: 'string', description: 'Memory ID' }
+                            },
+                            required: ['id']
+                        }
+                    },
+                    {
+                        name: 'list_memories',
+                        description: 'List memories with pagination and filters',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                limit: { type: 'number', description: 'Number of memories to return', default: 20 },
+                                offset: { type: 'number', description: 'Offset for pagination', default: 0 },
+                                memory_type: { type: 'string', description: 'Filter by memory type' },
+                                tags: { type: 'array', items: { type: 'string' }, description: 'Filter by tags' }
+                            }
+                        }
+                    },
+                    // API Key Management Tools
+                    {
+                        name: 'create_api_key',
+                        description: 'Create a new API key',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                name: { type: 'string', description: 'API key name' },
+                                description: { type: 'string', description: 'API key description' },
+                                project_id: { type: 'string', description: 'Project ID' },
+                                access_level: { type: 'string', description: 'Access level', enum: ['public', 'authenticated', 'team', 'admin', 'enterprise'] },
+                                expires_in_days: { type: 'number', description: 'Expiration in days', default: 365 }
+                            },
+                            required: ['name']
+                        }
+                    },
+                    {
+                        name: 'list_api_keys',
+                        description: 'List API keys',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                project_id: { type: 'string', description: 'Filter by project ID' },
+                                active_only: { type: 'boolean', description: 'Show only active keys', default: true }
+                            }
+                        }
+                    },
+                    {
+                        name: 'rotate_api_key',
+                        description: 'Rotate an API key',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                key_id: { type: 'string', description: 'API key ID to rotate' }
+                            },
+                            required: ['key_id']
+                        }
+                    },
+                    {
+                        name: 'delete_api_key',
+                        description: 'Delete an API key',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                key_id: { type: 'string', description: 'API key ID to delete' }
+                            },
+                            required: ['key_id']
+                        }
+                    },
+                    // Project Management Tools
+                    {
+                        name: 'create_project',
+                        description: 'Create a new project',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                name: { type: 'string', description: 'Project name' },
+                                description: { type: 'string', description: 'Project description' },
+                                organization_id: { type: 'string', description: 'Organization ID' }
+                            },
+                            required: ['name']
+                        }
+                    },
+                    {
+                        name: 'list_projects',
+                        description: 'List projects',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                organization_id: { type: 'string', description: 'Filter by organization ID' }
+                            }
+                        }
+                    },
+                    // Organization Management Tools
+                    {
+                        name: 'get_organization_info',
+                        description: 'Get organization information',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {}
+                        }
+                    },
+                    // Authentication Tools
+                    {
+                        name: 'get_auth_status',
+                        description: 'Get authentication status',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {}
+                        }
+                    },
+                    // Configuration Tools
+                    {
+                        name: 'get_config',
+                        description: 'Get configuration settings',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                key: { type: 'string', description: 'Specific config key to retrieve' }
+                            }
+                        }
+                    },
+                    {
+                        name: 'set_config',
+                        description: 'Set configuration setting',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                key: { type: 'string', description: 'Configuration key' },
+                                value: { type: 'string', description: 'Configuration value' }
+                            },
+                            required: ['key', 'value']
+                        }
+                    },
+                    // Health and Status Tools
+                    {
+                        name: 'get_health_status',
+                        description: 'Get system health status',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {}
+                        }
+                    }
+                ]
+            };
+        });
+        // Handle tool calls - Comprehensive implementation
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                const apiKey = process.env.LANONASIS_API_KEY;
+                const apiUrl = process.env.LANONASIS_API_URL || 'https://dashboard.lanonasis.com';
+                if (!apiKey) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'Error: LANONASIS_API_KEY environment variable is required'
+                            }
+                        ]
+                    };
+                }
+                const headers = {
+                    'Authorization': `Bearer ${apiKey}`,
+                    'Content-Type': 'application/json',
+                    'User-Agent': 'lanonasis-mcp-server/1.3.0'
+                };
+                switch (name) {
+                    // Memory Management Tools
+                    case 'create_memory': {
+                        const response = await fetch(`${apiUrl}/api/v1/memory`, {
+                            method: 'POST',
+                            headers,
+                            body: JSON.stringify(args)
+                        });
+                        if (!response.ok) {
+                            const errorText = await response.text();
+                            throw new Error(`Memory creation failed: ${response.status} ${response.statusText} - ${errorText}`);
+                        }
+                        const result = await response.json();
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `✅ Memory created successfully:\n${JSON.stringify(result, null, 2)}`
+                                }
+                            ]
+                        };
+                    }
+                    case 'search_memories': {
+                        const queryParams = new URLSearchParams();
+                        if (args.query)
+                            queryParams.append('query', String(args.query));
+                        if (args.memory_type)
+                            queryParams.append('memory_type', String(args.memory_type));
+                        if (args.limit)
+                            queryParams.append('limit', args.limit.toString());
+                        if (args.threshold)
+                            queryParams.append('threshold', args.threshold.toString());
+                        if (args.tags && Array.isArray(args.tags)) {
+                            args.tags.forEach((tag) => queryParams.append('tags', String(tag)));
+                        }
+                        const response = await fetch(`${apiUrl}/api/v1/memory/search?${queryParams}`, {
+                            method: 'GET',
+                            headers
+                        });
+                        if (!response.ok) {
+                            const errorText = await response.text();
+                            throw new Error(`Memory search failed: ${response.status} ${response.statusText} - ${errorText}`);
+                        }
+                        const result = await response.json();
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `🔍 Search results (${result.length || 0} found):\n${JSON.stringify(result, null, 2)}`
+                                }
+                            ]
+                        };
+                    }
+                    case 'get_memory': {
+                        const response = await fetch(`${apiUrl}/api/v1/memory/${args.id}`, {
+                            method: 'GET',
+                            headers
+                        });
+                        if (!response.ok) {
+                            const errorText = await response.text();
+                            throw new Error(`Memory retrieval failed: ${response.status} ${response.statusText} - ${errorText}`);
+                        }
+                        const result = await response.json();
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `📄 Memory details:\n${JSON.stringify(result, null, 2)}`
+                                }
+                            ]
+                        };
+                    }
+                    case 'update_memory': {
+                        const { id, ...updateData } = args;
+                        const response = await fetch(`${apiUrl}/api/v1/memory/${id}`, {
+                            method: 'PUT',
+                            headers,
+                            body: JSON.stringify(updateData)
+                        });
+                        if (!response.ok) {
+                            const errorText = await response.text();
+                            throw new Error(`Memory update failed: ${response.status} ${response.statusText} - ${errorText}`);
+                        }
+                        const result = await response.json();
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `✏️ Memory updated successfully:\n${JSON.stringify(result, null, 2)}`
+                                }
+                            ]
+                        };
+                    }
+                    case 'delete_memory': {
+                        const response = await fetch(`${apiUrl}/api/v1/memory/${args.id}`, {
+                            method: 'DELETE',
+                            headers
+                        });
+                        if (!response.ok) {
+                            const errorText = await response.text();
+                            throw new Error(`Memory deletion failed: ${response.status} ${response.statusText} - ${errorText}`);
+                        }
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `🗑️ Memory deleted successfully (ID: ${args.id})`
+                                }
+                            ]
+                        };
+                    }
+                    case 'list_memories': {
+                        const queryParams = new URLSearchParams();
+                        if (args.limit)
+                            queryParams.append('limit', args.limit.toString());
+                        if (args.offset)
+                            queryParams.append('offset', args.offset.toString());
+                        if (args.memory_type)
+                            queryParams.append('memory_type', String(args.memory_type));
+                        if (args.tags && Array.isArray(args.tags)) {
+                            args.tags.forEach((tag) => queryParams.append('tags', String(tag)));
+                        }
+                        const response = await fetch(`${apiUrl}/api/v1/memory?${queryParams}`, {
+                            method: 'GET',
+                            headers
+                        });
+                        if (!response.ok) {
+                            const errorText = await response.text();
+                            throw new Error(`Memory listing failed: ${response.status} ${response.statusText} - ${errorText}`);
+                        }
+                        const result = await response.json();
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `📋 Memory list (${result.length || 0} items):\n${JSON.stringify(result, null, 2)}`
+                                }
+                            ]
+                        };
+                    }
+                    // API Key Management Tools
+                    case 'create_api_key': {
+                        const response = await fetch(`${apiUrl}/api/v1/api-keys`, {
+                            method: 'POST',
+                            headers,
+                            body: JSON.stringify(args)
+                        });
+                        if (!response.ok) {
+                            const errorText = await response.text();
+                            throw new Error(`API key creation failed: ${response.status} ${response.statusText} - ${errorText}`);
+                        }
+                        const result = await response.json();
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `🔑 API key created successfully:\n${JSON.stringify(result, null, 2)}`
+                                }
+                            ]
+                        };
+                    }
+                    case 'list_api_keys': {
+                        const queryParams = new URLSearchParams();
+                        if (args.project_id)
+                            queryParams.append('project_id', String(args.project_id));
+                        if (args.active_only !== undefined)
+                            queryParams.append('active_only', args.active_only.toString());
+                        const response = await fetch(`${apiUrl}/api/v1/api-keys?${queryParams}`, {
+                            method: 'GET',
+                            headers
+                        });
+                        if (!response.ok) {
+                            const errorText = await response.text();
+                            throw new Error(`API key listing failed: ${response.status} ${response.statusText} - ${errorText}`);
+                        }
+                        const result = await response.json();
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `🔑 API keys (${result.length || 0} found):\n${JSON.stringify(result, null, 2)}`
+                                }
+                            ]
+                        };
+                    }
+                    case 'get_health_status': {
+                        const response = await fetch(`${apiUrl}/api/v1/health`, {
+                            method: 'GET',
+                            headers
+                        });
+                        if (!response.ok) {
+                            const errorText = await response.text();
+                            throw new Error(`Health check failed: ${response.status} ${response.statusText} - ${errorText}`);
+                        }
+                        const result = await response.json();
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `💚 System health status:\n${JSON.stringify(result, null, 2)}`
+                                }
+                            ]
+                        };
+                    }
+                    default:
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `❌ Unknown tool: ${name}. Available tools: create_memory, search_memories, get_memory, update_memory, delete_memory, list_memories, create_api_key, list_api_keys, get_health_status`
+                                }
+                            ]
+                        };
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ Error: ${errorMessage}`
+                        }
+                    ]
+                };
+            }
+        });
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        // Log to stderr that server is ready
+        console.error('[MCP-INFO] Lanonasis MCP Server started and ready');
+    }
+}
+// Start the server
+const server = new LanonasisMCPServer();
+server.run().catch((error) => {
+    console.error('[MCP-ERROR] Failed to start server:', error);
+    process.exit(1);
+});

package/dist/utils/api.d.ts

@@ -57,7 +57,7 @@ export interface GetMemoriesParams {
     limit?: number;
     offset?: number;
     memory_type?: MemoryType;
-    tags?: string[];
+    tags?: string[] | string;
     topic_id?: string;
     sort_by?: 'created_at' | 'updated_at' | 'last_accessed' | 'access_count';
     sort_order?: 'asc' | 'desc';
@@ -125,13 +125,19 @@ export interface HealthStatus {
     }>;
 }
 export interface PaginatedResponse<T> {
-    data: T[];
+    data?: T[];
+    memories?: T[];
+    results?: T[];
     pagination: {
         total: number;
         limit: number;
         offset: number;
         has_more: boolean;
+        page?: number;
+        pages?: number;
     };
+    total_results?: number;
+    search_time_ms?: number;
 }
 export interface ApiErrorResponse {
     error: string;
@@ -159,6 +165,10 @@ export declare class APIClient {
     updateTopic(id: string, data: UpdateTopicRequest): Promise<MemoryTopic>;
     deleteTopic(id: string): Promise<void>;
     getHealth(): Promise<HealthStatus>;
+    get<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    put<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    delete<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
     request<T = Record<string, unknown>>(config: AxiosRequestConfig): Promise<T>;
 }
 export declare const apiClient: APIClient;

package/dist/utils/api.js

@@ -132,6 +132,23 @@ export class APIClient {
         const response = await this.client.get('/api/v1/health');
         return response.data;
     }
+    // Generic HTTP methods
+    async get(url, config) {
+        const response = await this.client.get(url, config);
+        return response.data;
+    }
+    async post(url, data, config) {
+        const response = await this.client.post(url, data, config);
+        return response.data;
+    }
+    async put(url, data, config) {
+        const response = await this.client.put(url, data, config);
+        return response.data;
+    }
+    async delete(url, config) {
+        const response = await this.client.delete(url, config);
+        return response.data;
+    }
     // Generic request method
     async request(config) {
         const response = await this.client.request(config);

package/dist/utils/config.d.ts

@@ -16,8 +16,6 @@ export declare class CLIConfig {
     setApiUrl(url: string): Promise<void>;
     setToken(token: string): Promise<void>;
     getToken(): string | undefined;
-    setApiKey(apiKey: string): Promise<void>;
-    getApiKey(): string | undefined;
     getCurrentUser(): Promise<UserProfile | undefined>;
     isAuthenticated(): Promise<boolean>;
     logout(): Promise<void>;

package/dist/utils/config.js

@@ -39,7 +39,7 @@ export class CLIConfig {
     getApiUrl() {
         return process.env.MEMORY_API_URL ||
             this.config.apiUrl ||
-            'http://localhost:3000/api/v1';
+            'https://api.lanonasis.com';
     }
     async setApiUrl(url) {
         this.config.apiUrl = url;
@@ -67,22 +67,10 @@ export class CLIConfig {
     getToken() {
         return this.config.token;
     }
-    async setApiKey(apiKey) {
-        this.config.apiKey = apiKey;
-        await this.save();
-    }
-    getApiKey() {
-        return this.config.apiKey || process.env.LANONASIS_API_KEY;
-    }
     async getCurrentUser() {
         return this.config.user;
     }
     async isAuthenticated() {
-        // Check for API key first
-        const apiKey = this.getApiKey();
-        if (apiKey)
-            return true;
-        // Then check for valid JWT token
         const token = this.getToken();
         if (!token)
             return false;
@@ -97,7 +85,6 @@ export class CLIConfig {
     }
     async logout() {
         this.config.token = undefined;
-        this.config.apiKey = undefined;
         this.config.user = undefined;
         await this.save();
     }
@@ -133,7 +120,7 @@ export class CLIConfig {
         return this.config.mcpServerPath || path.join(__dirname, '../../../../onasis-gateway/mcp-server/server.js');
     }
     getMCPServerUrl() {
-        return this.config.mcpServerUrl || 'https://api.lanonasis.com';
+        return this.config.mcpServerUrl || 'https://dashboard.lanonasis.com';
     }
     shouldUseRemoteMCP() {
         const preference = this.config.mcpPreference || 'auto';

package/dist/utils/formatting.d.ts

@@ -2,3 +2,5 @@ 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;
+export declare function formatDate(date: string | Date): string;
+export declare function formatTableData(data: unknown[]): string[][];

package/dist/utils/formatting.js

@@ -32,3 +32,16 @@ export function formatDuration(ms) {
         return `${(ms / 1000).toFixed(1)}s`;
     return `${(ms / 60000).toFixed(1)}m`;
 }
+export function formatDate(date) {
+    const d = new Date(date);
+    return d.toLocaleString();
+}
+export function formatTableData(data) {
+    return data.map(item => {
+        if (Array.isArray(item))
+            return item.map(String);
+        if (typeof item === 'object' && item !== null)
+            return Object.values(item).map(String);
+        return [String(item)];
+    });
+}