@lanonasis/cli 3.7.3 → 3.7.5

package/README.md

@@ -26,9 +26,9 @@ lanonasis --version  # or onasis --version
 onasis guide
 
 # Quick manual setup
-onasis init                                    # Initialize configuration
-onasis login --vendor-key pk_xxx.sk_xxx      # Authenticate with vendor key
-onasis health                                 # Verify system health
+onasis init                                      # Initialize configuration
+onasis login --vendor-key <your-vendor-key>      # Authenticate with vendor key
+onasis health                                   # Verify system health
 
 # Create your first memory
 onasis memory create --title "Welcome" --content "My first memory"
@@ -85,10 +85,10 @@ onasis login --vendor-key pk_xxxxx.sk_xxxxx  // ✅ Automatically hashed
 
 ### 1. Vendor Key Authentication (Recommended)
 
-Best for API integrations and automation:
+Best for API integrations and automation. Copy the vendor key value exactly as shown in your LanOnasis dashboard (keys may vary in format):
 
 ```bash
-onasis login --vendor-key pk_xxxxx.sk_xxxxx
+onasis login --vendor-key <your-vendor-key>
 ```
 
 ### 2. OAuth Browser Authentication
@@ -288,7 +288,7 @@ Location: `~/.maas/config.json`
   "apiUrl": "https://api.lanonasis.com/api/v1",
   "defaultOutputFormat": "table",
   "mcpPreference": "auto",
-  "vendorKey": "pk_xxxxx.sk_xxxxx"
+  "vendorKey": "<your-vendor-key>"
 }
 ```
 
@@ -374,7 +374,7 @@ onasis auth status
 
 # Re-authenticate
 onasis auth logout
-onasis login --vendor-key pk_xxx.sk_xxx
+onasis login --vendor-key <your-vendor-key>
 ```
 
 #### Connection Issues

package/dist/mcp/access-control.js

@@ -64,8 +64,16 @@ export class MemoryAccessControl {
             // Get shared memories based on permissions
             const sharedMemories = await this.getSharedMemories(userId, appId);
             // Combine and deduplicate
-            const allMemories = [...new Set([...ownMemories, ...sharedMemories])];
-            return allMemories;
+            const combined = [...ownMemories, ...sharedMemories];
+            const deduped = [];
+            const seen = new Set();
+            combined.forEach(memoryId => {
+                if (!seen.has(memoryId)) {
+                    seen.add(memoryId);
+                    deduped.push(memoryId);
+                }
+            });
+            return deduped;
         }
         catch (error) {
             logger.error('Failed to get accessible memories', { error, userId, appId });

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

@@ -45,11 +45,11 @@ export class EnhancedMCPClient extends EventEmitter {
         }));
         await Promise.allSettled(connectionPromises);
         // Start health monitoring for connected servers
-        for (const [name, success] of results) {
+        results.forEach((success, name) => {
             if (success) {
                 this.startHealthMonitoring(name);
             }
-        }
+        });
         return results;
     }
     /**
@@ -327,12 +327,12 @@ export class EnhancedMCPClient extends EventEmitter {
      */
     async disconnectAll() {
         // Stop all health monitoring
-        for (const interval of this.healthCheckIntervals.values()) {
+        this.healthCheckIntervals.forEach(interval => {
             clearInterval(interval);
-        }
+        });
         this.healthCheckIntervals.clear();
         // Disconnect all clients
-        for (const [name, client] of this.clients) {
+        await Promise.all(Array.from(this.clients.entries()).map(async ([name, client]) => {
             try {
                 await client.close();
                 console.log(chalk.gray(`Disconnected from ${name}`));
@@ -340,7 +340,7 @@ export class EnhancedMCPClient extends EventEmitter {
             catch {
                 console.log(chalk.yellow(`Warning: Error disconnecting from ${name}`));
             }
-        }
+        }));
         this.clients.clear();
         this.transports.clear();
         this.connectionStatus.clear();

package/dist/mcp/schemas/tool-schemas.d.ts

@@ -202,13 +202,13 @@ export declare const SystemConfigSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     value?: any;
     action?: "get" | "set" | "reset";
-    key?: string;
     scope?: "user" | "global";
+    key?: string;
 }, {
     value?: any;
     action?: "get" | "set" | "reset";
-    key?: string;
     scope?: "user" | "global";
+    key?: string;
 }>;
 export declare const BulkOperationSchema: z.ZodObject<{
     operation: z.ZodEnum<["create", "update", "delete"]>;
@@ -580,13 +580,13 @@ export declare const MCPSchemas: {
         }, "strip", z.ZodTypeAny, {
             value?: any;
             action?: "get" | "set" | "reset";
-            key?: string;
             scope?: "user" | "global";
+            key?: string;
         }, {
             value?: any;
             action?: "get" | "set" | "reset";
-            key?: string;
             scope?: "user" | "global";
+            key?: string;
         }>;
     };
     operations: {

package/dist/mcp/server/lanonasis-server.js

@@ -916,7 +916,7 @@ Please choose an option (1-4):`
             connectionsByTransport: {}
         };
         const fiveMinutesAgo = Date.now() - (5 * 60 * 1000);
-        for (const connection of this.connectionPool.values()) {
+        this.connectionPool.forEach(connection => {
             // Count as active if there was activity in the last 5 minutes
             if (connection.lastActivity.getTime() > fiveMinutesAgo) {
                 stats.activeConnections++;
@@ -926,7 +926,7 @@ Please choose an option (1-4):`
             }
             stats.connectionsByTransport[connection.transport] =
                 (stats.connectionsByTransport[connection.transport] || 0) + 1;
-        }
+        });
         return stats;
     }
     /**
@@ -953,12 +953,13 @@ Please choose an option (1-4):`
     cleanupStaleConnections() {
         const tenMinutesAgo = Date.now() - (10 * 60 * 1000);
         const staleConnections = [];
-        for (const [clientId, connection] of this.connectionPool.entries()) {
+        this.connectionPool.forEach((connection, clientId) => {
             if (connection.lastActivity.getTime() < tenMinutesAgo) {
                 staleConnections.push(clientId);
             }
-        }
-        for (const clientId of staleConnections) {
+        });
+        for (let i = 0; i < staleConnections.length; i++) {
+            const clientId = staleConnections[i];
             this.removeConnection(clientId);
             if (this.options.verbose) {
                 console.log(chalk.yellow(`🧹 Cleaned up stale connection: ${clientId}`));
@@ -1385,12 +1386,12 @@ Please choose an option (1-4):`
      */
     getTransportStatus() {
         const failures = {};
-        for (const [transport, failure] of this.transportFailures.entries()) {
+        this.transportFailures.forEach((failure, transport) => {
             failures[transport] = {
                 count: failure.count,
                 lastFailure: failure.lastFailure.toISOString()
             };
-        }
+        });
         return {
             supportedTransports: this.supportedTransports,
             preferredTransport: this.options.preferredTransport || 'stdio',

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

@@ -411,9 +411,9 @@ export class MCPTransportManager {
      */
     getStatuses() {
         const statuses = {};
-        for (const [name, transport] of this.transports) {
+        this.transports.forEach((transport, name) => {
             statuses[name] = transport.isConnected();
-        }
+        });
         return statuses;
     }
     /**

package/dist/mcp-server.js

@@ -51,10 +51,14 @@ export class CLIMCPServer {
         }
         candidates.add(join(process.cwd(), 'mcp-server/dist/cli-aligned-mcp-server.js'));
         candidates.add(join(__dirname, '../../../mcp-server/dist/cli-aligned-mcp-server.js'));
-        for (const candidate of candidates) {
-            if (candidate && existsSync(candidate)) {
-                return candidate;
+        let resolvedPath = null;
+        candidates.forEach(candidate => {
+            if (!resolvedPath && candidate && existsSync(candidate)) {
+                resolvedPath = candidate;
             }
+        });
+        if (resolvedPath) {
+            return resolvedPath;
         }
         throw new Error('Unable to locate the CLI-aligned MCP server. Set MCP_SERVER_PATH or install @lanonasis/mcp-server.');
     }

package/dist/utils/api.js

@@ -2,7 +2,6 @@ import axios from 'axios';
 import chalk from 'chalk';
 import { randomUUID } from 'crypto';
 import { CLIConfig } from './config.js';
-import { ensureApiKeyHash } from './hash-utils.js';
 export class APIClient {
     client;
     config;
@@ -31,7 +30,8 @@ export class APIClient {
             const vendorKey = this.config.getVendorKey();
             if (vendorKey) {
                 // Vendor key authentication (validated server-side)
-                config.headers['X-API-Key'] = ensureApiKeyHash(vendorKey);
+                // Send raw key - server handles hashing for comparison
+                config.headers['X-API-Key'] = vendorKey;
                 config.headers['X-Auth-Method'] = 'vendor_key';
             }
             else if (token) {
@@ -100,61 +100,62 @@ export class APIClient {
         return response.data;
     }
     // Memory operations - aligned with existing schema
+    // All memory endpoints use /api/v1/memory path
     async createMemory(data) {
-        const response = await this.client.post('/memory', data);
+        const response = await this.client.post('/api/v1/memory', data);
         return response.data;
     }
     async getMemories(params = {}) {
-        const response = await this.client.get('/memory', { params });
+        const response = await this.client.get('/api/v1/memory', { params });
         return response.data;
     }
     async getMemory(id) {
-        const response = await this.client.get(`/memory/${id}`);
+        const response = await this.client.get(`/api/v1/memory/${id}`);
         return response.data;
     }
     async updateMemory(id, data) {
-        const response = await this.client.put(`/memory/${id}`, data);
+        const response = await this.client.put(`/api/v1/memory/${id}`, data);
         return response.data;
     }
     async deleteMemory(id) {
-        await this.client.delete(`/memory/${id}`);
+        await this.client.delete(`/api/v1/memory/${id}`);
     }
     async searchMemories(query, options = {}) {
-        const response = await this.client.post('/memory/search', {
+        const response = await this.client.post('/api/v1/memory/search', {
             query,
             ...options
         });
         return response.data;
     }
     async getMemoryStats() {
-        const response = await this.client.get('/memory/stats');
+        const response = await this.client.get('/api/v1/memory/stats');
         return response.data;
     }
     async bulkDeleteMemories(memoryIds) {
-        const response = await this.client.post('/memory/bulk/delete', {
+        const response = await this.client.post('/api/v1/memory/bulk/delete', {
             memory_ids: memoryIds
         });
         return response.data;
     }
     // Topic operations - working with existing memory_topics table
     async createTopic(data) {
-        const response = await this.client.post('/topics', data);
+        const response = await this.client.post('/api/v1/topics', data);
         return response.data;
     }
     async getTopics() {
-        const response = await this.client.get('/topics');
+        const response = await this.client.get('/api/v1/topics');
         return response.data;
     }
     async getTopic(id) {
-        const response = await this.client.get(`/topics/${id}`);
+        const response = await this.client.get(`/api/v1/topics/${id}`);
         return response.data;
     }
     async updateTopic(id, data) {
-        const response = await this.client.put(`/topics/${id}`, data);
+        const response = await this.client.put(`/api/v1/topics/${id}`, data);
         return response.data;
     }
     async deleteTopic(id) {
-        await this.client.delete(`/topics/${id}`);
+        await this.client.delete(`/api/v1/topics/${id}`);
     }
     // Health check
     async getHealth() {

package/dist/utils/config.d.ts

@@ -63,6 +63,7 @@ export declare class CLIConfig {
     getApiUrl(): string;
     getApiUrlsWithFallbacks(): string[];
     discoverServices(verbose?: boolean): Promise<void>;
+    private normalizeServiceError;
     private handleServiceDiscoveryFailure;
     private categorizeServiceDiscoveryError;
     private resolveFallbackEndpoints;

package/dist/utils/config.js

@@ -4,6 +4,7 @@ import * as os from 'os';
 import { jwtDecode } from 'jwt-decode';
 import { randomUUID } from 'crypto';
 import { ApiKeyStorage } from '@lanonasis/oauth-client';
+import axios from 'axios';
 export class CLIConfig {
     configDir;
     configPath;
@@ -167,9 +168,11 @@ export class CLIConfig {
         }
     }
     getApiUrl() {
-        return process.env.MEMORY_API_URL ||
+        const baseUrl = process.env.MEMORY_API_URL ||
             this.config.apiUrl ||
-            'https://api.lanonasis.com';
+            'https://mcp.lanonasis.com';
+        // Ensure we don't double-append /api/v1 - strip it if present since APIClient adds it
+        return baseUrl.replace(/\/api\/v1\/?$/, '');
     }
     // Get API URLs with fallbacks - try multiple endpoints
     getApiUrlsWithFallbacks() {
@@ -183,13 +186,14 @@ export class CLIConfig {
     }
     // Enhanced Service Discovery Integration
     async discoverServices(verbose = false) {
-        // Skip service discovery in test environment
-        if (process.env.NODE_ENV === 'test' || process.env.SKIP_SERVICE_DISCOVERY === 'true') {
+        const isTestEnvironment = process.env.NODE_ENV === 'test';
+        const forceDiscovery = process.env.FORCE_SERVICE_DISCOVERY === 'true';
+        if ((isTestEnvironment && !forceDiscovery) || process.env.SKIP_SERVICE_DISCOVERY === 'true') {
             if (!this.config.discoveredServices) {
                 this.config.discoveredServices = {
                     auth_base: 'https://auth.lanonasis.com',
-                    memory_base: 'https://mcp.lanonasis.com/api/v1',
-                    mcp_base: 'https://mcp.lanonasis.com/api/v1',
+                    memory_base: 'https://mcp.lanonasis.com', // Base URL without /api/v1
+                    mcp_base: 'https://mcp.lanonasis.com/api/v1', // Full MCP REST path
                     mcp_ws_base: 'wss://mcp.lanonasis.com/ws',
                     mcp_sse_base: 'https://mcp.lanonasis.com/api/v1/events',
                     project_scope: 'lanonasis-maas'
@@ -236,25 +240,24 @@ export class CLIConfig {
             throw lastError || new Error('All service discovery URLs failed');
         }
         try {
-            // Map discovery response to our config format
             const discovered = response.data;
-            // Extract auth base, but filter out localhost URLs
             let authBase = discovered.auth?.base || discovered.auth?.login?.replace('/auth/login', '') || '';
-            // Override localhost with production auth endpoint
             if (authBase.includes('localhost') || authBase.includes('127.0.0.1')) {
                 authBase = 'https://auth.lanonasis.com';
             }
-            const memoryBase = discovered.endpoints?.http || 'https://mcp.lanonasis.com/api/v1';
+            // Memory base should be the MCP base URL without /api/v1 suffix
+            // The API client will append the path as needed
+            const rawMemoryBase = discovered.endpoints?.http || 'https://mcp.lanonasis.com/api/v1';
+            const memoryBase = rawMemoryBase.replace(/\/api\/v1\/?$/, '') || 'https://mcp.lanonasis.com';
             this.config.discoveredServices = {
                 auth_base: authBase || 'https://auth.lanonasis.com',
                 memory_base: memoryBase,
-                mcp_base: memoryBase,
+                mcp_base: `${memoryBase}/api/v1`, // Full path for MCP REST calls
                 mcp_ws_base: discovered.endpoints?.websocket || 'wss://mcp.lanonasis.com/ws',
-                mcp_sse_base: discovered.endpoints?.sse || 'https://mcp.lanonasis.com/api/v1/events',
+                mcp_sse_base: discovered.endpoints?.sse || `${memoryBase}/api/v1/events`,
                 project_scope: 'lanonasis-maas'
             };
             this.config.apiUrl = memoryBase;
-            // Mark discovery as successful
             this.config.lastServiceDiscovery = new Date().toISOString();
             await this.save();
             if (verbose) {
@@ -265,10 +268,24 @@ export class CLIConfig {
             }
         }
         catch (error) {
-            // Enhanced error handling with user-visible messages
-            await this.handleServiceDiscoveryFailure(error, verbose);
+            const normalizedError = this.normalizeServiceError(error);
+            await this.handleServiceDiscoveryFailure(normalizedError, verbose);
         }
     }
+    normalizeServiceError(error) {
+        if (error && typeof error === 'object') {
+            if (error instanceof Error) {
+                return {
+                    ...error,
+                    message: error.message
+                };
+            }
+            return error;
+        }
+        return {
+            message: typeof error === 'string' ? error : JSON.stringify(error)
+        };
+    }
     async handleServiceDiscoveryFailure(error, verbose) {
         const errorType = this.categorizeServiceDiscoveryError(error);
         if (verbose || process.env.CLI_VERBOSE === 'true') {
@@ -294,7 +311,6 @@ export class CLIConfig {
                     console.log(`   Reason: ${error.message || 'Unknown error'}`);
             }
         }
-        // Use cached endpoints if available and recent (within 24 hours)
         if (this.config.discoveredServices && this.config.lastServiceDiscovery) {
             const lastDiscovery = new Date(this.config.lastServiceDiscovery);
             const hoursSinceDiscovery = (Date.now() - lastDiscovery.getTime()) / (1000 * 60 * 60);
@@ -311,7 +327,6 @@ export class CLIConfig {
             project_scope: 'lanonasis-maas'
         };
         this.config.apiUrl = fallback.endpoints.memory_base;
-        // Mark as fallback (don't set lastServiceDiscovery)
         await this.save();
         this.logFallbackUsage(fallback.source, this.config.discoveredServices);
         if (verbose) {
@@ -331,7 +346,7 @@ export class CLIConfig {
                     return 'timeout';
             }
         }
-        if (error.response?.status >= 500) {
+        if ((error.response?.status ?? 0) >= 500) {
             return 'server_error';
         }
         if (error.response?.status === 404) {
@@ -356,8 +371,8 @@ export class CLIConfig {
         const nodeEnv = (process.env.NODE_ENV ?? '').toLowerCase();
         const isDevEnvironment = nodeEnv === 'development' || nodeEnv === 'test';
         const defaultAuthBase = isDevEnvironment ? 'http://localhost:4000' : 'https://auth.lanonasis.com';
-        const defaultMemoryBase = isDevEnvironment ? 'http://localhost:4000/api/v1' : 'https://mcp.lanonasis.com/api/v1';
-        const defaultMcpBase = isDevEnvironment ? 'http://localhost:4100/api/v1' : 'https://mcp.lanonasis.com/api/v1';
+        const defaultMemoryBase = isDevEnvironment ? 'http://localhost:4000' : 'https://mcp.lanonasis.com'; // Base URL without /api/v1
+        const defaultMcpBase = isDevEnvironment ? 'http://localhost:4100/api/v1' : 'https://mcp.lanonasis.com/api/v1'; // Full MCP REST path
         const defaultMcpWsBase = isDevEnvironment ? 'ws://localhost:4100/ws' : 'wss://mcp.lanonasis.com/ws';
         const defaultMcpSseBase = isDevEnvironment ? 'http://localhost:4100/api/v1/events' : 'https://mcp.lanonasis.com/api/v1/events';
         const endpoints = {
@@ -421,9 +436,17 @@ export class CLIConfig {
             // Initialize with defaults first
             await this.discoverServices();
         }
+        const currentServices = this.config.discoveredServices ?? {
+            auth_base: 'https://auth.lanonasis.com',
+            memory_base: 'https://mcp.lanonasis.com', // Base URL without /api/v1
+            mcp_base: 'https://mcp.lanonasis.com/api/v1', // Full MCP REST path
+            mcp_ws_base: 'wss://mcp.lanonasis.com/ws',
+            mcp_sse_base: 'https://mcp.lanonasis.com/api/v1/events',
+            project_scope: 'lanonasis-maas'
+        };
         // Merge manual overrides with existing endpoints
         this.config.discoveredServices = {
-            ...this.config.discoveredServices,
+            ...currentServices,
             ...endpoints
         };
         // Mark as manually configured
@@ -483,56 +506,26 @@ export class CLIConfig {
         return true;
     }
     async validateVendorKeyWithServer(vendorKey) {
+        if (process.env.SKIP_SERVER_VALIDATION === 'true') {
+            return;
+        }
         try {
             // Import axios dynamically to avoid circular dependency
-            const axios = (await import('axios')).default;
             // Ensure service discovery is done
             await this.discoverServices();
             const authBase = this.config.discoveredServices?.auth_base || 'https://auth.lanonasis.com';
-            const normalizedBase = authBase.replace(/\/$/, '');
-            // Try multiple validation endpoints
-            const validationEndpoints = [
-                `${normalizedBase}/api/v1/auth/validate`,
-                `${normalizedBase}/api/v1/auth/validate-vendor-key`,
-                `${normalizedBase}/v1/auth/validate`
-            ];
-            let lastError;
-            let validated = false;
-            for (const endpoint of validationEndpoints) {
-                try {
-                    const response = await axios.post(endpoint, { key: vendorKey }, {
-                        headers: {
-                            'X-API-Key': vendorKey,
-                            'X-Auth-Method': 'vendor_key',
-                            'X-Project-Scope': 'lanonasis-maas',
-                            'Content-Type': 'application/json'
-                        },
-                        timeout: 10000,
-                        proxy: false
-                    });
-                    // Check if response indicates validation success
-                    if (response.data && (response.data.valid === true || response.data.success === true)) {
-                        validated = true;
-                        break;
-                    }
-                }
-                catch (error) {
-                    lastError = error;
-                    // Continue to next endpoint if this one fails
-                    continue;
-                }
-            }
-            if (!validated && lastError) {
-                throw lastError;
-            }
-            else if (!validated) {
-                throw new Error('Vendor key validation failed: Unable to validate key with server');
-            }
+            // Use pingAuthHealth for validation (simpler and more reliable)
+            await this.pingAuthHealth(axios, authBase, {
+                'X-API-Key': vendorKey,
+                'X-Auth-Method': 'vendor_key',
+                'X-Project-Scope': 'lanonasis-maas'
+            }, { timeout: 10000, proxy: false });
         }
         catch (error) {
+            const normalizedError = this.normalizeServiceError(error);
             // Provide specific error messages based on response
-            if (error.response?.status === 401) {
-                const errorData = error.response.data;
+            if (normalizedError.response?.status === 401) {
+                const errorData = normalizedError.response.data;
                 if (errorData?.error?.includes('expired') || errorData?.message?.includes('expired')) {
                     throw new Error('Vendor key validation failed: Key has expired. Please generate a new key from your dashboard.');
                 }
@@ -546,29 +539,29 @@ export class CLIConfig {
                     throw new Error('Vendor key validation failed: Authentication failed. The key may be invalid, expired, or revoked.');
                 }
             }
-            else if (error.response?.status === 403) {
+            else if (normalizedError.response?.status === 403) {
                 throw new Error('Vendor key access denied. The key may not have sufficient permissions for this operation.');
             }
-            else if (error.response?.status === 429) {
+            else if (normalizedError.response?.status === 429) {
                 throw new Error('Too many validation attempts. Please wait a moment before trying again.');
             }
-            else if (error.response?.status >= 500) {
+            else if ((normalizedError.response?.status ?? 0) >= 500) {
                 throw new Error('Server error during validation. Please try again in a few moments.');
             }
-            else if (error.code === 'ECONNREFUSED') {
+            else if (normalizedError.code === 'ECONNREFUSED') {
                 throw new Error('Cannot connect to authentication server. Please check your internet connection and try again.');
             }
-            else if (error.code === 'ENOTFOUND') {
+            else if (normalizedError.code === 'ENOTFOUND') {
                 throw new Error('Authentication server not found. Please check your internet connection.');
             }
-            else if (error.code === 'ETIMEDOUT') {
+            else if (normalizedError.code === 'ETIMEDOUT') {
                 throw new Error('Validation request timed out. Please check your internet connection and try again.');
             }
-            else if (error.code === 'ECONNRESET') {
+            else if (normalizedError.code === 'ECONNRESET') {
                 throw new Error('Connection was reset during validation. Please try again.');
             }
             else {
-                throw new Error(`Vendor key validation failed: ${error.message || 'Unknown error'}`);
+                throw new Error(`Vendor key validation failed: ${normalizedError.message || 'Unknown error'}`);
             }
         }
     }
@@ -731,7 +724,6 @@ export class CLIConfig {
         // If not locally valid, attempt server verification before failing
         if (!locallyValid) {
             try {
-                const axios = (await import('axios')).default;
                 const endpoints = [
                     'http://localhost:4000/v1/auth/verify-token',
                     'https://auth.lanonasis.com/v1/auth/verify-token'
@@ -768,7 +760,6 @@ export class CLIConfig {
         }
         // Verify with server (security check) for tokens that haven't been validated recently
         try {
-            const axios = (await import('axios')).default;
             // Try auth-gateway first (port 4000), then fall back to Netlify function
             const endpoints = [
                 'http://localhost:4000/v1/auth/verify-token',
@@ -880,7 +871,6 @@ export class CLIConfig {
                 return false;
             }
             // Import axios dynamically to avoid circular dependency
-            const axios = (await import('axios')).default;
             // Ensure service discovery is done
             await this.discoverServices();
             const authBase = this.config.discoveredServices?.auth_base || 'https://auth.lanonasis.com';
@@ -925,7 +915,6 @@ export class CLIConfig {
             // Refresh if token expires within 5 minutes
             if (exp > 0 && (exp - now) < 300) {
                 // Import axios dynamically
-                const axios = (await import('axios')).default;
                 await this.discoverServices();
                 const authBase = this.config.discoveredServices?.auth_base || 'https://auth.lanonasis.com';
                 // Attempt token refresh

package/dist/utils/mcp-client.js

@@ -456,9 +456,11 @@ export class MCPClient {
         // Use the proper SSE endpoint from config
         const sseUrl = this.config.getMCPSSEUrl() ?? `${serverUrl}/events`;
         const token = this.config.get('token');
-        if (token) {
+        const vendorKey = this.config.get('vendorKey');
+        const authKey = token || vendorKey || process.env.LANONASIS_API_KEY;
+        if (authKey) {
             // EventSource doesn't support headers directly, append token to URL
-            this.sseConnection = new EventSource(`${sseUrl}?token=${encodeURIComponent(token)}`);
+            this.sseConnection = new EventSource(`${sseUrl}?token=${encodeURIComponent(authKey)}`);
             this.sseConnection.onmessage = (event) => {
                 try {
                     const data = JSON.parse(event.data);
@@ -478,7 +480,9 @@ export class MCPClient {
      */
     async initializeWebSocket(wsUrl) {
         const token = this.config.get('token');
-        if (!token) {
+        const vendorKey = this.config.get('vendorKey');
+        const authKey = token || vendorKey || process.env.LANONASIS_API_KEY;
+        if (!authKey) {
             throw new Error('API key required for WebSocket mode. Set LANONASIS_API_KEY or login first.');
         }
         return new Promise((resolve, reject) => {
@@ -491,8 +495,8 @@ export class MCPClient {
                 // Create new WebSocket connection with authentication
                 this.wsConnection = new WebSocket(wsUrl, [], {
                     headers: {
-                        'Authorization': `Bearer ${token}`,
-                        'X-API-Key': token
+                        'Authorization': `Bearer ${authKey}`,
+                        'X-API-Key': authKey
                     }
                 });
                 this.wsConnection.on('open', () => {
@@ -624,15 +628,17 @@ export class MCPClient {
     async checkRemoteHealth() {
         const apiUrl = this.config.getMCPRestUrl() ?? 'https://mcp.lanonasis.com/api/v1';
         const token = this.config.get('token');
-        if (!token) {
+        const vendorKey = this.config.get('vendorKey');
+        const authKey = token || vendorKey || process.env.LANONASIS_API_KEY;
+        if (!authKey) {
             throw new Error('No authentication token available');
         }
         try {
             const axios = (await import('axios')).default;
             await axios.get(`${apiUrl}/health`, {
                 headers: {
-                    'Authorization': `Bearer ${token}`,
-                    'x-api-key': String(token)
+                    'Authorization': `Bearer ${authKey}`,
+                    'X-API-Key': authKey
                 },
                 timeout: 5000
             });
@@ -749,7 +755,9 @@ export class MCPClient {
     async callRemoteTool(toolName, args) {
         const apiUrl = this.config.getMCPRestUrl() ?? 'https://mcp.lanonasis.com/api/v1';
         const token = this.config.get('token');
-        if (!token) {
+        const vendorKey = this.config.get('vendorKey');
+        const authKey = token || vendorKey || process.env.LANONASIS_API_KEY;
+        if (!authKey) {
             throw new Error('Authentication required. Run "lanonasis auth login" first.');
         }
         // Map MCP tool names to REST API endpoints
@@ -805,8 +813,8 @@ export class MCPClient {
                 method: mapping.method,
                 url: `${apiUrl}${endpoint}`,
                 headers: {
-                    'Authorization': `Bearer ${token}`,
-                    'x-api-key': String(token),
+                    'Authorization': `Bearer ${authKey}`,
+                    'X-API-Key': authKey,
                     'Content-Type': 'application/json'
                 },
                 data: mapping.transform ? mapping.transform(args) : undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lanonasis/cli",
-  "version": "3.7.3",
+  "version": "3.7.5",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
     "@jest/globals": "^29.7.0",
     "@types/cli-progress": "^3.11.6",
     "@types/inquirer": "^9.0.7",
-    "@types/node": "^22.10.2",
+    "@types/node": "^22.19.3",
     "@types/ws": "^8.5.12",
     "jest": "^29.7.0",
     "rimraf": "^5.0.7",