@lanonasis/cli 1.5.0 → 1.5.2

package/dist/mcp-server.d.ts

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+/**
+ * CLI-Embedded MCP Server
+ * Uses the same configuration and authentication as @lanonasis/cli v1.5.2+
+ * Can run standalone or be invoked by CLI commands
+ */
+interface MCPServerOptions {
+    mode?: 'stdio' | 'http';
+    port?: number;
+    verbose?: boolean;
+    useRemote?: boolean;
+}
+export declare class CLIMCPServer {
+    private config;
+    constructor();
+    /**
+     * Start MCP server using CLI configuration
+     */
+    start(options?: MCPServerOptions): Promise<void>;
+    /**
+     * Start local MCP server using CLI auth config
+     */
+    private startLocalMCP;
+    /**
+     * Connect to remote MCP server
+     */
+    private startRemoteMCP;
+    /**
+     * Check if MCP server is available and configured
+     */
+    checkStatus(): Promise<{
+        available: boolean;
+        configured: boolean;
+        authMethod: string;
+        mode: 'local' | 'remote' | 'auto';
+    }>;
+}
+export default CLIMCPServer;

package/dist/mcp-server.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+/**
+ * CLI-Embedded MCP Server
+ * Uses the same configuration and authentication as @lanonasis/cli v1.5.2+
+ * Can run standalone or be invoked by CLI commands
+ */
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { spawn } from 'child_process';
+import { CLIConfig } from './utils/config.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export class CLIMCPServer {
+    config;
+    constructor() {
+        this.config = new CLIConfig();
+    }
+    /**
+     * Start MCP server using CLI configuration
+     */
+    async start(options = {}) {
+        await this.config.init();
+        const { mode = 'stdio', port = 3001, verbose = false, useRemote = this.config.shouldUseRemoteMCP() } = options;
+        if (useRemote) {
+            await this.startRemoteMCP(options);
+        }
+        else {
+            await this.startLocalMCP(options);
+        }
+    }
+    /**
+     * Start local MCP server using CLI auth config
+     */
+    async startLocalMCP(options) {
+        const { mode, port, verbose } = options;
+        // Path to CLI-aligned MCP server in submodule
+        const mcpServerPath = join(__dirname, '../../../mcp-server/dist/cli-aligned-mcp-server.js');
+        const args = mode === 'http' ? ['--http'] : ['--stdio'];
+        if (verbose) {
+            console.error('🚀 Starting CLI-aligned MCP Server...');
+            console.error(`Mode: ${mode}`);
+            console.error(`Config: ~/.maas/config.json`);
+            console.error(`Auth: ${this.config.hasVendorKey() ? 'Vendor Key' : 'JWT Token'}`);
+        }
+        // Set environment variables from CLI config
+        const env = {
+            ...process.env,
+            PORT: port?.toString(),
+            MEMORY_API_URL: this.config.getApiUrl(),
+            LANONASIS_VENDOR_KEY: this.config.getVendorKey(),
+            LANONASIS_TOKEN: this.config.getToken(),
+            MCP_VERBOSE: verbose ? 'true' : 'false',
+            CLI_ALIGNED: 'true'
+        };
+        const child = spawn('node', [mcpServerPath, ...args], {
+            env,
+            stdio: mode === 'stdio' ? ['pipe', 'pipe', 'inherit'] : 'inherit'
+        });
+        if (mode === 'stdio') {
+            // For stdio mode, pipe stdin/stdout for MCP protocol
+            process.stdin.pipe(child.stdin);
+            child.stdout.pipe(process.stdout);
+        }
+        child.on('error', (error) => {
+            console.error('❌ MCP Server failed to start:', error.message);
+            process.exit(1);
+        });
+        child.on('exit', (code) => {
+            if (code !== 0) {
+                console.error(`❌ MCP Server exited with code ${code}`);
+                process.exit(code || 1);
+            }
+        });
+        // Handle graceful shutdown
+        process.on('SIGINT', () => {
+            child.kill('SIGINT');
+        });
+        process.on('SIGTERM', () => {
+            child.kill('SIGTERM');
+        });
+    }
+    /**
+     * Connect to remote MCP server
+     */
+    async startRemoteMCP(options) {
+        const { verbose } = options;
+        if (verbose) {
+            console.error('🌐 Connecting to remote MCP server...');
+            console.error(`URL: ${this.config.getMCPServerUrl()}`);
+        }
+        // For remote MCP, we'd need to implement a proxy or client
+        // For now, fall back to local mode
+        console.error('⚠️  Remote MCP not yet implemented, falling back to local mode');
+        await this.startLocalMCP({ ...options, useRemote: false });
+    }
+    /**
+     * Check if MCP server is available and configured
+     */
+    async checkStatus() {
+        await this.config.init();
+        return {
+            available: true, // CLI always has MCP server available
+            configured: this.config.hasVendorKey() || !!this.config.getToken(),
+            authMethod: this.config.hasVendorKey() ? 'vendor_key' :
+                this.config.getToken() ? 'jwt' : 'none',
+            mode: this.config.shouldUseRemoteMCP() ? 'remote' : 'local'
+        };
+    }
+}
+// Main execution when run as standalone script
+async function main() {
+    const args = process.argv.slice(2);
+    const server = new CLIMCPServer();
+    // Parse command line arguments
+    const options = {
+        mode: args.includes('--http') ? 'http' : 'stdio',
+        port: parseInt(args.find(arg => arg.startsWith('--port='))?.split('=')[1] || '3001'),
+        verbose: args.includes('--verbose') || args.includes('-v'),
+        useRemote: args.includes('--remote')
+    };
+    if (args.includes('--status')) {
+        const status = await server.checkStatus();
+        console.log(JSON.stringify(status, null, 2));
+        return;
+    }
+    if (args.includes('--help')) {
+        console.log(`
+CLI MCP Server - CLI-aligned Model Context Protocol server
+
+Usage:
+  lanonasis-mcp-server [options]
+
+Options:
+  --stdio          Use stdio transport (default)
+  --http           Use HTTP transport
+  --port=3001      HTTP port (default: 3001)
+  --remote         Use remote MCP server
+  --verbose, -v    Verbose logging
+  --status         Check server status
+  --help           Show this help
+
+Examples:
+  lanonasis-mcp-server                    # Start stdio server
+  lanonasis-mcp-server --http --port=3002 # Start HTTP server
+  lanonasis-mcp-server --status           # Check status
+`);
+        return;
+    }
+    await server.start(options);
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch(console.error);
+}
+export default CLIMCPServer;

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

@@ -1,5 +1,6 @@
 import axios from 'axios';
 import chalk from 'chalk';
+import { randomUUID } from 'crypto';
 import { CLIConfig } from './config.js';
 export class APIClient {
     client;
@@ -7,16 +8,32 @@ export class APIClient {
     constructor() {
         this.config = new CLIConfig();
         this.client = axios.create();
-        // Setup request interceptor to add auth token
+        // Setup request interceptor to add auth token and headers
         this.client.interceptors.request.use(async (config) => {
             await this.config.init();
+            // Service Discovery
+            await this.config.discoverServices();
+            config.baseURL = this.config.getDiscoveredApiUrl();
+            // Enhanced Authentication Support
             const token = this.config.getToken();
-            if (token) {
+            const vendorKey = this.config.getVendorKey();
+            if (vendorKey) {
+                // Vendor key authentication (pk_*.sk_* format)
+                config.headers['X-API-Key'] = vendorKey;
+                config.headers['X-Auth-Method'] = 'vendor_key';
+            }
+            else if (token) {
+                // JWT token authentication
                 config.headers.Authorization = `Bearer ${token}`;
+                config.headers['X-Auth-Method'] = 'jwt';
             }
-            config.baseURL = this.config.getApiUrl();
+            // Add request ID for correlation
+            const requestId = randomUUID();
+            config.headers['X-Request-ID'] = requestId;
+            // Add project scope for Golden Contract compliance
+            config.headers['X-Project-Scope'] = 'lanonasis-maas';
             if (process.env.CLI_VERBOSE === 'true') {
-                console.log(chalk.dim(`→ ${config.method?.toUpperCase()} ${config.url}`));
+                console.log(chalk.dim(`→ ${config.method?.toUpperCase()} ${config.url} [${requestId}]`));
             }
             return config;
         });
@@ -132,6 +149,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

@@ -13,11 +13,14 @@ export declare class CLIConfig {
     load(): Promise<void>;
     save(): Promise<void>;
     getApiUrl(): string;
+    discoverServices(): Promise<void>;
+    getDiscoveredApiUrl(): string;
+    setVendorKey(vendorKey: string): Promise<void>;
+    getVendorKey(): string | undefined;
+    hasVendorKey(): boolean;
     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,42 @@ export class CLIConfig {
     getApiUrl() {
         return process.env.MEMORY_API_URL ||
             this.config.apiUrl ||
-            'http://localhost:3000/api/v1';
+            'https://api.lanonasis.com/api/v1';
+    }
+    // Service Discovery Integration
+    async discoverServices() {
+        try {
+            // Use axios instead of fetch for consistency
+            const axios = (await import('axios')).default;
+            const discoveryUrl = 'https://api.lanonasis.com/.well-known/onasis.json';
+            const response = await axios.get(discoveryUrl);
+            this.config.discoveredServices = response.data;
+            await this.save();
+        }
+        catch (error) {
+            // Service discovery failed, use defaults
+            if (process.env.CLI_VERBOSE === 'true') {
+                console.log('Service discovery failed, using defaults');
+            }
+        }
+    }
+    getDiscoveredApiUrl() {
+        return this.config.discoveredServices?.auth_base || this.getApiUrl();
+    }
+    // Enhanced authentication support
+    async setVendorKey(vendorKey) {
+        // Validate vendor key format (pk_*.sk_*)
+        if (!vendorKey.match(/^pk_[a-zA-Z0-9]+\.sk_[a-zA-Z0-9]+$/)) {
+            throw new Error('Invalid vendor key format. Expected: pk_xxx.sk_xxx');
+        }
+        this.config.vendorKey = vendorKey;
+        await this.save();
+    }
+    getVendorKey() {
+        return this.config.vendorKey;
+    }
+    hasVendorKey() {
+        return !!this.config.vendorKey;
     }
     async setApiUrl(url) {
         this.config.apiUrl = url;
@@ -67,22 +102,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 +120,6 @@ export class CLIConfig {
     }
     async logout() {
         this.config.token = undefined;
-        this.config.apiKey = undefined;
         this.config.user = undefined;
         await this.save();
     }
@@ -133,7 +155,9 @@ 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.discoveredServices?.mcp_ws_base ||
+            this.config.mcpServerUrl ||
+            'https://api.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)];
+    });
+}

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

@@ -2,27 +2,70 @@ interface MCPConnectionOptions {
     serverPath?: string;
     serverUrl?: string;
     useRemote?: boolean;
-    mode?: 'local' | 'remote' | 'websocket';
+    useWebSocket?: boolean;
+    connectionMode?: 'local' | 'remote' | 'websocket';
+}
+/**
+ * Interface for MCP tool arguments
+ */
+interface MCPToolArgs {
+    [key: string]: unknown;
+}
+/**
+ * Interface for MCP tool response
+ */
+export interface MCPToolResponse {
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+    };
+    id?: string;
+    title?: string;
+    memory_type?: string;
+    length?: number;
+    forEach?: (callback: (item: any, index: number) => void) => void;
+    code?: number;
+    message?: string;
+    response?: any;
+}
+/**
+ * Interface for MCP WebSocket messages
+ */
+export interface MCPWebSocketMessage {
+    id: number;
+    method?: string;
+    params?: Record<string, unknown>;
+    result?: Record<string, unknown>;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
 }
 export declare class MCPClient {
     private client;
     private config;
     private isConnected;
     private sseConnection;
-    private wsClient;
+    private wsConnection;
     constructor();
     /**
      * Connect to MCP server (local or remote)
      */
     connect(options?: MCPConnectionOptions): Promise<boolean>;
     /**
-     * Initialize WebSocket MCP connection for enterprise users
+     * Initialize SSE connection for real-time updates
+     */
+    private initializeSSE;
+    /**
+     * Initialize WebSocket connection for enterprise MCP server
      */
     private initializeWebSocket;
     /**
-     * Initialize SSE connection for real-time updates
+     * Send a message over the WebSocket connection
      */
-    private initializeSSE;
+    private sendWebSocketMessage;
     /**
      * Disconnect from MCP server
      */
@@ -30,7 +73,7 @@ export declare class MCPClient {
     /**
      * Call an MCP tool
      */
-    callTool(toolName: string, args: any): Promise<any>;
+    callTool(toolName: string, args: MCPToolArgs): Promise<MCPToolResponse>;
     /**
      * Call remote tool via REST API with MCP interface
      */