@lanonasis/cli 3.4.15 → 3.5.15

package/dist/commands/auth.js

@@ -231,8 +231,11 @@ export async function diagnoseCommand() {
                 console.log(chalk.green('   ✓ Token is not expired'));
             }
         }
-        catch {
+        catch (error) {
             console.log(chalk.yellow('   ⚠ Could not validate token expiry'));
+            if (process.env.CLI_VERBOSE === 'true' && error instanceof Error) {
+                console.log(chalk.gray(`     ${error.message}`));
+            }
         }
     }
     else {
@@ -315,8 +318,11 @@ export async function diagnoseCommand() {
         diagnostics.deviceId = deviceId;
         console.log(chalk.green('   ✓ Device ID:'), chalk.gray(deviceId));
     }
-    catch {
+    catch (error) {
         console.log(chalk.yellow('   ⚠ Could not get device ID'));
+        if (process.env.CLI_VERBOSE === 'true' && error instanceof Error) {
+            console.log(chalk.gray(`     ${error.message}`));
+        }
     }
     // Summary and recommendations
     console.log(chalk.blue.bold('\n📋 Diagnostic Summary'));

package/dist/core/welcome.js

@@ -393,7 +393,6 @@ export class InteractiveSetup {
                 mask: '*'
             }
         ]);
-        void auth; // suppress unused until real auth wired
         const spinner = ora('Signing in...').start();
         await this.simulateDelay(1000);
         spinner.succeed('Sign in successful!');

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

@@ -59,7 +59,7 @@ export class EnhancedMCPClient extends EventEmitter {
         const maxRetries = config.maxRetries || 3;
         const timeout = config.timeout || 30000;
         let attempts = 0;
-        while (attempts < maxRetries) {
+        while (true) {
             try {
                 this.updateConnectionStatus(config.name, 'connecting');
                 const client = await this.createClientWithTimeout(config, timeout);
@@ -82,7 +82,6 @@ export class EnhancedMCPClient extends EventEmitter {
                 await this.delay(delay);
             }
         }
-        return false;
     }
     /**
      * Create client with timeout

package/dist/mcp-server.d.ts

@@ -17,6 +17,7 @@ export declare class CLIMCPServer {
      * Start MCP server using CLI configuration
      */
     start(options?: MCPServerOptions): Promise<void>;
+    private resolveMCPServerPath;
     /**
      * Start local MCP server using CLI auth config
      */

package/dist/mcp-server.js

@@ -6,10 +6,13 @@
  */
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
+import { existsSync } from 'fs';
+import { createRequire } from 'module';
 import { spawn } from 'child_process';
 import { CLIConfig } from './utils/config.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+const nodeRequire = createRequire(import.meta.url);
 export class CLIMCPServer {
     config;
     constructor() {
@@ -28,6 +31,33 @@ export class CLIMCPServer {
             await this.startLocalMCP(options);
         }
     }
+    resolveMCPServerPath() {
+        const candidates = new Set();
+        if (process.env.MCP_SERVER_PATH) {
+            candidates.add(process.env.MCP_SERVER_PATH);
+        }
+        const packageRequests = [
+            '@lanonasis/mcp-server/dist/cli-aligned-mcp-server.js',
+            'lanonasis-mcp-server/dist/cli-aligned-mcp-server.js'
+        ];
+        for (const request of packageRequests) {
+            try {
+                const resolved = nodeRequire.resolve(request);
+                candidates.add(resolved);
+            }
+            catch {
+                // Ignore resolution failures and continue through fallbacks
+            }
+        }
+        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;
+            }
+        }
+        throw new Error('Unable to locate the CLI-aligned MCP server. Set MCP_SERVER_PATH or install @lanonasis/mcp-server.');
+    }
     /**
      * Start local MCP server using CLI auth config
      */
@@ -42,10 +72,11 @@ export class CLIMCPServer {
             console.error(`Config: ~/.maas/config.json`);
             console.error(`Auth: ${this.config.hasVendorKey() ? 'Vendor Key' : 'JWT Token'}`);
         }
+        const resolvedPort = typeof port === 'number' && !Number.isNaN(port) ? port : 3001;
         // Set environment variables from CLI config
         const env = {
             ...process.env,
-            PORT: port?.toString(),
+            PORT: resolvedPort.toString(),
             MEMORY_API_URL: this.config.getApiUrl(),
             LANONASIS_VENDOR_KEY: this.config.getVendorKey(),
             LANONASIS_TOKEN: this.config.getToken(),
@@ -84,14 +115,13 @@ export class CLIMCPServer {
      */
     async startRemoteMCP(options) {
         const { verbose } = options;
+        const message = 'Remote MCP not implemented; remove --remote or use local mode.';
         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 });
+        console.error(`❌ ${message}`);
+        throw new Error(message);
     }
     /**
      * Check if MCP server is available and configured
@@ -149,6 +179,10 @@ Examples:
     await server.start(options);
 }
 if (import.meta.url === `file://${process.argv[1]}`) {
-    main().catch(console.error);
+    main().catch(error => {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        process.exit(1);
+    });
 }
 export default CLIMCPServer;

package/dist/utils/config.d.ts

@@ -43,6 +43,14 @@ export declare class CLIConfig {
     private authCheckCache;
     private readonly AUTH_CACHE_TTL;
     constructor();
+    /**
+     * Overrides the configuration storage directory. Primarily used for tests.
+     */
+    setConfigDirectory(configDir: string): void;
+    /**
+     * Exposes the current config path for tests and diagnostics.
+     */
+    getConfigPath(): string;
     init(): Promise<void>;
     load(): Promise<void>;
     private migrateConfigIfNeeded;
@@ -55,6 +63,8 @@ export declare class CLIConfig {
     discoverServices(verbose?: boolean): Promise<void>;
     private handleServiceDiscoveryFailure;
     private categorizeServiceDiscoveryError;
+    private resolveFallbackEndpoints;
+    private logFallbackUsage;
     setManualEndpoints(endpoints: Partial<CLIConfigData['discoveredServices']>): Promise<void>;
     hasManualEndpointOverrides(): boolean;
     clearManualEndpointOverrides(): Promise<void>;
@@ -71,7 +81,6 @@ export declare class CLIConfig {
     isAuthenticated(): Promise<boolean>;
     logout(): Promise<void>;
     clear(): Promise<void>;
-    getConfigPath(): string;
     exists(): Promise<boolean>;
     validateStoredCredentials(): Promise<boolean>;
     refreshTokenIfNeeded(): Promise<void>;

package/dist/utils/config.js

@@ -16,6 +16,20 @@ export class CLIConfig {
         this.configPath = path.join(this.configDir, 'config.json');
         this.lockFile = path.join(this.configDir, 'config.lock');
     }
+    /**
+     * Overrides the configuration storage directory. Primarily used for tests.
+     */
+    setConfigDirectory(configDir) {
+        this.configDir = configDir;
+        this.configPath = path.join(configDir, 'config.json');
+        this.lockFile = path.join(configDir, 'config.lock');
+    }
+    /**
+     * Exposes the current config path for tests and diagnostics.
+     */
+    getConfigPath() {
+        return this.configPath;
+    }
     async init() {
         try {
             await fs.mkdir(this.configDir, { recursive: true });
@@ -229,20 +243,17 @@ export class CLIConfig {
                 return;
             }
         }
-        // Set fallback service endpoints
+        const fallback = this.resolveFallbackEndpoints();
         this.config.discoveredServices = {
-            auth_base: 'https://api.lanonasis.com', // CLI auth goes to central auth system
-            memory_base: 'https://api.lanonasis.com/api/v1', // Memory via onasis-core
-            mcp_base: 'https://mcp.lanonasis.com/api/v1', // MCP HTTP/REST
-            mcp_ws_base: 'wss://mcp.lanonasis.com/ws', // MCP WebSocket
-            mcp_sse_base: 'https://mcp.lanonasis.com/api/v1/events', // MCP SSE
-            project_scope: 'lanonasis-maas' // Correct project scope
+            ...fallback.endpoints,
+            project_scope: 'lanonasis-maas'
         };
         // Mark as fallback (don't set lastServiceDiscovery)
         await this.save();
+        this.logFallbackUsage(fallback.source, this.config.discoveredServices);
         if (verbose) {
             console.log('✓ Using fallback service endpoints');
-            console.log('   These are the standard production endpoints');
+            console.log(`   Source: ${fallback.source === 'environment' ? 'environment overrides' : 'built-in defaults'}`);
         }
     }
     categorizeServiceDiscoveryError(error) {
@@ -272,6 +283,47 @@ export class CLIConfig {
         }
         return 'unknown';
     }
+    resolveFallbackEndpoints() {
+        const envAuthBase = process.env.LANONASIS_FALLBACK_AUTH_BASE ?? process.env.AUTH_BASE;
+        const envMemoryBase = process.env.LANONASIS_FALLBACK_MEMORY_BASE ?? process.env.MEMORY_BASE;
+        const envMcpBase = process.env.LANONASIS_FALLBACK_MCP_BASE ?? process.env.MCP_BASE;
+        const envMcpWsBase = process.env.LANONASIS_FALLBACK_MCP_WS_BASE ?? process.env.MCP_WS_BASE;
+        const envMcpSseBase = process.env.LANONASIS_FALLBACK_MCP_SSE_BASE ?? process.env.MCP_SSE_BASE;
+        const hasEnvOverrides = Boolean(envAuthBase || envMemoryBase || envMcpBase || envMcpWsBase || envMcpSseBase);
+        const nodeEnv = (process.env.NODE_ENV ?? '').toLowerCase();
+        const isDevEnvironment = nodeEnv === 'development' || nodeEnv === 'test';
+        const defaultAuthBase = isDevEnvironment ? 'http://localhost:4000' : 'https://api.lanonasis.com';
+        const defaultMemoryBase = isDevEnvironment ? 'http://localhost:4000/api/v1' : 'https://api.lanonasis.com/api/v1';
+        const defaultMcpBase = isDevEnvironment ? 'http://localhost:4100/api/v1' : 'https://mcp.lanonasis.com/api/v1';
+        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 = {
+            auth_base: envAuthBase ?? defaultAuthBase,
+            memory_base: envMemoryBase ?? defaultMemoryBase,
+            mcp_base: envMcpBase ?? defaultMcpBase,
+            mcp_ws_base: envMcpWsBase ?? defaultMcpWsBase,
+            mcp_sse_base: envMcpSseBase ?? defaultMcpSseBase
+        };
+        return {
+            endpoints,
+            source: hasEnvOverrides ? 'environment' : 'default'
+        };
+    }
+    logFallbackUsage(source, endpoints) {
+        const summary = {
+            auth: endpoints.auth_base,
+            mcp: endpoints.mcp_base,
+            websocket: endpoints.mcp_ws_base,
+            sse: endpoints.mcp_sse_base,
+            source
+        };
+        const message = `Service discovery fallback activated using ${source === 'environment' ? 'environment overrides' : 'built-in defaults'}`;
+        console.warn(`⚠️  ${message}`);
+        console.info('📊 service_discovery_fallback', summary);
+        if (typeof process.emitWarning === 'function') {
+            process.emitWarning(message, 'ServiceDiscoveryFallback');
+        }
+    }
     // Manual endpoint override functionality
     async setManualEndpoints(endpoints) {
         if (!this.config.discoveredServices) {
@@ -570,9 +622,6 @@ export class CLIConfig {
         this.config = {};
         await this.save();
     }
-    getConfigPath() {
-        return this.configPath;
-    }
     async exists() {
         try {
             await fs.access(this.configPath);
@@ -656,9 +705,12 @@ export class CLIConfig {
                 }
             }
         }
-        catch {
+        catch (err) {
             // If refresh fails, mark credentials as potentially invalid
             await this.incrementFailureCount();
+            if (process.env.CLI_VERBOSE === 'true' || process.env.NODE_ENV !== 'production') {
+                console.debug('Token refresh failed:', err.message);
+            }
         }
     }
     async clearInvalidCredentials() {

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

@@ -57,6 +57,23 @@ export declare class MCPClient {
     private lastHealthCheck;
     private activeConnectionMode;
     constructor();
+    /**
+     * Overrides the configuration directory used by the underlying CLI config.
+     * Useful for tests that need isolated config state.
+     */
+    setConfigDirectory(configDir: string): void;
+    /**
+     * Returns the current config file path. Primarily used for test introspection.
+     */
+    getConfigPath(): string;
+    /**
+     * Helper for tests to seed authentication tokens without accessing internals.
+     */
+    setTokenForTesting(token: string): Promise<void>;
+    /**
+     * Helper for tests to seed vendor keys without accessing internals.
+     */
+    setVendorKeyForTesting(vendorKey: string): Promise<void>;
     /**
      * Initialize the MCP client configuration
      */

package/dist/utils/mcp-client.js

@@ -20,6 +20,31 @@ export class MCPClient {
     constructor() {
         this.config = new CLIConfig();
     }
+    /**
+     * Overrides the configuration directory used by the underlying CLI config.
+     * Useful for tests that need isolated config state.
+     */
+    setConfigDirectory(configDir) {
+        this.config.setConfigDirectory(configDir);
+    }
+    /**
+     * Returns the current config file path. Primarily used for test introspection.
+     */
+    getConfigPath() {
+        return this.config.getConfigPath();
+    }
+    /**
+     * Helper for tests to seed authentication tokens without accessing internals.
+     */
+    async setTokenForTesting(token) {
+        await this.config.setToken(token);
+    }
+    /**
+     * Helper for tests to seed vendor keys without accessing internals.
+     */
+    async setVendorKeyForTesting(vendorKey) {
+        await this.config.setVendorKey(vendorKey);
+    }
     /**
      * Initialize the MCP client configuration
      */
@@ -528,7 +553,7 @@ export class MCPClient {
         }
         try {
             this.lastHealthCheck = new Date();
-            const connectionMode = this.config.get('mcpConnectionMode') ?? 'remote';
+            const connectionMode = this.activeConnectionMode || 'remote';
             switch (connectionMode) {
                 case 'websocket':
                     await this.checkWebSocketHealth();
@@ -542,7 +567,8 @@ export class MCPClient {
             }
         }
         catch {
-            console.log(chalk.yellow('⚠️  Health check failed, attempting reconnection...'));
+            const connectionMode = this.activeConnectionMode || 'remote';
+            console.log(chalk.yellow(`⚠️  ${connectionMode} connection health check failed, attempting reconnection...`));
             await this.handleHealthCheckFailure();
         }
     }
@@ -607,10 +633,11 @@ export class MCPClient {
         this.isConnected = false;
         this.stopHealthMonitoring();
         // Attempt to reconnect with current configuration
-        const connectionMode = this.config.get('mcpConnectionMode') ?? 'remote';
+        const connectionMode = (this.activeConnectionMode || 'remote');
         const options = {
-            connectionMode: connectionMode
+            connectionMode
         };
+        console.log(chalk.yellow(`↻ Attempting reconnection using ${connectionMode} mode...`));
         // Add specific URLs if available
         if (connectionMode === 'websocket') {
             options.serverUrl = this.config.get('mcpWebSocketUrl');
@@ -648,7 +675,7 @@ export class MCPClient {
             this.wsConnection = null;
         }
         this.isConnected = false;
-        this.activeConnectionMode = 'local'; // Reset to default
+        this.activeConnectionMode = 'websocket'; // Reset to default
     }
     /**
      * Call an MCP tool

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lanonasis/cli",
-  "version": "3.4.15",
+  "version": "3.5.15",
   "description": "LanOnasis Enterprise CLI - Memory as a Service, API Key Management, and Infrastructure Orchestration",
   "main": "dist/index-simple.js",
   "bin": {