onbuzz 3.4.0 → 3.6.2

package/src/interfaces/terminal/__tests__/smoke/imports.test.js

@@ -92,12 +92,10 @@ describe('Terminal UI Infrastructure - Imports', () => {
   });
 
   test('useConnection hook can be imported', async () => {
-    const { useConnection, useConnectionStatus } = await import('../../state/useConnection.js');
+    const mod = await import('../../state/useConnection.js');
 
-    expect(useConnection).toBeDefined();
-    expect(typeof useConnection).toBe('function');
-    expect(useConnectionStatus).toBeDefined();
-    expect(typeof useConnectionStatus).toBe('function');
+    expect(mod.useConnection).toBeDefined();
+    expect(typeof mod.useConnection).toBe('function');
   });
 });
 

package/src/interfaces/webServer.js

@@ -1946,15 +1946,6 @@ class WebServer {
       try {
         const { sessionId, filename } = req.params;
 
-        // Security validation: Check if sessionId exists
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-          return res.status(HTTP_STATUS.FORBIDDEN).json({
-            success: false,
-            error: 'Invalid session'
-          });
-        }
-
         // Security validation: Check filename for path traversal attempts
         const normalizedFilename = path.basename(filename);
         if (normalizedFilename !== filename || filename.includes('..') || filename.includes('/') || filename.includes('\\')) {
@@ -1964,19 +1955,32 @@ class WebServer {
           });
         }
 
+        // Session may or may not still exist (server restarts lose session map)
+        const session = this.sessions.get(sessionId);
+        const projectDir = session?.projectDir || process.cwd();
+
         // Try to locate the image in multiple possible locations
         let imagePath = null;
         const searchPaths = [
           // 1. Session's project directory images folder
-          path.join(session.projectDir || process.cwd(), 'images', normalizedFilename),
+          path.join(projectDir, 'images', normalizedFilename),
           // 2. Temp directory for this session
           path.join('/tmp/loxia-images', sessionId, normalizedFilename),
           // 3. General temp images directory
-          path.join('/tmp/loxia-images', normalizedFilename)
+          path.join('/tmp/loxia-images', normalizedFilename),
+          // 4. OS temp dir (Windows: %TEMP%, Linux: /tmp)
+          path.join(process.env.TEMP || process.env.TMP || '/tmp', 'loxia-images', sessionId, normalizedFilename),
+          path.join(process.env.TEMP || process.env.TMP || '/tmp', 'loxia-images', normalizedFilename)
         ];
 
-        // 4. Search in agent working directories for this session
-        // Get all agents and check their workingDirectory
+        // 5. Search ALL known project dirs from active sessions (not just current)
+        for (const [, sess] of this.sessions) {
+          if (sess?.projectDir && sess.projectDir !== projectDir) {
+            searchPaths.push(path.join(sess.projectDir, 'images', normalizedFilename));
+          }
+        }
+
+        // 6. Search in agent working directories AND agent projectDirs
         if (this.orchestrator?.agentPool) {
           try {
             const agents = await this.orchestrator.agentPool.getAllAgents();
@@ -1986,6 +1990,10 @@ class WebServer {
                   path.join(agent.directoryAccess.workingDirectory, 'images', normalizedFilename)
                 );
               }
+              // Also check the agent's own projectDir (may differ from session projectDir)
+              if (agent.projectDir) {
+                searchPaths.push(path.join(agent.projectDir, 'images', normalizedFilename));
+              }
             }
           } catch (error) {
             this.logger.warn('Failed to get agent working directories for image search', {
@@ -1994,6 +2002,12 @@ class WebServer {
           }
         }
 
+        // 7. Common user project directory (fallback for when session is gone)
+        const homeDir = process.env.USERPROFILE || process.env.HOME || '';
+        if (homeDir) {
+          searchPaths.push(path.join(homeDir, 'Loxia', 'images', normalizedFilename));
+        }
+
         // Find the first existing file
         for (const searchPath of searchPaths) {
           try {
@@ -2576,6 +2590,76 @@ class WebServer {
       }
     });
 
+    // ============================================
+    // Artifacts API Endpoint
+    // ============================================
+
+    // DEBUG: Inject a test artifact into an agent (remove after testing)
+    this.app.post('/api/agents/:agentId/artifacts/test', async (req, res) => {
+      try {
+        const { agentId } = req.params;
+        const agent = await this.orchestrator.agentPool.getAgent(agentId);
+        if (!agent) return res.status(404).json({ success: false, error: 'Agent not found' });
+
+        if (!agent.artifacts) agent.artifacts = {};
+        const testPath = (agent.directoryAccess?.workingDirectory || '/test') + '/test-artifact.js';
+        const displayPath = 'test-artifact.js';
+
+        agent.artifacts[testPath] = {
+          displayPath,
+          versions: [{
+            id: `v-${Date.now()}`,
+            content: '// Test artifact\nconsole.log("Hello from artifacts!");',
+            timestamp: new Date().toISOString(),
+            action: 'write',
+            size: 50,
+            fullPath: testPath
+          }]
+        };
+
+        // Broadcast via WebSocket
+        const sessionIds = this.orchestrator.webSocketManager?.getSessionsForAgent?.(agentId) || [];
+        for (const sid of sessionIds) {
+          this.orchestrator.webSocketManager.broadcastToSession(sid, {
+            type: 'artifacts_updated',
+            data: { agentId, artifacts: agent.artifacts, workingDirectory: agent.directoryAccess?.workingDirectory || '' }
+          });
+        }
+
+        res.json({ success: true, artifactCount: Object.keys(agent.artifacts).length });
+      } catch (error) {
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
+    // Get artifacts (files written by the agent) with version history
+    this.app.get('/api/agents/:agentId/artifacts', async (req, res) => {
+      try {
+        const { agentId } = req.params;
+        const agent = await this.orchestrator.agentPool.getAgent(agentId);
+
+        if (!agent) {
+          return res.status(404).json({ success: false, error: 'Agent not found' });
+        }
+
+        // Return the artifacts map (or empty if none yet)
+        // { [filePath]: { displayPath, versions: [{ id, content, timestamp, action, size }] } }
+        res.json({
+          success: true,
+          agentId,
+          artifacts: agent.artifacts || {},
+          workingDirectory: agent.directoryAccess?.workingDirectory || ''
+        });
+
+      } catch (error) {
+        this.logger.error('Failed to get agent artifacts', {
+          agentId: req.params.agentId,
+          error: error.message
+        });
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
     // ============================================
     // Terminal Tasks API Endpoints
     // ============================================

package/src/services/__tests__/agentActivityService.test.js

@@ -0,0 +1,319 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+import {
+  shouldAgentBeActive,
+  getActiveAgents,
+  getAllAgentActivityStatus,
+  shouldSkipIteration,
+  hasPendingTasks,
+  getMessageQueueStatus,
+  isAgentDelayed,
+  isAgentPaused,
+  isExecutingTools
+} from '../agentActivityService.js';
+
+// Helper to create a base active agent
+function makeAgent(overrides = {}) {
+  return {
+    id: 'agent-1',
+    name: 'Test Agent',
+    sessionId: 'session-1',
+    status: 'active',
+    mode: 'agent',
+    taskList: { tasks: [] },
+    messageQueues: {},
+    delayEndTime: null,
+    pausedUntil: null,
+    awaitingUserInput: null,
+    stopRequested: false,
+    toolExecutionInProgress: false,
+    ttl: null,
+    ...overrides
+  };
+}
+
+describe('agentActivityService', () => {
+  describe('hasPendingTasks', () => {
+    test('returns false when taskList is null or missing', () => {
+      expect(hasPendingTasks({})).toBe(false);
+      expect(hasPendingTasks({ taskList: null })).toBe(false);
+      expect(hasPendingTasks({ taskList: {} })).toBe(false);
+      expect(hasPendingTasks({ taskList: { tasks: 'not-array' } })).toBe(false);
+    });
+
+    test('returns true when there are pending tasks', () => {
+      const agent = makeAgent({
+        taskList: { tasks: [{ status: 'pending' }] }
+      });
+      expect(hasPendingTasks(agent)).toBe(true);
+    });
+
+    test('returns true when there are in_progress tasks', () => {
+      const agent = makeAgent({
+        taskList: { tasks: [{ status: 'completed' }, { status: 'in_progress' }] }
+      });
+      expect(hasPendingTasks(agent)).toBe(true);
+    });
+
+    test('returns false when all tasks are completed', () => {
+      const agent = makeAgent({
+        taskList: { tasks: [{ status: 'completed' }, { status: 'failed' }] }
+      });
+      expect(hasPendingTasks(agent)).toBe(false);
+    });
+  });
+
+  describe('getMessageQueueStatus', () => {
+    test('returns zero counts for empty queues', () => {
+      const result = getMessageQueueStatus({});
+      expect(result.hasMessages).toBe(false);
+      expect(result.counts.total).toBe(0);
+    });
+
+    test('counts messages across all queues', () => {
+      const agent = makeAgent({
+        messageQueues: {
+          toolResults: [{ id: 1 }],
+          interAgentMessages: [{ id: 2 }, { id: 3 }],
+          userMessages: [{ id: 4 }]
+        }
+      });
+      const result = getMessageQueueStatus(agent);
+      expect(result.hasMessages).toBe(true);
+      expect(result.hasUserMessages).toBe(true);
+      expect(result.hasInterAgentMessages).toBe(true);
+      expect(result.hasToolResults).toBe(true);
+      expect(result.counts.total).toBe(4);
+    });
+
+    test('handles non-array queue values', () => {
+      const agent = makeAgent({
+        messageQueues: { toolResults: 'not-array', userMessages: null }
+      });
+      const result = getMessageQueueStatus(agent);
+      expect(result.counts.toolResults).toBe(0);
+      expect(result.counts.userMessages).toBe(0);
+    });
+  });
+
+  describe('isAgentDelayed', () => {
+    test('returns false when no delayEndTime', () => {
+      expect(isAgentDelayed(makeAgent())).toBe(false);
+    });
+
+    test('returns true when delay is in the future', () => {
+      const future = new Date(Date.now() + 60000).toISOString();
+      expect(isAgentDelayed(makeAgent({ delayEndTime: future }))).toBe(true);
+    });
+
+    test('returns false when delay is in the past', () => {
+      const past = new Date(Date.now() - 60000).toISOString();
+      expect(isAgentDelayed(makeAgent({ delayEndTime: past }))).toBe(false);
+    });
+  });
+
+  describe('isAgentPaused', () => {
+    test('returns false for active, non-paused agent', () => {
+      expect(isAgentPaused(makeAgent())).toBe(false);
+    });
+
+    test('returns true for paused status without expiry', () => {
+      expect(isAgentPaused(makeAgent({ status: 'paused' }))).toBe(true);
+    });
+
+    test('returns true for paused status with future expiry', () => {
+      const future = new Date(Date.now() + 60000).toISOString();
+      expect(isAgentPaused(makeAgent({ status: 'paused', pausedUntil: future }))).toBe(true);
+    });
+
+    test('returns false for paused status with past expiry', () => {
+      const past = new Date(Date.now() - 60000).toISOString();
+      expect(isAgentPaused(makeAgent({ status: 'paused', pausedUntil: past }))).toBe(false);
+    });
+
+    test('returns true when pausedUntil is in future even without paused status', () => {
+      const future = new Date(Date.now() + 60000).toISOString();
+      expect(isAgentPaused(makeAgent({ pausedUntil: future }))).toBe(true);
+    });
+  });
+
+  describe('isExecutingTools', () => {
+    test('returns true when toolExecutionInProgress is true', () => {
+      expect(isExecutingTools({ toolExecutionInProgress: true })).toBe(true);
+    });
+
+    test('returns false otherwise', () => {
+      expect(isExecutingTools({ toolExecutionInProgress: false })).toBe(false);
+      expect(isExecutingTools({})).toBe(false);
+    });
+  });
+
+  describe('shouldAgentBeActive', () => {
+    test('returns inactive for null agent', () => {
+      const result = shouldAgentBeActive(null);
+      expect(result.active).toBe(false);
+      expect(result.reason).toBe('agent-not-found');
+    });
+
+    test('returns inactive for non-active status', () => {
+      const result = shouldAgentBeActive(makeAgent({ status: 'idle' }));
+      expect(result.active).toBe(false);
+      expect(result.reason).toBe('agent-inactive-status');
+    });
+
+    test('returns inactive when delayed', () => {
+      const future = new Date(Date.now() + 60000).toISOString();
+      const result = shouldAgentBeActive(makeAgent({ delayEndTime: future }));
+      expect(result.active).toBe(false);
+      expect(result.reason).toBe('agent-delayed');
+    });
+
+    test('returns inactive when paused', () => {
+      const result = shouldAgentBeActive(makeAgent({ status: 'active', pausedUntil: new Date(Date.now() + 60000).toISOString() }));
+      expect(result.active).toBe(false);
+      expect(result.reason).toBe('agent-paused');
+    });
+
+    test('returns inactive when awaiting user input', () => {
+      const result = shouldAgentBeActive(makeAgent({ awaitingUserInput: { type: 'credentials' } }));
+      expect(result.active).toBe(false);
+      expect(result.reason).toBe('awaiting-user-input');
+    });
+
+    test('returns inactive when stop requested', () => {
+      const result = shouldAgentBeActive(makeAgent({ stopRequested: true }));
+      expect(result.active).toBe(false);
+      expect(result.reason).toBe('stop-requested');
+    });
+
+    test('returns active when TTL remaining', () => {
+      const result = shouldAgentBeActive(makeAgent({ ttl: 3 }));
+      expect(result.active).toBe(true);
+      expect(result.reason).toBe('has-ttl-remaining');
+    });
+
+    test('AGENT mode: active when has pending tasks', () => {
+      const result = shouldAgentBeActive(makeAgent({
+        taskList: { tasks: [{ status: 'pending' }] }
+      }));
+      expect(result.active).toBe(true);
+      expect(result.reason).toBe('has-pending-tasks');
+    });
+
+    test('AGENT mode: inactive when no pending tasks', () => {
+      const result = shouldAgentBeActive(makeAgent({
+        taskList: { tasks: [{ status: 'completed' }] }
+      }));
+      expect(result.active).toBe(false);
+      expect(result.reason).toBe('no-pending-work');
+    });
+
+    test('CHAT mode: active when has user messages', () => {
+      const result = shouldAgentBeActive(makeAgent({
+        mode: 'chat',
+        messageQueues: { userMessages: [{ id: 1 }] }
+      }));
+      expect(result.active).toBe(true);
+      expect(result.reason).toBe('has-user-messages');
+    });
+
+    test('CHAT mode: active when has inter-agent messages', () => {
+      const result = shouldAgentBeActive(makeAgent({
+        mode: 'chat',
+        messageQueues: { interAgentMessages: [{ id: 1 }] }
+      }));
+      expect(result.active).toBe(true);
+      expect(result.reason).toBe('has-inter-agent-messages');
+    });
+
+    test('CHAT mode: inactive with only tool results', () => {
+      const result = shouldAgentBeActive(makeAgent({
+        mode: 'chat',
+        messageQueues: { toolResults: [{ id: 1 }] }
+      }));
+      expect(result.active).toBe(false);
+      expect(result.reason).toBe('chat-mode-no-messages');
+      expect(result.details).toContain('tool results');
+    });
+
+    test('CHAT mode: inactive with no messages', () => {
+      const result = shouldAgentBeActive(makeAgent({ mode: 'chat' }));
+      expect(result.active).toBe(false);
+      expect(result.reason).toBe('chat-mode-no-messages');
+    });
+
+    test('returns unknown mode for unrecognized mode', () => {
+      const result = shouldAgentBeActive(makeAgent({ mode: 'weird' }));
+      expect(result.active).toBe(false);
+      expect(result.reason).toBe('unknown-mode');
+    });
+  });
+
+  describe('getActiveAgents', () => {
+    test('filters active agents from an array', () => {
+      const agents = [
+        makeAgent({ id: 'a1', taskList: { tasks: [{ status: 'pending' }] } }),
+        makeAgent({ id: 'a2', status: 'idle' }),
+        makeAgent({ id: 'a3', taskList: { tasks: [{ status: 'pending' }] } })
+      ];
+      const active = getActiveAgents(agents);
+      expect(active).toHaveLength(2);
+      expect(active.map(a => a.agentId)).toEqual(['a1', 'a3']);
+    });
+
+    test('works with a Map input', () => {
+      const agents = new Map();
+      agents.set('a1', makeAgent({ id: 'a1', taskList: { tasks: [{ status: 'pending' }] } }));
+      agents.set('a2', makeAgent({ id: 'a2', status: 'idle' }));
+      const active = getActiveAgents(agents);
+      expect(active).toHaveLength(1);
+    });
+  });
+
+  describe('getAllAgentActivityStatus', () => {
+    test('returns detailed status for all agents', () => {
+      const agents = [
+        makeAgent({ id: 'a1', name: 'Agent 1', taskList: { tasks: [{ status: 'pending' }] } })
+      ];
+      const statuses = getAllAgentActivityStatus(agents);
+      expect(statuses).toHaveLength(1);
+      expect(statuses[0].agentId).toBe('a1');
+      expect(statuses[0].active).toBe(true);
+      expect(statuses[0]).toHaveProperty('queueCounts');
+      expect(statuses[0]).toHaveProperty('hasPendingTasks');
+      expect(statuses[0]).toHaveProperty('isExecutingTools');
+    });
+
+    test('works with Map input', () => {
+      const map = new Map();
+      map.set('a1', makeAgent({ id: 'a1' }));
+      const statuses = getAllAgentActivityStatus(map);
+      expect(statuses).toHaveLength(1);
+    });
+  });
+
+  describe('shouldSkipIteration', () => {
+    test('returns skip for null agent', () => {
+      const result = shouldSkipIteration(null);
+      expect(result.skip).toBe(true);
+    });
+
+    test('returns skip when delayed', () => {
+      const future = new Date(Date.now() + 60000).toISOString();
+      const result = shouldSkipIteration(makeAgent({ delayEndTime: future }));
+      expect(result.skip).toBe(true);
+    });
+
+    test('returns skip when paused with future expiry', () => {
+      const future = new Date(Date.now() + 60000).toISOString();
+      const result = shouldSkipIteration(makeAgent({ pausedUntil: future }));
+      expect(result.skip).toBe(true);
+    });
+
+    test('returns no skip for normal agent', () => {
+      const result = shouldSkipIteration(makeAgent());
+      expect(result.skip).toBe(false);
+      expect(result.reason).toBeNull();
+    });
+  });
+});

package/src/services/__tests__/apiKeyManager.test.js

@@ -0,0 +1,206 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+
+// Mock fs/promises, crypto, os, and userDataDir before importing
+const mockFs = {
+  readFile: jest.fn(),
+  writeFile: jest.fn()
+};
+const mockCrypto = {
+  randomBytes: jest.fn(() => Buffer.alloc(32, 'a')),
+  pbkdf2Sync: jest.fn(() => Buffer.alloc(32, 'k')),
+  createCipheriv: jest.fn(),
+  createDecipheriv: jest.fn()
+};
+const mockOs = {
+  hostname: jest.fn(() => 'test-host'),
+  homedir: jest.fn(() => '/home/test'),
+  userInfo: jest.fn(() => ({ username: 'testuser' }))
+};
+
+jest.unstable_mockModule('fs', () => ({
+  promises: mockFs
+}));
+
+jest.unstable_mockModule('crypto', () => ({
+  default: mockCrypto,
+  ...mockCrypto
+}));
+
+jest.unstable_mockModule('os', () => ({
+  default: mockOs,
+  ...mockOs
+}));
+
+jest.unstable_mockModule('../../utilities/userDataDir.js', () => ({
+  getUserDataPaths: jest.fn(() => ({ settings: '/fake/settings', attachments: '/fake/attachments' })),
+  ensureUserDataDirs: jest.fn(async () => {})
+}));
+
+const { default: ApiKeyManager } = await import('../apiKeyManager.js');
+
+describe('ApiKeyManager', () => {
+  let manager;
+  let logger;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    logger = createMockLogger();
+    manager = new ApiKeyManager(logger);
+  });
+
+  test('constructor initializes with empty keys', () => {
+    expect(manager.keys.loxiaApiKey).toBeNull();
+    expect(manager.keys.vendorKeys).toEqual({});
+    expect(manager.initialized).toBe(false);
+  });
+
+  test('initialize sets up persistence and loads keys', async () => {
+    // Mock salt file read failure (new salt generation)
+    mockFs.readFile.mockRejectedValueOnce(new Error('ENOENT'));
+    // Mock writeFile for salt
+    mockFs.writeFile.mockResolvedValue(undefined);
+    // Mock readFile for loadFromDisk - ENOENT (no existing keys)
+    const enoent = new Error('No file');
+    enoent.code = 'ENOENT';
+    mockFs.readFile.mockRejectedValueOnce(enoent);
+
+    await manager.initialize();
+    expect(manager.initialized).toBe(true);
+    expect(manager.persistenceFile).toContain('api-keys.enc');
+  });
+
+  test('initialize only runs once', async () => {
+    manager.initialized = true;
+    await manager.initialize();
+    // Should not call ensureUserDataDirs if already initialized
+    expect(logger.info).not.toHaveBeenCalled();
+  });
+
+  test('initialize handles errors gracefully', async () => {
+    const { ensureUserDataDirs } = await import('../../utilities/userDataDir.js');
+    ensureUserDataDirs.mockRejectedValueOnce(new Error('disk full'));
+
+    await manager.initialize();
+    expect(logger.warn).toHaveBeenCalled();
+  });
+
+  test('_getMachineIdentifier returns colon-separated string', () => {
+    const id = manager._getMachineIdentifier();
+    expect(id).toContain('test-host');
+    expect(id).toContain('testuser');
+    expect(id).toContain('loxia-api-key-encryption-v1');
+  });
+
+  test('_encrypt throws when no encryption key', () => {
+    expect(() => manager._encrypt('test')).toThrow('Encryption key not initialized');
+  });
+
+  test('_decrypt throws when no encryption key', () => {
+    expect(() => manager._decrypt('test')).toThrow('Encryption key not initialized');
+  });
+
+  test('setSessionKeys stores loxia key and vendor keys', async () => {
+    manager.persistenceFile = null; // skip persist
+    await manager.setSessionKeys('sess-1', {
+      loxiaApiKey: 'loxia-key-123',
+      vendorKeys: { anthropic: 'anth-key' }
+    });
+    expect(manager.keys.loxiaApiKey).toBe('loxia-key-123');
+    expect(manager.keys.vendorKeys.anthropic).toBe('anth-key');
+  });
+
+  test('setSessionKeys merges vendor keys', async () => {
+    manager.persistenceFile = null;
+    manager.keys.vendorKeys = { openai: 'oai-key' };
+    await manager.setSessionKeys('sess-1', {
+      vendorKeys: { anthropic: 'anth-key' }
+    });
+    expect(manager.keys.vendorKeys.openai).toBe('oai-key');
+    expect(manager.keys.vendorKeys.anthropic).toBe('anth-key');
+  });
+
+  test('getSessionKeys returns keys regardless of sessionId', () => {
+    manager.keys.loxiaApiKey = 'test-key';
+    const keys = manager.getSessionKeys('any-session');
+    expect(keys.loxiaApiKey).toBe('test-key');
+  });
+
+  test('getKeysForRequest returns loxia key for platform-provided', () => {
+    manager.keys.loxiaApiKey = 'loxia-123';
+    const result = manager.getKeysForRequest('sess', { platformProvided: true, vendor: 'anthropic' });
+    expect(result.loxiaApiKey).toBe('loxia-123');
+    expect(result.vendorApiKey).toBeNull();
+  });
+
+  test('getKeysForRequest returns vendor key for direct access', () => {
+    manager.keys.loxiaApiKey = 'loxia-123';
+    manager.keys.vendorKeys = { anthropic: 'anth-key' };
+    const result = manager.getKeysForRequest('sess', { platformProvided: false, vendor: 'anthropic' });
+    expect(result.loxiaApiKey).toBe('loxia-123');
+    expect(result.vendorApiKey).toBe('anth-key');
+  });
+
+  test('getKeysForRequest returns null vendor key when no vendor specified', () => {
+    const result = manager.getKeysForRequest('sess', {});
+    expect(result.vendorApiKey).toBeNull();
+  });
+
+  test('removeSessionKeys clears all keys and returns true if had keys', async () => {
+    manager.persistenceFile = null;
+    manager.keys.loxiaApiKey = 'some-key';
+    const hadKeys = await manager.removeSessionKeys('sess');
+    expect(hadKeys).toBe(true);
+    expect(manager.keys.loxiaApiKey).toBeNull();
+    expect(manager.keys.vendorKeys).toEqual({});
+  });
+
+  test('removeSessionKeys returns false if no keys existed', async () => {
+    const hadKeys = await manager.removeSessionKeys('sess');
+    expect(hadKeys).toBe(false);
+  });
+
+  test('setGlobalKeys delegates to setSessionKeys', async () => {
+    manager.persistenceFile = null;
+    await manager.setGlobalKeys({ loxiaApiKey: 'global-key' });
+    expect(manager.keys.loxiaApiKey).toBe('global-key');
+  });
+
+  test('getActiveSessions returns empty array', () => {
+    expect(manager.getActiveSessions()).toEqual([]);
+  });
+
+  test('cleanupExpiredSessions returns 0', () => {
+    expect(manager.cleanupExpiredSessions()).toBe(0);
+  });
+
+  test('persist does nothing when not initialized', async () => {
+    manager.persistenceFile = null;
+    await manager.persist();
+    expect(mockFs.writeFile).not.toHaveBeenCalled();
+  });
+
+  test('loadFromDisk does nothing when not initialized', async () => {
+    manager.persistenceFile = null;
+    await manager.loadFromDisk();
+    // No errors expected
+  });
+
+  test('loadFromDisk handles ENOENT gracefully', async () => {
+    manager.persistenceFile = '/fake/file';
+    manager.encryptionKey = Buffer.alloc(32);
+    const err = new Error('not found');
+    err.code = 'ENOENT';
+    mockFs.readFile.mockRejectedValueOnce(err);
+    await manager.loadFromDisk();
+    expect(logger.debug).toHaveBeenCalled();
+  });
+
+  test('loadFromDisk handles decrypt errors gracefully', async () => {
+    manager.persistenceFile = '/fake/file';
+    manager.encryptionKey = Buffer.alloc(32);
+    mockFs.readFile.mockRejectedValueOnce(new Error('bad data'));
+    await manager.loadFromDisk();
+    expect(logger.warn).toHaveBeenCalled();
+  });
+});