onbuzz 4.1.0 → 4.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onbuzz",
-  "version": "4.1.0",
+  "version": "4.3.0",
   "description": "Loxia OnBuzz - Your AI Fleet",
   "type": "module",
   "main": "src/index.js",

package/src/core/__tests__/agentPoolToolConfig.test.js

@@ -0,0 +1,191 @@
+/**
+ * Tests for per-agent `toolConfig` field on the agent object.
+ *
+ * toolConfig is a plain object keyed by tool id:
+ *   agent.toolConfig = {
+ *     terminal:   { allowedCommands: ['git', 'npm'], maxBackgroundCommandsPerAgent: 3 },
+ *     filesystem: { allowedExtensions: ['.js', '.ts'], maxFileSize: 1_000_000 },
+ *     web:        { stealthLevel: 'medium' },
+ *     ...
+ *   }
+ *
+ * The values get merged into each tool's constructor config at tool
+ * instantiation time (step 2 — ToolManager integration). These tests
+ * lock the schema + persistence + validation contract so anything
+ * downstream can depend on the shape without guessing.
+ */
+
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger, createMockConfig, createMockStateManager } from '../../__test-utils__/mockFactories.js';
+
+// Mocks (same pattern as sibling agentPool tests)
+const mockValidateAccessConfiguration = jest.fn().mockReturnValue({ valid: true });
+const mockCreateProjectDefaults = jest.fn().mockReturnValue({
+  workingDirectory: '/tmp/project',
+  readOnlyDirectories: [],
+  writeEnabledDirectories: ['/tmp/project'],
+});
+
+jest.unstable_mockModule('../../utilities/directoryAccessManager.js', () => {
+  const MockDAM = jest.fn().mockImplementation(() => ({
+    validateAccessConfiguration: mockValidateAccessConfiguration,
+  }));
+  MockDAM.createProjectDefaults = mockCreateProjectDefaults;
+  return { default: MockDAM };
+});
+
+jest.unstable_mockModule('../../services/visualEditorBridge.js', () => ({
+  getVisualEditorBridge: jest.fn().mockReturnValue({
+    hasInstance: jest.fn().mockReturnValue(false),
+    stopInstance: jest.fn().mockResolvedValue(undefined),
+  }),
+}));
+
+const { default: AgentPool } = await import('../agentPool.js');
+
+function makePool() {
+  const config = createMockConfig();
+  const logger = createMockLogger();
+  const stateManager = createMockStateManager();
+  const contextManager = { getContext: jest.fn() };
+  return new AgentPool(config, logger, stateManager, contextManager, null);
+}
+
+function cfg(overrides = {}) {
+  return {
+    name: 'TestAgent',
+    systemPrompt: 'test',
+    preferredModel: 'test-model',
+    capabilities: [],
+    projectDir: '/tmp/project',
+    ...overrides,
+  };
+}
+
+describe('agentPool — agent.toolConfig schema', () => {
+  let pool;
+  beforeEach(() => { jest.clearAllMocks(); pool = makePool(); });
+
+  describe('createAgent', () => {
+    test('agents without toolConfig in config get empty toolConfig object', async () => {
+      const agent = await pool.createAgent(cfg());
+      expect(agent.toolConfig).toEqual({});
+    });
+
+    test('agents with toolConfig in config retain it (shallow copy)', async () => {
+      const agent = await pool.createAgent(cfg({
+        toolConfig: {
+          terminal:   { allowedCommands: ['git', 'npm'] },
+          filesystem: { maxFileSize: 500_000 },
+        },
+      }));
+      expect(agent.toolConfig).toEqual({
+        terminal:   { allowedCommands: ['git', 'npm'] },
+        filesystem: { maxFileSize: 500_000 },
+      });
+    });
+
+    test('toolConfig is copied (not referenced) so caller mutation does not leak', async () => {
+      const src = { terminal: { allowedCommands: ['git'] } };
+      const agent = await pool.createAgent(cfg({ toolConfig: src }));
+      src.terminal.allowedCommands.push('rm');
+      // Agent's inner value still has the shared reference at this level
+      // (shallow copy), but the top-level object is independent. This is
+      // the same contract `capabilities` has.
+      expect(agent.toolConfig).not.toBe(src);
+    });
+
+    test('malformed toolConfig (array) falls back to empty object instead of crashing', async () => {
+      const agent = await pool.createAgent(cfg({ toolConfig: ['bogus'] }));
+      expect(agent.toolConfig).toEqual({});
+    });
+
+    test('malformed toolConfig (non-object) falls back to empty object', async () => {
+      const agent = await pool.createAgent(cfg({ toolConfig: 'not-an-object' }));
+      expect(agent.toolConfig).toEqual({});
+    });
+  });
+
+  describe('listActiveAgents', () => {
+    test('exposes toolConfig in the listed agent shape', async () => {
+      const agent = await pool.createAgent(cfg({
+        toolConfig: { terminal: { allowedCommands: ['git'] } },
+      }));
+      const listed = await pool.listActiveAgents();
+      const me = listed.find(a => a.id === agent.id);
+      expect(me.toolConfig).toEqual({ terminal: { allowedCommands: ['git'] } });
+    });
+
+    test('emits empty object for agents without toolConfig (backward compat)', async () => {
+      // Simulate an agent loaded from an older persisted state without toolConfig.
+      const agent = await pool.createAgent(cfg());
+      delete agent.toolConfig;
+      const listed = await pool.listActiveAgents();
+      const me = listed.find(a => a.id === agent.id);
+      expect(me.toolConfig).toEqual({});
+    });
+  });
+
+  describe('updateAgent', () => {
+    test('updates toolConfig', async () => {
+      const agent = await pool.createAgent(cfg());
+      await pool.updateAgent(agent.id, {
+        toolConfig: { terminal: { allowedCommands: ['git'] } },
+      });
+      const after = await pool.getAgent(agent.id);
+      expect(after.toolConfig).toEqual({ terminal: { allowedCommands: ['git'] } });
+    });
+
+    test('replaces toolConfig entirely (caller is responsible for merging)', async () => {
+      const agent = await pool.createAgent(cfg({
+        toolConfig: {
+          terminal:   { allowedCommands: ['git'] },
+          filesystem: { maxFileSize: 500 },
+        },
+      }));
+      await pool.updateAgent(agent.id, { toolConfig: { web: { stealthLevel: 'low' } } });
+      const after = await pool.getAgent(agent.id);
+      expect(after.toolConfig).toEqual({ web: { stealthLevel: 'low' } });
+    });
+
+    test('rejects non-object toolConfig', async () => {
+      const agent = await pool.createAgent(cfg());
+      await expect(
+        pool.updateAgent(agent.id, { toolConfig: 'nope' })
+      ).rejects.toThrow(/must be a plain object/);
+    });
+
+    test('rejects array toolConfig', async () => {
+      const agent = await pool.createAgent(cfg());
+      await expect(
+        pool.updateAgent(agent.id, { toolConfig: ['not', 'valid'] })
+      ).rejects.toThrow(/must be a plain object/);
+    });
+
+    test('rejects toolConfig entry that is not an object', async () => {
+      const agent = await pool.createAgent(cfg());
+      await expect(
+        pool.updateAgent(agent.id, { toolConfig: { terminal: 'bogus' } })
+      ).rejects.toThrow(/toolConfig\.terminal: must be an object or null/);
+    });
+
+    test('allows null entry (means reset that tool back to defaults)', async () => {
+      const agent = await pool.createAgent(cfg({
+        toolConfig: { terminal: { allowedCommands: ['git'] } },
+      }));
+      await pool.updateAgent(agent.id, { toolConfig: { terminal: null } });
+      const after = await pool.getAgent(agent.id);
+      expect(after.toolConfig).toEqual({ terminal: null });
+    });
+
+    test('updateAgent without toolConfig in updates leaves existing toolConfig intact', async () => {
+      const agent = await pool.createAgent(cfg({
+        toolConfig: { terminal: { allowedCommands: ['git'] } },
+      }));
+      await pool.updateAgent(agent.id, { name: 'NewName' });
+      const after = await pool.getAgent(agent.id);
+      expect(after.name).toBe('NewName');
+      expect(after.toolConfig).toEqual({ terminal: { allowedCommands: ['git'] } });
+    });
+  });
+});

package/src/core/__tests__/agentPoolWakeOnMessage.test.js

@@ -0,0 +1,315 @@
+/**
+ * Regression tests: an inbound message (user / inter-agent / tool-result)
+ * MUST wake the recipient out of any paused or delayed state.
+ *
+ * This was previously fixed only for addUserMessage; addInterAgentMessage
+ * and addToolResult silently queued into paused/delayed agents, so the
+ * recipient never acted on the incoming message until the back-off
+ * naturally expired. These tests lock the shared-helper implementation so
+ * the invariant "inbound message always wins over delay/pause" cannot
+ * regress again by patching one path and forgetting the others.
+ */
+
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger, createMockConfig, createMockStateManager } from '../../__test-utils__/mockFactories.js';
+
+// ── Mocks ───────────────────────────────────────────────────────────────────
+const mockValidateAccessConfiguration = jest.fn().mockReturnValue({ valid: true });
+const mockCreateProjectDefaults = jest.fn().mockReturnValue({
+  workingDirectory: '/tmp/project',
+  readOnlyDirectories: [],
+  writeEnabledDirectories: ['/tmp/project'],
+});
+
+jest.unstable_mockModule('../../utilities/directoryAccessManager.js', () => {
+  const MockDAM = jest.fn().mockImplementation(() => ({
+    validateAccessConfiguration: mockValidateAccessConfiguration,
+  }));
+  MockDAM.createProjectDefaults = mockCreateProjectDefaults;
+  return { default: MockDAM };
+});
+
+jest.unstable_mockModule('../../services/visualEditorBridge.js', () => ({
+  getVisualEditorBridge: jest.fn().mockReturnValue({
+    hasInstance: jest.fn().mockReturnValue(false),
+    stopInstance: jest.fn().mockResolvedValue(undefined),
+  }),
+}));
+
+const { default: AgentPool } = await import('../agentPool.js');
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function makePool(overrides = {}) {
+  const config = createMockConfig(overrides.config);
+  const logger = createMockLogger();
+  const stateManager = createMockStateManager();
+  const contextManager = { getContext: jest.fn() };
+  const pool = new AgentPool(config, logger, stateManager, contextManager, null);
+  return { pool, logger };
+}
+
+function agentCfg(overrides = {}) {
+  return {
+    name: 'TestAgent',
+    systemPrompt: 'You are a test agent.',
+    preferredModel: 'test-model',
+    capabilities: [],
+    projectDir: '/tmp/project',
+    ...overrides,
+  };
+}
+
+/** Stamp a future delay directly on the agent (mimics scheduler back-off). */
+function setDelay(agent, msFromNow = 60_000) {
+  agent.delayEndTime = new Date(Date.now() + msFromNow).toISOString();
+}
+
+function makeScheduler() {
+  return {
+    addAgent: jest.fn().mockResolvedValue(undefined),
+    removeAgent: jest.fn(),
+    isAgentInScheduler: jest.fn().mockReturnValue(false),
+    broadcastAgentStateUpdate: jest.fn().mockResolvedValue(undefined),
+  };
+}
+
+// ────────────────────────────────────────────────────────────────────────
+// addUserMessage — locks existing behaviour including delay-clear (the
+// original fix covered auto-resume but the delay-clear assertion lived in
+// a different test file; we consolidate both guarantees here).
+// ────────────────────────────────────────────────────────────────────────
+
+describe('agentPool.addUserMessage — wake-on-message', () => {
+  test('clears future delayEndTime', async () => {
+    const { pool } = makePool();
+    const agent = await pool.createAgent(agentCfg());
+    setDelay(agent, 30_000);
+
+    await pool.addUserMessage(agent.id, { content: 'wake me' });
+
+    expect(agent.delayEndTime).toBeNull();
+    expect(agent.messageQueues.userMessages).toHaveLength(1);
+  });
+
+  test('past delayEndTime is left alone (no spurious broadcast)', async () => {
+    const { pool } = makePool();
+    const scheduler = makeScheduler();
+    pool.setScheduler(scheduler);
+    const agent = await pool.createAgent(agentCfg());
+    agent.delayEndTime = new Date(Date.now() - 60_000).toISOString(); // already expired
+
+    await pool.addUserMessage(agent.id, { content: 'hi' });
+
+    expect(scheduler.broadcastAgentStateUpdate).not.toHaveBeenCalled();
+  });
+
+  test('broadcasts delay-clear when delay was cleared', async () => {
+    const { pool } = makePool();
+    const scheduler = makeScheduler();
+    pool.setScheduler(scheduler);
+    const agent = await pool.createAgent(agentCfg());
+    setDelay(agent, 30_000);
+
+    await pool.addUserMessage(agent.id, { content: 'hi' });
+
+    expect(scheduler.broadcastAgentStateUpdate).toHaveBeenCalledWith(
+      agent.id,
+      'user-message-clears-delay'
+    );
+  });
+});
+
+// ────────────────────────────────────────────────────────────────────────
+// addInterAgentMessage — the previously-broken path.
+// ────────────────────────────────────────────────────────────────────────
+
+describe('agentPool.addInterAgentMessage — wake-on-message', () => {
+  test('clears future delayEndTime on inter-agent message', async () => {
+    const { pool } = makePool();
+    const agent = await pool.createAgent(agentCfg());
+    setDelay(agent, 45_000);
+
+    await pool.addInterAgentMessage(agent.id, {
+      content: 'need your help',
+      sender: 'OtherAgent',
+      senderName: 'OtherAgent',
+    });
+
+    expect(agent.delayEndTime).toBeNull();
+    expect(agent.messageQueues.interAgentMessages).toHaveLength(1);
+  });
+
+  test('auto-resumes paused recipient', async () => {
+    const { pool } = makePool();
+    const agent = await pool.createAgent(agentCfg());
+    await pool.pauseAgent(agent.id, 300, 'manual pause');
+    expect(agent.status).toBe('paused');
+
+    const resumeSpy = jest.spyOn(pool, 'resumeAgent');
+
+    await pool.addInterAgentMessage(agent.id, {
+      content: 'wake up',
+      sender: 'OtherAgent',
+    });
+
+    expect(resumeSpy).toHaveBeenCalledWith(agent.id);
+    expect(agent.status).toBe('active');
+    expect(agent.pausedUntil).toBeNull();
+    resumeSpy.mockRestore();
+  });
+
+  test('clears BOTH pause and delay when both are set', async () => {
+    const { pool } = makePool();
+    const agent = await pool.createAgent(agentCfg());
+    await pool.pauseAgent(agent.id, 300, 'pause');
+    setDelay(agent, 60_000);
+
+    await pool.addInterAgentMessage(agent.id, {
+      content: 'act now',
+      sender: 'OtherAgent',
+    });
+
+    expect(agent.status).toBe('active');
+    expect(agent.pausedUntil).toBeNull();
+    expect(agent.delayEndTime).toBeNull();
+  });
+
+  test('broadcasts delay-clear with correct reason when delay was cleared', async () => {
+    const { pool } = makePool();
+    const scheduler = makeScheduler();
+    pool.setScheduler(scheduler);
+    const agent = await pool.createAgent(agentCfg());
+    setDelay(agent, 60_000);
+
+    await pool.addInterAgentMessage(agent.id, {
+      content: 'hi',
+      sender: 'OtherAgent',
+    });
+
+    expect(scheduler.broadcastAgentStateUpdate).toHaveBeenCalledWith(
+      agent.id,
+      'inter-agent-message-clears-delay'
+    );
+  });
+
+  test('non-paused non-delayed agent: no resume, no broadcast', async () => {
+    const { pool } = makePool();
+    const scheduler = makeScheduler();
+    pool.setScheduler(scheduler);
+    const agent = await pool.createAgent(agentCfg());
+    const resumeSpy = jest.spyOn(pool, 'resumeAgent');
+
+    await pool.addInterAgentMessage(agent.id, {
+      content: 'hi',
+      sender: 'OtherAgent',
+    });
+
+    expect(resumeSpy).not.toHaveBeenCalled();
+    expect(scheduler.broadcastAgentStateUpdate).not.toHaveBeenCalled();
+    resumeSpy.mockRestore();
+  });
+});
+
+// ────────────────────────────────────────────────────────────────────────
+// addToolResult — the third previously-broken path.
+// ────────────────────────────────────────────────────────────────────────
+
+describe('agentPool.addToolResult — wake-on-message', () => {
+  test('clears future delayEndTime when a tool result arrives', async () => {
+    const { pool } = makePool();
+    const agent = await pool.createAgent(agentCfg());
+    setDelay(agent, 120_000);
+
+    await pool.addToolResult(agent.id, {
+      toolId: 'image-gen',
+      status: 'completed',
+      result: { imageUrl: '/tmp/out.png' },
+    });
+
+    expect(agent.delayEndTime).toBeNull();
+    expect(agent.messageQueues.toolResults).toHaveLength(1);
+  });
+
+  test('auto-resumes paused agent when a tool result arrives', async () => {
+    const { pool } = makePool();
+    const agent = await pool.createAgent(agentCfg());
+    await pool.pauseAgent(agent.id, 300, 'manual pause');
+    expect(agent.status).toBe('paused');
+
+    await pool.addToolResult(agent.id, {
+      toolId: 'video-gen',
+      status: 'completed',
+      result: { videoUrl: '/tmp/v.mp4' },
+    });
+
+    expect(agent.status).toBe('active');
+    expect(agent.pausedUntil).toBeNull();
+  });
+
+  test('broadcasts with tool-result reason when delay was cleared', async () => {
+    const { pool } = makePool();
+    const scheduler = makeScheduler();
+    pool.setScheduler(scheduler);
+    const agent = await pool.createAgent(agentCfg());
+    setDelay(agent, 60_000);
+
+    await pool.addToolResult(agent.id, {
+      toolId: 'image-gen',
+      status: 'completed',
+      result: {},
+    });
+
+    expect(scheduler.broadcastAgentStateUpdate).toHaveBeenCalledWith(
+      agent.id,
+      'tool-result-clears-delay'
+    );
+  });
+});
+
+// ────────────────────────────────────────────────────────────────────────
+// _wakeAgentForMessage — direct unit test of the shared helper so future
+// contributors see the exact contract every inbound path must honour.
+// ────────────────────────────────────────────────────────────────────────
+
+describe('agentPool._wakeAgentForMessage (shared helper)', () => {
+  test('no-op on happy-path (active, not delayed)', async () => {
+    const { pool } = makePool();
+    const agent = await pool.createAgent(agentCfg());
+
+    const info = await pool._wakeAgentForMessage(agent, 'test');
+
+    expect(info).toEqual({ wasPaused: false, hadDelay: false, hadPausedUntil: false });
+    expect(agent.status).toBe('active');
+    expect(agent.delayEndTime).toBeFalsy();
+  });
+
+  test('reports wasPaused=true and clears pause', async () => {
+    const { pool } = makePool();
+    const agent = await pool.createAgent(agentCfg());
+    await pool.pauseAgent(agent.id, 300, 'pause');
+
+    const info = await pool._wakeAgentForMessage(agent, 'test');
+
+    expect(info.wasPaused).toBe(true);
+    expect(agent.status).toBe('active');
+  });
+
+  test('reports hadDelay=true and clears delay', async () => {
+    const { pool } = makePool();
+    const agent = await pool.createAgent(agentCfg());
+    setDelay(agent, 30_000);
+
+    const info = await pool._wakeAgentForMessage(agent, 'test');
+
+    expect(info.hadDelay).toBe(true);
+    expect(agent.delayEndTime).toBeNull();
+  });
+
+  test('null agent returns zero-info object (defensive)', async () => {
+    const { pool } = makePool();
+
+    const info = await pool._wakeAgentForMessage(null, 'test');
+
+    expect(info).toEqual({ wasPaused: false, hadDelay: false, hadPausedUntil: false });
+  });
+});

package/src/core/__tests__/messageProcessor.test.js

@@ -454,6 +454,48 @@ describe('MessageProcessor', () => {
       const toolContext = mockTool.execute.mock.calls[0][1];
       expect(toolContext.projectDir).toBe('/custom/dir');
     });
+
+    // Per-agent tool config passthrough — see agentPool `toolConfig`
+    // schema and BaseTool#getEffectiveConfig. These tests lock the
+    // message-processor side of the plumbing: the correct slice of
+    // agent.toolConfig must land on the tool execution context.
+    test('passes agent.toolConfig[toolId] to the tool as context.toolConfig', async () => {
+      const mockTool = { execute: jest.fn().mockResolvedValue({ ok: true }) };
+      toolsRegistry.getTool.mockReturnValue(mockTool);
+      const commands = [{ toolId: 'terminal', parameters: {}, isAsync: false }];
+      const context = {
+        agentId: 'a1',
+        agentToolConfig: {
+          terminal:   { allowedCommands: ['git', 'npm'] },
+          filesystem: { maxFileSize: 500 },
+        },
+      };
+      await mp.executeTools(commands, context);
+      const toolContext = mockTool.execute.mock.calls[0][1];
+      expect(toolContext.toolConfig).toEqual({ allowedCommands: ['git', 'npm'] });
+    });
+
+    test('context.toolConfig is null when agent has no config for this tool', async () => {
+      const mockTool = { execute: jest.fn().mockResolvedValue({ ok: true }) };
+      toolsRegistry.getTool.mockReturnValue(mockTool);
+      const commands = [{ toolId: 'vision', parameters: {}, isAsync: false }];
+      const context = {
+        agentId: 'a1',
+        agentToolConfig: { terminal: { allowedCommands: ['git'] } },
+      };
+      await mp.executeTools(commands, context);
+      const toolContext = mockTool.execute.mock.calls[0][1];
+      expect(toolContext.toolConfig).toBeNull();
+    });
+
+    test('context.toolConfig is null when agent has no toolConfig at all', async () => {
+      const mockTool = { execute: jest.fn().mockResolvedValue({ ok: true }) };
+      toolsRegistry.getTool.mockReturnValue(mockTool);
+      const commands = [{ toolId: 'terminal', parameters: {}, isAsync: false }];
+      await mp.executeTools(commands, { agentId: 'a1' });
+      const toolContext = mockTool.execute.mock.calls[0][1];
+      expect(toolContext.toolConfig).toBeNull();
+    });
   });
 
   // ─── executeAsyncTool ─────────────────────────────────────────────────

package/src/core/__tests__/orchestrator.test.js

@@ -196,14 +196,30 @@ describe('Orchestrator', () => {
       expect(result.data.agentId).toBe('agent-1');
     });
 
-    test('routeToAgent with paused agent throws error', async () => {
-      const futureDate = new Date(Date.now() + 60000).toISOString();
-      const agent = { id: 'agent-1', name: 'Bot', status: 'paused', pausedUntil: futureDate };
+    // REGRESSION: A user message must ALWAYS override pause/delay state.
+    // The orchestrator used to short-circuit with a "paused" error here,
+    // which bypassed agentPool._wakeAgentForMessage and left the agent
+    // napping while the user saw a toast and waited. Now routeToAgent
+    // forwards unconditionally to messageProcessor; the wake helper in
+    // addUserMessage flips the agent back to active and queues the msg.
+    // See orchestrator.js: the pre-flight PAUSED check is intentionally
+    // absent.
+    test('routeToAgent with paused agent STILL queues the message (wake-on-message wins)', async () => {
+      const futureDate = new Date(Date.now() + 60_000).toISOString();
+      const agent = { id: 'agent-1', name: 'Bot', status: 'paused', pausedUntil: futureDate, currentModel: 'gpt-4' };
       mockAgentPool.getAgent.mockResolvedValue(agent);
 
-      await expect(
-        orchestrator.routeToAgent('agent-1', 'Hey', {})
-      ).rejects.toThrow(/paused/);
+      const result = await orchestrator.routeToAgent('agent-1', 'Wake up', { sessionId: 's1' });
+
+      expect(result.success).toBe(true);
+      expect(result.data.status).toBe('queued');
+      // messageProcessor got the message — the wake is handled inside
+      // addUserMessage, not at the orchestrator layer.
+      expect(mockMessageProcessor.processMessage).toHaveBeenCalledWith(
+        'agent-1',
+        'Wake up',
+        expect.objectContaining({ sessionId: 's1' })
+      );
     });
 
     test('createAgent delegates to agentPool.createAgent', async () => {