onbuzz 3.6.1 → 3.6.2

package/src/index.js

@@ -32,8 +32,6 @@ import { ToolsRegistry } from './tools/baseTool.js';
 import AgentDelayTool from './tools/agentDelayTool.js';
 import TerminalTool from './tools/terminalTool.js';
 import FileSystemTool from './tools/fileSystemTool.js';
-// BrowserTool is DEPRECATED - use WebTool instead
-// import BrowserTool from './tools/browserTool.js';
 import JobDoneTool from './tools/jobDoneTool.js';
 import AgentCommunicationTool from './tools/agentCommunicationTool.js';
 import TaskManagerTool from './tools/taskManagerTool.js';
@@ -486,11 +484,6 @@ class LoxiaApplication {
       this.logger.info('ToolsRegistry set for Help Tool');
     }
 
-    // NOTE: BrowserTool is DEPRECATED as of December 2024
-    // Use WebTool (toolId: "web") for all browser automation tasks
-    // The Browser tool registration has been removed - WebTool provides
-    // equivalent functionality with better architecture (singleton browser instance)
-    
     // Set AgentPool dependency for AgentDelayTool
     const agentDelayTool = this.toolsRegistry.getTool('agentdelay');
     if (agentDelayTool && typeof agentDelayTool.setAgentPool === 'function') {
@@ -848,9 +841,9 @@ class LoxiaApplication {
         this.logger?.info('Models service retries cancelled');
       }
 
-      // Close Puppeteer browsers (webTool, browserTool) — they hold DevTools ports
+      // Close Puppeteer browser (webTool) — it holds DevTools ports
       if (this.toolsRegistry) {
-        for (const toolId of ['web', 'browser']) {
+        for (const toolId of ['web']) {
           try {
             const tool = this.toolsRegistry.getTool(toolId);
             if (tool?.cleanup) {
@@ -863,6 +856,29 @@ class LoxiaApplication {
         }
       }
 
+      // Kill ALL running terminal processes across all agents
+      if (this.toolsRegistry) {
+        try {
+          const terminalTool = this.toolsRegistry.getTool('terminal');
+          if (terminalTool?.commandTracker) {
+            let killed = 0;
+            for (const [cmdId, cmdInfo] of terminalTool.commandTracker) {
+              if (cmdInfo.process && cmdInfo.state === 'RUNNING') {
+                try {
+                  cmdInfo.process.kill('SIGTERM');
+                  killed++;
+                } catch { /* already dead */ }
+              }
+            }
+            if (killed > 0) {
+              this.logger?.info(`Killed ${killed} running terminal process(es) on shutdown`);
+            }
+          }
+        } catch (error) {
+          this.logger?.warn('Failed to cleanup terminal processes', { error: error.message });
+        }
+      }
+
       // Shutdown interfaces (web server, visual editor, WS connections)
       for (const [type, interface_] of this.interfaces) {
         try {

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/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();
+  });
+});