@lanonasis/cli 3.3.15 → 3.5.15

package/dist/utils/mcp-client.js

@@ -2,7 +2,6 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import chalk from 'chalk';
 import { CLIConfig } from './config.js';
-import * as path from 'path';
 import * as fs from 'fs';
 import { EventSource } from 'eventsource';
 import WebSocket from 'ws';
@@ -17,9 +16,35 @@ export class MCPClient {
     healthCheckInterval = null;
     connectionStartTime = 0;
     lastHealthCheck = null;
+    activeConnectionMode = 'local'; // Track actual connection mode
     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
      */
@@ -43,13 +68,18 @@ export class MCPClient {
             await this.init();
             // Validate authentication before attempting connection
             await this.validateAuthBeforeConnect();
-            // Determine connection mode with priority to explicit mode option
-            // Default to 'remote' for better user experience
-            const connectionMode = options.connectionMode ??
-                (options.useWebSocket ? 'websocket' :
-                    options.useRemote ? 'remote' :
-                        this.config.get('mcpConnectionMode') ??
-                            this.config.get('mcpUseRemote') ? 'remote' : 'remote');
+            // Determine connection mode with clear precedence and safe defaults
+            // 1) explicit option
+            // 2) explicit flags
+            // 3) configured preference
+            // 4) default to 'websocket' (production-ready pm2 mcp-core)
+            const configuredMode = this.config.get('mcpConnectionMode');
+            const preferRemote = this.config.get('mcpUseRemote');
+            const connectionMode = options.connectionMode
+                ?? (options.useWebSocket ? 'websocket' : undefined)
+                ?? (options.useRemote ? 'remote' : undefined)
+                ?? configuredMode
+                ?? (preferRemote ? 'remote' : 'websocket');
             let wsUrl;
             let serverUrl;
             let serverPath;
@@ -70,6 +100,7 @@ export class MCPClient {
                     // Initialize WebSocket connection
                     await this.initializeWebSocket(wsUrl);
                     this.isConnected = true;
+                    this.activeConnectionMode = 'websocket';
                     this.retryAttempts = 0;
                     this.startHealthMonitoring();
                     return true;
@@ -90,21 +121,24 @@ export class MCPClient {
                     // Initialize SSE connection for real-time updates
                     await this.initializeSSE(serverUrl);
                     this.isConnected = true;
+                    this.activeConnectionMode = 'remote';
                     this.retryAttempts = 0;
                     this.startHealthMonitoring();
                     return true;
                 }
-                default: {
-                    // Local MCP server connection (default)
-                    const serverPathValue = options.serverPath ??
-                        this.config.get('mcpServerPath') ??
-                        path.join(path.resolve(), '../../../../onasis-gateway/mcp-server/server.js');
-                    serverPath = serverPathValue;
+                case 'local': {
+                    // Local MCP server connection requires explicit path via option or config
+                    serverPath = options.serverPath ?? this.config.get('mcpServerPath');
+                    if (!serverPath) {
+                        console.log(chalk.yellow('⚠️  No local MCP server path configured.'));
+                        console.log(chalk.cyan('💡 Prefer using WebSocket mode (default). Or configure a local path via:'));
+                        console.log(chalk.cyan('   lanonasis config set mcpServerPath /absolute/path/to/server.js'));
+                        throw new Error('Local MCP server path not provided');
+                    }
                     // Check if the server file exists
                     if (!fs.existsSync(serverPath)) {
                         console.log(chalk.yellow(`⚠️  Local MCP server not found at ${serverPath}`));
-                        console.log(chalk.cyan('💡 For remote connection, use: onasis mcp connect --url wss://mcp.lanonasis.com/ws'));
-                        console.log(chalk.cyan('💡 Or install local server: npm install -g @lanonasis/mcp-server'));
+                        console.log(chalk.cyan('💡 For remote use WebSocket: lanonasis mcp connect --mode websocket --url wss://mcp.lanonasis.com/ws'));
                         throw new Error(`MCP server not found at ${serverPath}`);
                     }
                     if (this.retryAttempts === 0) {
@@ -113,9 +147,20 @@ export class MCPClient {
                     else {
                         console.log(chalk.yellow(`Retry ${this.retryAttempts}/${this.maxRetries}: Connecting to local MCP server...`));
                     }
+                    // Allow passing extra args to local server (e.g., --stdio) via options or env/config
+                    // Precedence: options.localArgs -> env.MCP_LOCAL_SERVER_ARGS -> config.mcpLocalArgs -> none
+                    const envArgs = (process.env.MCP_LOCAL_SERVER_ARGS || '')
+                        .split(' ')
+                        .map(s => s.trim())
+                        .filter(Boolean);
+                    const configArgs = (this.config.get('mcpLocalArgs') || []);
+                    const extraArgs = (options.localArgs && options.localArgs.length > 0)
+                        ? options.localArgs
+                        : (envArgs.length > 0 ? envArgs : configArgs);
+                    const args = [serverPath, ...extraArgs];
                     const localTransport = new StdioClientTransport({
                         command: 'node',
-                        args: [serverPath]
+                        args
                     });
                     this.client = new Client({
                         name: '@lanonasis/cli',
@@ -123,11 +168,27 @@ export class MCPClient {
                     });
                     await this.client.connect(localTransport);
                     this.isConnected = true;
+                    this.activeConnectionMode = 'local';
                     this.retryAttempts = 0;
                     console.log(chalk.green('✓ Connected to MCP server'));
                     this.startHealthMonitoring();
                     return true;
                 }
+                default: {
+                    // Safety: if we reach default, fall back to remote (HTTP) rather than brittle local
+                    const serverUrlValue = options.serverUrl
+                        ?? this.config.get('mcpServerUrl')
+                        ?? this.config.getMCPRestUrl()
+                        ?? 'https://mcp.lanonasis.com/api/v1';
+                    serverUrl = serverUrlValue;
+                    console.log(chalk.yellow(`Unknown connection mode '${String(connectionMode)}', falling back to remote at ${serverUrl}`));
+                    await this.initializeSSE(serverUrl);
+                    this.isConnected = true;
+                    this.activeConnectionMode = 'remote';
+                    this.retryAttempts = 0;
+                    this.startHealthMonitoring();
+                    return true;
+                }
             }
         }
         catch (error) {
@@ -140,7 +201,8 @@ export class MCPClient {
     async handleConnectionFailure(error, options) {
         // Check if this is an authentication error (don't retry these)
         if (this.isAuthenticationError(error)) {
-            console.error(chalk.red('Authentication failed:'), error.message);
+            const authMsg = error?.message ?? '';
+            console.error(chalk.red('Authentication failed:'), authMsg);
             this.provideAuthenticationGuidance(error);
             this.isConnected = false;
             return false;
@@ -155,7 +217,8 @@ export class MCPClient {
         // For network errors, retry with exponential backoff
         const delay = await this.exponentialBackoff(this.retryAttempts);
         console.log(chalk.yellow(`Network error, retrying in ${delay}ms... (${this.retryAttempts}/${this.maxRetries})`));
-        console.log(chalk.gray(`Error: ${error.message}`));
+        const message = error?.message ?? String(error);
+        console.log(chalk.gray(`Error: ${message}`));
         await new Promise(resolve => setTimeout(resolve, delay));
         return this.connectWithRetry(options);
     }
@@ -163,7 +226,7 @@ export class MCPClient {
      * Check if error is authentication-related
      */
     isAuthenticationError(error) {
-        const errorMessage = error.message?.toLowerCase() || '';
+        const errorMessage = error?.message?.toLowerCase() || '';
         return errorMessage.includes('authentication_required') ||
             errorMessage.includes('authentication_invalid') ||
             errorMessage.includes('unauthorized') ||
@@ -171,23 +234,25 @@ export class MCPClient {
             errorMessage.includes('token is invalid') ||
             errorMessage.includes('401') ||
             errorMessage.includes('403') ||
-            (error.response?.status >= 401 && error.response?.status <= 403);
+            ((error.response?.status ?? 0) >= 401 &&
+                (error.response?.status ?? 0) <= 403);
     }
     /**
      * Provide authentication-specific guidance
      */
     provideAuthenticationGuidance(error) {
         console.log(chalk.yellow('\n🔐 Authentication Issue Detected:'));
-        if (error.message?.includes('AUTHENTICATION_REQUIRED')) {
+        const msg = error?.message ?? '';
+        if (msg.includes('AUTHENTICATION_REQUIRED')) {
             console.log(chalk.cyan('• No credentials found. Run: lanonasis auth login'));
             console.log(chalk.cyan('• Or set vendor key: lanonasis auth login --vendor-key pk_xxx.sk_xxx'));
         }
-        else if (error.message?.includes('AUTHENTICATION_INVALID')) {
+        else if (msg.includes('AUTHENTICATION_INVALID')) {
             console.log(chalk.cyan('• Invalid credentials. Check your vendor key format'));
             console.log(chalk.cyan('• Expected format: pk_xxx.sk_xxx'));
             console.log(chalk.cyan('• Try: lanonasis auth logout && lanonasis auth login'));
         }
-        else if (error.message?.includes('expired')) {
+        else if (msg.includes('expired')) {
             console.log(chalk.cyan('• Token expired. Re-authenticate: lanonasis auth login'));
             console.log(chalk.cyan('• Or refresh: lanonasis auth refresh (if available)'));
         }
@@ -200,27 +265,28 @@ export class MCPClient {
     /**
      * Provide network troubleshooting guidance
      */
-    provideNetworkTroubleshootingGuidance(error) {
+    provideNetworkTroubleshootingGuidance(_error) {
         console.log(chalk.yellow('\n🌐 Network Issue Detected:'));
-        if (error.message?.includes('ECONNREFUSED') || error.message?.includes('connect ECONNREFUSED')) {
+        const msg = _error?.message ?? '';
+        if (msg.includes('ECONNREFUSED') || msg.includes('connect ECONNREFUSED')) {
             console.log(chalk.cyan('• Connection refused. Service may be down:'));
             console.log(chalk.cyan('  - For remote: Check https://mcp.lanonasis.com/health'));
             console.log(chalk.cyan('  - For WebSocket: Check wss://mcp.lanonasis.com/ws'));
             console.log(chalk.cyan('  - For local: Install local MCP server'));
         }
-        else if (error.message?.includes('timeout') || error.message?.includes('ETIMEDOUT')) {
+        else if (msg.includes('timeout') || msg.includes('ETIMEDOUT')) {
             console.log(chalk.cyan('• Connection timeout. Check network:'));
             console.log(chalk.cyan('  - Verify internet connectivity'));
             console.log(chalk.cyan('  - Check firewall settings'));
             console.log(chalk.cyan('  - Try different connection mode: --mode remote'));
         }
-        else if (error.message?.includes('ENOTFOUND') || error.message?.includes('getaddrinfo')) {
+        else if (msg.includes('ENOTFOUND') || msg.includes('getaddrinfo')) {
             console.log(chalk.cyan('• DNS resolution failed:'));
             console.log(chalk.cyan('  - Check DNS settings'));
             console.log(chalk.cyan('  - Verify server URL is correct'));
             console.log(chalk.cyan('  - Try using IP address instead of hostname'));
         }
-        else if (error.message?.includes('certificate') || error.message?.includes('SSL') || error.message?.includes('TLS')) {
+        else if (msg.includes('certificate') || msg.includes('SSL') || msg.includes('TLS')) {
             console.log(chalk.cyan('• SSL/TLS certificate issue:'));
             console.log(chalk.cyan('  - Check system time and date'));
             console.log(chalk.cyan('  - Update CA certificates'));
@@ -297,7 +363,7 @@ export class MCPClient {
                 }
             }
         }
-        catch (error) {
+        catch {
             // If we can't decode the token, try to validate it with the server
             await this.validateTokenWithServer(token);
         }
@@ -323,7 +389,7 @@ export class MCPClient {
                 console.log(chalk.green('✓ Token refreshed successfully'));
             }
         }
-        catch (error) {
+        catch {
             throw new Error('Failed to refresh token. Please re-authenticate.');
         }
     }
@@ -343,10 +409,12 @@ export class MCPClient {
             });
         }
         catch (error) {
-            if (error.response?.status === 401 || error.response?.status === 403) {
+            const status = error.response?.status;
+            if (status === 401 || status === 403) {
                 throw new Error('Token is invalid or expired. Please re-authenticate.');
             }
-            throw new Error(`Token validation failed: ${error.message}`);
+            const msg = error?.message || 'Unknown error';
+            throw new Error(`Token validation failed: ${msg}`);
         }
     }
     /**
@@ -485,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();
@@ -498,8 +566,9 @@ export class MCPClient {
                     break;
             }
         }
-        catch (error) {
-            console.log(chalk.yellow('⚠️  Health check failed, attempting reconnection...'));
+        catch {
+            const connectionMode = this.activeConnectionMode || 'remote';
+            console.log(chalk.yellow(`⚠️  ${connectionMode} connection health check failed, attempting reconnection...`));
             await this.handleHealthCheckFailure();
         }
     }
@@ -536,8 +605,9 @@ export class MCPClient {
                 timeout: 5000
             });
         }
-        catch (error) {
-            throw new Error(`Remote health check failed: ${error}`);
+        catch (e) {
+            const msg = e?.message ?? String(e);
+            throw new Error(`Remote health check failed: ${msg}`);
         }
     }
     /**
@@ -551,8 +621,9 @@ export class MCPClient {
         try {
             await this.client.listTools();
         }
-        catch (error) {
-            throw new Error(`Local health check failed: ${error}`);
+        catch (e) {
+            const msg = e?.message ?? String(e);
+            throw new Error(`Local health check failed: ${msg}`);
         }
     }
     /**
@@ -562,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');
@@ -603,6 +675,7 @@ export class MCPClient {
             this.wsConnection = null;
         }
         this.isConnected = false;
+        this.activeConnectionMode = 'websocket'; // Reset to default
     }
     /**
      * Call an MCP tool
@@ -712,8 +785,7 @@ export class MCPClient {
         catch (error) {
             // Safely handle errors with type checking
             const errorObj = error;
-            const errorMsg = errorObj.response?.data?.error ||
-                (errorObj.message ? errorObj.message : 'Unknown error');
+            const errorMsg = errorObj.response?.data?.error || (errorObj.message ?? 'Unknown error');
             throw new Error(`Remote tool call failed: ${errorMsg}`);
         }
     }
@@ -757,8 +829,7 @@ export class MCPClient {
      * Get connection status details with health information
      */
     getConnectionStatus() {
-        const connectionMode = this.config.get('mcpConnectionMode') ??
-            (this.config.get('mcpUseRemote') ? 'remote' : 'local');
+        const connectionMode = this.activeConnectionMode;
         let server;
         switch (connectionMode) {
             case 'websocket':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lanonasis/cli",
-  "version": "3.3.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": {
@@ -24,7 +24,7 @@
     "test": "NODE_OPTIONS=--experimental-vm-modules jest",
     "test:mcp": "NODE_OPTIONS=--experimental-vm-modules jest --testPathPattern=mcp",
     "test:integration": "npm run build:mcp && npm run test:mcp",
-    "lint": "eslint src/**/*.ts",
+    "lint": "eslint .",
     "type-check": "tsc --noEmit",
     "prepare": "npm run build",
     "publish:with-mcp": "npm run build:mcp && npm publish"
@@ -99,4 +99,4 @@
   "engines": {
     "node": ">=18.0.0"
   }
-}
+}

package/dist/__tests__/auth-persistence.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/auth-persistence.test.js

@@ -1,243 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
-import { CLIConfig } from '../utils/config.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-// Mock axios for network calls
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const mockAxios = {
-    get: jest.fn(),
-    post: jest.fn()
-};
-jest.mock('axios', () => ({
-    default: mockAxios,
-    get: mockAxios.get,
-    post: mockAxios.post
-}));
-describe('Authentication Persistence Tests', () => {
-    let testConfigDir;
-    let config;
-    beforeEach(async () => {
-        // Create a temporary test directory for each test
-        testConfigDir = path.join(os.tmpdir(), `test-auth-persistence-${Date.now()}-${Math.random()}`);
-        await fs.mkdir(testConfigDir, { recursive: true });
-        // Create a new config instance with test directory
-        config = new CLIConfig();
-        config.configDir = testConfigDir;
-        config.configPath = path.join(testConfigDir, 'config.json');
-        config.lockFile = path.join(testConfigDir, 'config.lock');
-        await config.init();
-        // Clear axios mocks
-        mockAxios.get.mockClear();
-        mockAxios.post.mockClear();
-    });
-    afterEach(async () => {
-        // Clean up test directory
-        try {
-            await fs.rm(testConfigDir, { recursive: true, force: true });
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-    });
-    describe('Credential Storage and Retrieval', () => {
-        it('should store and retrieve vendor key credentials across CLI sessions', async () => {
-            const testVendorKey = 'pk_test123456789.sk_test123456789012345';
-            // Mock successful server validation
-            mockAxios.get.mockResolvedValueOnce({ status: 200, data: { status: 'ok' } });
-            // Store vendor key
-            await config.setVendorKey(testVendorKey);
-            // Verify storage
-            expect(config.getVendorKey()).toBe(testVendorKey);
-            expect(config.get('authMethod')).toBe('vendor_key');
-            expect(config.get('lastValidated')).toBeDefined();
-            // Simulate new CLI session by creating new config instance
-            const newConfig = new CLIConfig();
-            newConfig.configDir = testConfigDir;
-            newConfig.configPath = path.join(testConfigDir, 'config.json');
-            newConfig.lockFile = path.join(testConfigDir, 'config.lock');
-            await newConfig.init();
-            // Verify credentials persist across sessions
-            expect(newConfig.getVendorKey()).toBe(testVendorKey);
-            expect(newConfig.get('authMethod')).toBe('vendor_key');
-        });
-        it('should store and retrieve JWT token credentials across CLI sessions', async () => {
-            const testToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
-            // Store JWT token
-            await config.setToken(testToken);
-            // Verify storage
-            expect(config.getToken()).toBe(testToken);
-            expect(config.get('authMethod')).toBe('jwt');
-            expect(config.get('lastValidated')).toBeDefined();
-            // Simulate new CLI session
-            const newConfig = new CLIConfig();
-            newConfig.configDir = testConfigDir;
-            newConfig.configPath = path.join(testConfigDir, 'config.json');
-            newConfig.lockFile = path.join(testConfigDir, 'config.lock');
-            await newConfig.init();
-            // Verify token persists across sessions
-            expect(newConfig.getToken()).toBe(testToken);
-            expect(newConfig.get('authMethod')).toBe('jwt');
-        });
-    });
-    describe('Authentication Failure Tracking', () => {
-        it('should track authentication failure count and last failure time', async () => {
-            // Initially no failures
-            expect(config.getFailureCount()).toBe(0);
-            expect(config.getLastAuthFailure()).toBeUndefined();
-            // Increment failure count
-            await config.incrementFailureCount();
-            // Verify failure count increased
-            expect(config.getFailureCount()).toBe(1);
-            expect(config.getLastAuthFailure()).toBeDefined();
-            // Increment again
-            await config.incrementFailureCount();
-            // Verify count is now 2
-            expect(config.getFailureCount()).toBe(2);
-        });
-        it('should reset failure count when authentication succeeds', async () => {
-            // Add some failures
-            await config.incrementFailureCount();
-            await config.incrementFailureCount();
-            expect(config.getFailureCount()).toBe(2);
-            // Reset failure count (simulating successful auth)
-            await config.resetFailureCount();
-            // Verify reset
-            expect(config.getFailureCount()).toBe(0);
-            expect(config.getLastAuthFailure()).toBeUndefined();
-        });
-        it('should apply progressive delays based on failure count', async () => {
-            // Initially no delay
-            expect(config.shouldDelayAuth()).toBe(false);
-            expect(config.getAuthDelayMs()).toBe(0);
-            // After 3 failures, should delay
-            await config.incrementFailureCount(); // 1
-            await config.incrementFailureCount(); // 2
-            await config.incrementFailureCount(); // 3
-            expect(config.shouldDelayAuth()).toBe(true);
-            expect(config.getAuthDelayMs()).toBeGreaterThanOrEqual(1500); // 2000ms ± 25%
-            expect(config.getAuthDelayMs()).toBeLessThanOrEqual(2500);
-            // After 4 failures, delay should increase
-            await config.incrementFailureCount(); // 4
-            expect(config.getAuthDelayMs()).toBeGreaterThanOrEqual(3000); // 4000ms ± 25%
-            expect(config.getAuthDelayMs()).toBeLessThanOrEqual(5000);
-        });
-    });
-    describe('Vendor Key Validation', () => {
-        it('should validate correct vendor key format', () => {
-            const validKey = 'pk_test123456789.sk_test123456789012345';
-            const result = config.validateVendorKeyFormat(validKey);
-            expect(result).toBe(true);
-        });
-        it('should reject invalid vendor key formats', () => {
-            const invalidKeys = [
-                'invalid-key', // no dot
-                'pk_.sk_test123456789012345', // empty public part
-                'pk_test123456789.sk_', // empty secret part
-                'pk_test.sk_test', // too short
-                'pk_test123456789', // missing secret part
-                'sk_test123456789.pk_test123456789', // wrong order
-                'pk_test@invalid.sk_test123456789012345', // invalid chars
-            ];
-            invalidKeys.forEach(key => {
-                const result = config.validateVendorKeyFormat(key);
-                expect(result).not.toBe(true);
-                expect(typeof result).toBe('string'); // Should return error message
-            });
-        });
-        it('should accept valid vendor key formats', () => {
-            const validKeys = [
-                'pk_123456789ABCDEF.sk_1234567890123456789012345',
-                'pk_A0123456789ABC.sk_XYZ123456789012345',
-            ];
-            validKeys.forEach(key => {
-                const result = config.validateVendorKeyFormat(key);
-                expect(result).toBe(true);
-            });
-        });
-    });
-    describe('Token Expiry Handling', () => {
-        it('should detect if JWT token is authenticated', async () => {
-            // Valid token (in the future)
-            const validToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJleHAiOjk5OTk5OTk5OTl9.03fBznX7YvIa8e1GjN0dYF1zR2vZ3xP4wQ5rE6sT7uA';
-            await config.setToken(validToken);
-            const isAuthenticated = await config.isAuthenticated();
-            expect(isAuthenticated).toBe(true);
-        });
-        it('should detect if JWT token is expired', async () => {
-            // Expired token (in the past)
-            const expiredToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJleHAiOjE1MTYyMzkwMjJ9.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
-            await config.setToken(expiredToken);
-            const isAuthenticated = await config.isAuthenticated();
-            expect(isAuthenticated).toBe(false);
-        });
-    });
-    describe('Device ID Management', () => {
-        it('should generate and maintain consistent device ID across sessions', async () => {
-            // Get first device ID
-            const deviceId1 = await config.getDeviceId();
-            expect(deviceId1).toBeDefined();
-            expect(typeof deviceId1).toBe('string');
-            expect(deviceId1.length).toBeGreaterThan(0);
-            // Get device ID again - should be the same
-            const deviceId2 = await config.getDeviceId();
-            expect(deviceId1).toBe(deviceId2);
-            // Simulate new session
-            const newConfig = new CLIConfig();
-            newConfig.configDir = testConfigDir;
-            newConfig.configPath = path.join(testConfigDir, 'config.json');
-            newConfig.lockFile = path.join(testConfigDir, 'config.lock');
-            await newConfig.init();
-            // Device ID should persist across sessions
-            const deviceId3 = await newConfig.getDeviceId();
-            expect(deviceId1).toBe(deviceId3);
-        });
-    });
-    describe('Configuration Versioning and Migration', () => {
-        it('should maintain configuration version compatibility', async () => {
-            // Check that config has version
-            const version = config.get('version');
-            expect(version).toBeDefined();
-            expect(version).toBe('1.0.0');
-        });
-        it('should handle atomic configuration saves', async () => {
-            // Set some data
-            await config.setAndSave('testKey', 'testValue');
-            // Verify it was saved
-            expect(config.get('testKey')).toBe('testValue');
-            // Create new config instance and verify data persists
-            const newConfig = new CLIConfig();
-            newConfig.configDir = testConfigDir;
-            newConfig.configPath = path.join(testConfigDir, 'config.json');
-            newConfig.lockFile = path.join(testConfigDir, 'config.lock');
-            await newConfig.init();
-            expect(newConfig.get('testKey')).toBe('testValue');
-        });
-    });
-    describe('Credential Validation Against Server', () => {
-        it('should validate stored credentials against server', async () => {
-            const testVendorKey = 'pk_test123456789.sk_test123456789012345';
-            // Mock successful server validation
-            mockAxios.get.mockResolvedValue({ status: 200, data: { status: 'ok' } });
-            // Set vendor key
-            await config.setVendorKey(testVendorKey);
-            // Validate credentials
-            const isValid = await config.validateStoredCredentials();
-            expect(isValid).toBe(true);
-            // Verify server was called
-            expect(mockAxios.get).toHaveBeenCalledTimes(1);
-        });
-        it('should return false when credentials are invalid', async () => {
-            const testVendorKey = 'pk_test123456789.sk_test123456789012345';
-            // Mock failed server validation
-            mockAxios.get.mockRejectedValue({ response: { status: 401 } });
-            // Set vendor key
-            await config.setVendorKey(testVendorKey);
-            // Validate credentials
-            const isValid = await config.validateStoredCredentials();
-            expect(isValid).toBe(false);
-            // Verify server was called
-            expect(mockAxios.get).toHaveBeenCalledTimes(1);
-        });
-    });
-});

package/dist/__tests__/cross-device-integration.test.d.ts

@@ -1 +0,0 @@
-export {};