@lanonasis/cli 3.1.13 → 3.3.15

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

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

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

@@ -0,0 +1,243 @@
+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

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

package/dist/__tests__/cross-device-integration.test.js

@@ -0,0 +1,305 @@
+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 dependencies
+// 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
+}));
+jest.mock('eventsource');
+jest.mock('ws');
+jest.mock('@modelcontextprotocol/sdk/client/index.js', () => ({
+    Client: jest.fn().mockImplementation(() => ({
+        connect: jest.fn(),
+        close: jest.fn(),
+        callTool: jest.fn(),
+        listTools: jest.fn()
+    }))
+}));
+jest.mock('@modelcontextprotocol/sdk/client/stdio.js', () => ({
+    StdioClientTransport: jest.fn()
+}));
+describe('Cross-Device Integration Tests', () => {
+    let device1Config;
+    let device2Config;
+    let device3Config;
+    let device1Dir;
+    let device2Dir;
+    let device3Dir;
+    beforeEach(async () => {
+        // Create separate test directories for each "device"
+        device1Dir = path.join(os.tmpdir(), `test-device1-${Date.now()}-${Math.random()}`);
+        device2Dir = path.join(os.tmpdir(), `test-device2-${Date.now()}-${Math.random()}`);
+        device3Dir = path.join(os.tmpdir(), `test-device3-${Date.now()}-${Math.random()}`);
+        await fs.mkdir(device1Dir, { recursive: true });
+        await fs.mkdir(device2Dir, { recursive: true });
+        await fs.mkdir(device3Dir, { recursive: true });
+        // Create config instances for each "device"
+        device1Config = new CLIConfig();
+        device1Config.configDir = device1Dir;
+        device1Config.configPath = path.join(device1Dir, 'config.json');
+        device1Config.lockFile = path.join(device1Dir, 'config.lock');
+        device2Config = new CLIConfig();
+        device2Config.configDir = device2Dir;
+        device2Config.configPath = path.join(device2Dir, 'config.json');
+        device2Config.lockFile = path.join(device2Dir, 'config.lock');
+        device3Config = new CLIConfig();
+        device3Config.configDir = device3Dir;
+        device3Config.configPath = path.join(device3Dir, 'config.json');
+        device3Config.lockFile = path.join(device3Dir, 'config.lock');
+        // Initialize all configs
+        await device1Config.init();
+        await device2Config.init();
+        await device3Config.init();
+        // Clear axios mocks
+        mockAxios.get.mockClear();
+        mockAxios.post.mockClear();
+    });
+    afterEach(async () => {
+        // Clean up all test directories
+        try {
+            await fs.rm(device1Dir, { recursive: true, force: true });
+            await fs.rm(device2Dir, { recursive: true, force: true });
+            await fs.rm(device3Dir, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    });
+    describe('Same Credentials Working on Multiple Simulated Devices', () => {
+        it('should allow same vendor key to work on multiple devices', async () => {
+            const sharedVendorKey = 'pk_shared123456789.sk_shared123456789012345';
+            // Mock successful server validation for all devices
+            mockAxios.get.mockResolvedValue({ status: 200, data: { status: 'ok' } });
+            // Set same vendor key on all devices
+            await device1Config.setVendorKey(sharedVendorKey);
+            await device2Config.setVendorKey(sharedVendorKey);
+            await device3Config.setVendorKey(sharedVendorKey);
+            // Verify all devices have the same vendor key
+            expect(device1Config.getVendorKey()).toBe(sharedVendorKey);
+            expect(device2Config.getVendorKey()).toBe(sharedVendorKey);
+            expect(device3Config.getVendorKey()).toBe(sharedVendorKey);
+            // Verify all devices have same auth method
+            expect(device1Config.get('authMethod')).toBe('vendor_key');
+            expect(device2Config.get('authMethod')).toBe('vendor_key');
+            expect(device3Config.get('authMethod')).toBe('vendor_key');
+            // Verify server validation was called for each device
+            expect(mockAxios.get).toHaveBeenCalledTimes(3);
+        });
+        it('should maintain separate device IDs while sharing credentials', async () => {
+            const sharedVendorKey = 'pk_shared123456789.sk_shared123456789012345';
+            // Mock successful server validation
+            mockAxios.get.mockResolvedValue({ status: 200, data: { status: 'ok' } });
+            // Set same vendor key on all devices
+            await device1Config.setVendorKey(sharedVendorKey);
+            await device2Config.setVendorKey(sharedVendorKey);
+            await device3Config.setVendorKey(sharedVendorKey);
+            // Get device IDs
+            const deviceId1 = await device1Config.getDeviceId();
+            const deviceId2 = await device2Config.getDeviceId();
+            const deviceId3 = await device3Config.getDeviceId();
+            // Device IDs should be different
+            expect(deviceId1).not.toBe(deviceId2);
+            expect(deviceId1).not.toBe(deviceId3);
+            expect(deviceId2).not.toBe(deviceId3);
+            // But credentials should be the same
+            expect(device1Config.getVendorKey()).toBe(sharedVendorKey);
+            expect(device2Config.getVendorKey()).toBe(sharedVendorKey);
+            expect(device3Config.getVendorKey()).toBe(sharedVendorKey);
+        });
+    });
+    describe('Service Discovery Consistency Across Environments', () => {
+        it('should discover same service endpoints from all devices', async () => {
+            // Mock service discovery response
+            const mockDiscoveryResponse = {
+                auth: { login: 'https://api.lanonasis.com/auth/login' },
+                endpoints: {
+                    http: 'https://mcp.lanonasis.com/api/v1',
+                    websocket: 'wss://mcp.lanonasis.com/ws',
+                    sse: 'https://mcp.lanonasis.com/api/v1/events'
+                }
+            };
+            mockAxios.get.mockResolvedValue({ data: mockDiscoveryResponse });
+            // Perform service discovery on all devices
+            await device1Config.discoverServices();
+            await device2Config.discoverServices();
+            await device3Config.discoverServices();
+            // All devices should have discovered the same endpoints
+            const services1 = device1Config.get('discoveredServices');
+            const services2 = device2Config.get('discoveredServices');
+            const services3 = device3Config.get('discoveredServices');
+            expect(services1).toEqual(services2);
+            expect(services1).toEqual(services3);
+            expect(services2).toEqual(services3);
+            // Verify specific endpoints
+            expect(services1.mcp_base).toBe('https://mcp.lanonasis.com/api/v1');
+            expect(services1.mcp_ws_base).toBe('wss://mcp.lanonasis.com/ws');
+            expect(services1.mcp_sse_base).toBe('https://mcp.lanonasis.com/api/v1/events');
+        });
+        it('should handle service discovery failures consistently', async () => {
+            // Mock service discovery failure
+            mockAxios.get.mockRejectedValue(new Error('Service discovery failed'));
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+            // Attempt service discovery on all devices
+            await device1Config.discoverServices(true);
+            await device2Config.discoverServices(true);
+            await device3Config.discoverServices(true);
+            // All devices should fall back to same default endpoints
+            const services1 = device1Config.get('discoveredServices');
+            const services2 = device2Config.get('discoveredServices');
+            const services3 = device3Config.get('discoveredServices');
+            expect(services1).toEqual(services2);
+            expect(services1).toEqual(services3);
+            // Should use fallback endpoints
+            expect(services1.auth_base).toBe('https://api.lanonasis.com');
+            expect(services1.mcp_base).toBe('https://mcp.lanonasis.com/api/v1');
+            expect(services1.mcp_ws_base).toBe('wss://mcp.lanonasis.com/ws');
+            consoleSpy.mockRestore();
+        });
+    });
+    describe('Configuration Synchronization and Compatibility', () => {
+        it('should maintain configuration version compatibility across devices', async () => {
+            // All devices should have the same config version
+            expect(device1Config.get('version')).toBe('1.0.0');
+            expect(device2Config.get('version')).toBe('1.0.0');
+            expect(device3Config.get('version')).toBe('1.0.0');
+            // Set some data on device 1
+            await device1Config.setAndSave('testData', 'test-value');
+            // Read config file directly and apply to device 2
+            const configPath1 = device1Config.configPath;
+            const configData = JSON.parse(await fs.readFile(configPath1, 'utf-8'));
+            const configPath2 = device2Config.configPath;
+            await fs.writeFile(configPath2, JSON.stringify(configData, null, 2));
+            // Reload device 2 config
+            await device2Config.load();
+            // Device 2 should have the same data and version
+            expect(device2Config.get('testData')).toBe('test-value');
+            expect(device2Config.get('version')).toBe('1.0.0');
+        });
+        it('should create consistent backup files across devices', async () => {
+            const testData = { test: 'backup-data', timestamp: Date.now() };
+            // Set data on all devices
+            await device1Config.setAndSave('backupTest', testData);
+            await device2Config.setAndSave('backupTest', testData);
+            await device3Config.setAndSave('backupTest', testData);
+            // Create backups on all devices
+            const backup1 = await device1Config.backupConfig();
+            const backup2 = await device2Config.backupConfig();
+            const backup3 = await device3Config.backupConfig();
+            // All backups should exist
+            expect(await fs.access(backup1).then(() => true).catch(() => false)).toBe(true);
+            expect(await fs.access(backup2).then(() => true).catch(() => false)).toBe(true);
+            expect(await fs.access(backup3).then(() => true).catch(() => false)).toBe(true);
+            // All backups should contain the same data
+            const backupData1 = JSON.parse(await fs.readFile(backup1, 'utf-8'));
+            const backupData2 = JSON.parse(await fs.readFile(backup2, 'utf-8'));
+            const backupData3 = JSON.parse(await fs.readFile(backup3, 'utf-8'));
+            expect(backupData1.backupTest).toEqual(testData);
+            expect(backupData2.backupTest).toEqual(testData);
+            expect(backupData3.backupTest).toEqual(testData);
+            // All should have same version
+            expect(backupData1.version).toBe('1.0.0');
+            expect(backupData2.version).toBe('1.0.0');
+            expect(backupData3.version).toBe('1.0.0');
+        });
+    });
+    describe('Error Message Consistency Across Different Failure Scenarios', () => {
+        it('should provide consistent error messages for authentication failures', async () => {
+            const invalidVendorKey = 'pk_invalid.sk_invalid';
+            // Mock authentication failure
+            mockAxios.get.mockRejectedValue({
+                response: { status: 401, data: { error: 'invalid vendor key' } }
+            });
+            // Attempt to set invalid vendor key on all devices
+            const errors = [];
+            try {
+                await device1Config.setVendorKey(invalidVendorKey);
+            }
+            catch (error) {
+                errors.push(error.message);
+            }
+            try {
+                await device2Config.setVendorKey(invalidVendorKey);
+            }
+            catch (error) {
+                errors.push(error.message);
+            }
+            try {
+                await device3Config.setVendorKey(invalidVendorKey);
+            }
+            catch (error) {
+                errors.push(error.message);
+            }
+            // All devices should get the same error message
+            expect(errors).toHaveLength(3);
+            expect(errors[0]).toBe(errors[1]);
+            expect(errors[0]).toBe(errors[2]);
+            expect(errors[0]).toContain('Vendor key authentication failed');
+        });
+        it('should provide consistent validation error messages', async () => {
+            const invalidFormats = [
+                'invalid-key',
+                'pk_short.sk_short',
+                'pk_.sk_test123456789012345',
+                'pk_test123456789.sk_'
+            ];
+            for (const invalidKey of invalidFormats) {
+                const validationResults = [];
+                // Test validation on all devices
+                validationResults.push(device1Config.validateVendorKeyFormat(invalidKey));
+                validationResults.push(device2Config.validateVendorKeyFormat(invalidKey));
+                validationResults.push(device3Config.validateVendorKeyFormat(invalidKey));
+                // All devices should return the same validation error
+                expect(validationResults[0]).toBe(validationResults[1]);
+                expect(validationResults[0]).toBe(validationResults[2]);
+                expect(typeof validationResults[0]).toBe('string'); // Should be error message
+            }
+        });
+        it('should maintain consistent failure tracking across devices', async () => {
+            const sharedVendorKey = 'pk_shared123456789.sk_shared123456789012345';
+            // Mock successful initial setup
+            mockAxios.get.mockResolvedValue({ status: 200, data: { status: 'ok' } });
+            // Set vendor key on all devices
+            await device1Config.setVendorKey(sharedVendorKey);
+            await device2Config.setVendorKey(sharedVendorKey);
+            await device3Config.setVendorKey(sharedVendorKey);
+            // Mock validation failure
+            mockAxios.get.mockRejectedValue({
+                response: { status: 401, data: { error: 'invalid credentials' } }
+            });
+            // Validate credentials on all devices (should fail)
+            await device1Config.validateStoredCredentials();
+            await device2Config.validateStoredCredentials();
+            await device3Config.validateStoredCredentials();
+            // All devices should have incremented failure count
+            expect(device1Config.getFailureCount()).toBe(1);
+            expect(device2Config.getFailureCount()).toBe(1);
+            expect(device3Config.getFailureCount()).toBe(1);
+            // Add more failures to test delay calculation consistency
+            await device1Config.incrementFailureCount();
+            await device1Config.incrementFailureCount();
+            await device2Config.incrementFailureCount();
+            await device2Config.incrementFailureCount();
+            await device3Config.incrementFailureCount();
+            await device3Config.incrementFailureCount();
+            // All devices should have same failure count and delay
+            expect(device1Config.getFailureCount()).toBe(3);
+            expect(device2Config.getFailureCount()).toBe(3);
+            expect(device3Config.getFailureCount()).toBe(3);
+            expect(device1Config.shouldDelayAuth()).toBe(true);
+            expect(device2Config.shouldDelayAuth()).toBe(true);
+            expect(device3Config.shouldDelayAuth()).toBe(true);
+            expect(device1Config.getAuthDelayMs()).toBe(2000);
+            expect(device2Config.getAuthDelayMs()).toBe(2000);
+            expect(device3Config.getAuthDelayMs()).toBe(2000);
+        });
+    });
+});

package/dist/__tests__/mcp-connection-reliability.test.d.ts

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