onbuzz 4.1.0 → 4.2.0

package/src/tools/__tests__/filesystemTool.test.js

@@ -81,6 +81,15 @@ jest.unstable_mockModule('../baseTool.js', () => ({
       this.lastUsed = null;
       this.usageCount = 0;
     }
+    // Mirror real BaseTool#getEffectiveConfig so the per-agent config gate
+    // in fileSystemTool.execute() works under test. Real helper lives in
+    // src/tools/baseTool.js — change in lockstep if you touch it.
+    getEffectiveConfig(context, fallbacks = {}) {
+      const perAgent = (context && context.toolConfig && typeof context.toolConfig === 'object' && !Array.isArray(context.toolConfig))
+        ? context.toolConfig
+        : {};
+      return { ...fallbacks, ...(this.config || {}), ...perAgent };
+    }
   }
 }));
 
@@ -714,4 +723,93 @@ describe('FileSystemTool', () => {
       expect(actions).toContain('stats');
     });
   });
+
+  // Per-agent overrides via context.toolConfig (agent.toolConfig.filesystem)
+  // — merged into effective config by BaseTool#getEffectiveConfig at
+  // execute time, then applied as a per-action gate above the existing
+  // path-access and size checks.
+  describe('per-agent toolConfig overrides', () => {
+    test('per-agent blockedExtensions blocks a previously-allowed extension', async () => {
+      const { tool, context } = createTestSetup();
+      const result = await tool.execute(
+        { actions: [{ type: 'read', filePath: '/tmp/test/secret.env' }] },
+        { ...context, toolConfig: { blockedExtensions: ['.env'] } }
+      );
+      expect(result.actions[0].success).toBe(false);
+      expect(result.actions[0].error).toMatch(/blocked by agent policy/);
+      // No actual read attempted.
+      expect(fsMock.readFile).not.toHaveBeenCalled();
+    });
+
+    test('per-agent allowedExtensions rejects anything outside the list', async () => {
+      const { tool, context } = createTestSetup();
+      const result = await tool.execute(
+        { actions: [{ type: 'read', filePath: '/tmp/test/app.js' }] },
+        { ...context, toolConfig: { allowedExtensions: ['.ts'] } }
+      );
+      expect(result.actions[0].success).toBe(false);
+      expect(result.actions[0].error).toMatch(/not in the agent's allowed list/);
+      expect(fsMock.readFile).not.toHaveBeenCalled();
+    });
+
+    test('per-agent allowedExtensions accepts matches', async () => {
+      const { tool, context } = createTestSetup();
+      const result = await tool.execute(
+        { actions: [{ type: 'read', filePath: '/tmp/test/app.js' }] },
+        { ...context, toolConfig: { allowedExtensions: ['.js'] } }
+      );
+      expect(result.actions[0].success).toBe(true);
+    });
+
+    test('per-agent maxFileSize rejects oversized write payload', async () => {
+      const { tool, context } = createTestSetup();
+      const bigContent = 'x'.repeat(500);
+      const result = await tool.execute(
+        {
+          actions: [{ type: 'write', outputPath: 'big.txt', content: bigContent }],
+        },
+        { ...context, toolConfig: { maxFileSize: 100 } }
+      );
+      expect(result.actions[0].success).toBe(false);
+      expect(result.actions[0].error).toMatch(/too large/);
+      expect(result.actions[0].error).toMatch(/per-agent maxFileSize/);
+      expect(fsMock.writeFile).not.toHaveBeenCalled();
+    });
+
+    test('per-agent maxFileSize accepts payloads within limit', async () => {
+      const { tool, context } = createTestSetup();
+      const content = 'hello';
+      // Mirror the mock setup used by the existing write tests so the
+      // verify-after-write step finds the file with matching size.
+      fsMock.access.mockRejectedValueOnce(new Error('ENOENT'));
+      fsMock.stat.mockResolvedValue(mockStatResult({ size: Buffer.byteLength(content) }));
+      fsMock.readFile.mockResolvedValue(content);
+
+      const result = await tool.execute(
+        { actions: [{ type: 'write', outputPath: 'ok.txt', content }] },
+        { ...context, toolConfig: { maxFileSize: 1_000_000 } }
+      );
+      expect(result.actions[0].success).toBe(true);
+      expect(fsMock.writeFile).toHaveBeenCalled();
+    });
+
+    test('blocked wins over allowed when both set', async () => {
+      const { tool, context } = createTestSetup();
+      const result = await tool.execute(
+        { actions: [{ type: 'read', filePath: '/tmp/test/app.js' }] },
+        { ...context, toolConfig: { allowedExtensions: ['.js'], blockedExtensions: ['.js'] } }
+      );
+      expect(result.actions[0].success).toBe(false);
+      expect(result.actions[0].error).toMatch(/blocked by agent policy/);
+    });
+
+    test('no toolConfig → original behaviour preserved', async () => {
+      const { tool, context } = createTestSetup();
+      const result = await tool.execute(
+        { actions: [{ type: 'read', filePath: '/tmp/test/app.js' }] },
+        context
+      );
+      expect(result.actions[0].success).toBe(true);
+    });
+  });
 });

package/src/tools/__tests__/memoryTool.reminisce.test.js

@@ -153,6 +153,39 @@ describe('memoryTool reminisce — wiring', () => {
     expect(out.result.targetFound).toBe(false);
     expect(out.result.message).toBeNull();
   });
+
+  test('read surfaces hasReasoning + reasoningTokens but omits text by default', async () => {
+    const localMessages = makeMessages(20);
+    localMessages[5] = {
+      ...localMessages[5],
+      reasoning: 'Chain of thought: first I need to analyze...',
+      reasoningTokens: 512,
+    };
+    const local = makeSetup({ messages: localMessages });
+    const out = await local.tool.execute(
+      { action: 'reminisce', mode: 'read', messageId: 'msg_0005' },
+      local.context
+    );
+    expect(out.result.message.hasReasoning).toBe(true);
+    expect(out.result.message.reasoningTokens).toBe(512);
+    expect(out.result.message.reasoning).toBeUndefined();
+  });
+
+  test('read with includeReasoning=true returns the reasoning text', async () => {
+    const localMessages = makeMessages(20);
+    const thought = 'Step 1: analyze. Step 2: decide. Step 3: act.';
+    localMessages[5] = {
+      ...localMessages[5],
+      reasoning: thought,
+      reasoningTokens: 200,
+    };
+    const local = makeSetup({ messages: localMessages });
+    const out = await local.tool.execute(
+      { action: 'reminisce', mode: 'read', messageId: 'msg_0005', includeReasoning: true },
+      local.context
+    );
+    expect(out.result.message.reasoning).toBe(thought);
+  });
 });
 
 describe('memoryTool reminisce — error paths', () => {

package/src/tools/__tests__/terminalTool.test.js

@@ -212,6 +212,70 @@ describe('TerminalTool', () => {
     expect(tool.isBlockedCommand('Format')).toBe(true);
   });
 
+  // Per-agent config overrides (agent.toolConfig.terminal). These ride in
+  // via context.toolConfig in execute() — see BaseTool#getEffectiveConfig.
+  describe('per-agent toolConfig overrides', () => {
+    test('per-agent blockedCommands refuses a command that is globally allowed', async () => {
+      const result = await tool.execute(
+        { actions: [{ type: 'run-command', command: 'curl https://evil.example' }] },
+        { ...context, toolConfig: { blockedCommands: ['curl'] } }
+      );
+      expect(result.success).toBe(false);
+      expect(result.error).toMatch(/blocked by agent policy/);
+      // Must not execute the blocked command.
+      expect(mockExec).not.toHaveBeenCalled();
+    });
+
+    test('per-agent allowedCommands rejects anything not in the list', async () => {
+      const result = await tool.execute(
+        { actions: [{ type: 'run-command', command: 'npm install' }] },
+        { ...context, toolConfig: { allowedCommands: ['git'] } }
+      );
+      expect(result.success).toBe(false);
+      expect(result.error).toMatch(/not in the agent's allowed list/);
+      expect(mockExec).not.toHaveBeenCalled();
+    });
+
+    test('per-agent allowedCommands accepts matches (prefix ok)', async () => {
+      setupExecSuccess('main');
+      const result = await tool.execute(
+        { actions: [{ type: 'run-command', command: 'git status' }] },
+        { ...context, toolConfig: { allowedCommands: ['git'] } }
+      );
+      expect(result.success).toBe(true);
+      expect(mockExec).toHaveBeenCalled();
+    });
+
+    test('blocked wins over allowed when both set', async () => {
+      const result = await tool.execute(
+        { actions: [{ type: 'run-command', command: 'rm file.txt' }] },
+        { ...context, toolConfig: { allowedCommands: ['rm'], blockedCommands: ['rm'] } }
+      );
+      expect(result.success).toBe(false);
+      expect(result.error).toMatch(/blocked by agent policy/);
+    });
+
+    test('no toolConfig → global rules apply (unchanged behavior)', async () => {
+      setupExecSuccess('ok');
+      const result = await tool.execute(
+        { actions: [{ type: 'run-command', command: 'echo hi' }] },
+        context
+      );
+      expect(result.success).toBe(true);
+    });
+
+    test('empty allowedCommands array is treated as "any" (not "none")', async () => {
+      // Empty list means "no override" not "nothing allowed". Otherwise
+      // setting the override to [] would brick the agent.
+      setupExecSuccess('ok');
+      const result = await tool.execute(
+        { actions: [{ type: 'run-command', command: 'echo hi' }] },
+        { ...context, toolConfig: { allowedCommands: [] } }
+      );
+      expect(result.success).toBe(true);
+    });
+  });
+
   test('execute run-command returns stdout on success', async () => {
     setupExecSuccess('hello world');
 

package/src/tools/__tests__/webTool.perAgentConfig.test.js

@@ -0,0 +1,94 @@
+/**
+ * WebTool per-agent configuration tests.
+ *
+ * Covers the domain-allowlist / blocklist gate and the default
+ * stealthLevel fallback introduced by the per-agent toolConfig feature.
+ * Split from webTool.unit.test.js because that file is excluded from
+ * the default jest run (it pulls in heavier mocks). These tests
+ * short-circuit BEFORE the browser layer, so they don't need any of
+ * Puppeteer mocked.
+ */
+
+import { describe, test, expect, beforeEach } from '@jest/globals';
+
+let WebTool;
+
+beforeEach(async () => {
+  const mod = await import('../webTool.js');
+  WebTool = mod.default;
+});
+
+function makeTool() {
+  return new WebTool({ logger: { info() {}, warn() {}, error() {}, debug() {} } });
+}
+
+describe('WebTool per-agent toolConfig (domain gate)', () => {
+  test('fetch: blocked domain short-circuits with error', async () => {
+    const wt = makeTool();
+    const result = await wt.execute(
+      { operation: 'fetch', url: 'https://evil.example/page' },
+      { agentId: 'a', toolConfig: { blockedDomains: ['evil.example'] } }
+    );
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/blocked by agent policy/);
+    expect(result.operation).toBe('fetch');
+  });
+
+  test('fetch: subdomain match counts as blocked', async () => {
+    const wt = makeTool();
+    const result = await wt.execute(
+      { operation: 'fetch', url: 'https://ads.tracker.example/x' },
+      { agentId: 'a', toolConfig: { blockedDomains: ['tracker.example'] } }
+    );
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/blocked by agent policy/);
+  });
+
+  test('fetch: allowed domain whitelist rejects non-matching URL', async () => {
+    const wt = makeTool();
+    const result = await wt.execute(
+      { operation: 'fetch', url: 'https://other.example/x' },
+      { agentId: 'a', toolConfig: { allowedDomains: ['github.com'] } }
+    );
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/not in the agent's allowed domains/);
+  });
+
+  test('interactive: per-action navigate URLs are gated', async () => {
+    const wt = makeTool();
+    const result = await wt.execute(
+      {
+        operation: 'interactive',
+        actions: [{ type: 'navigate', url: 'https://blocked.example' }],
+      },
+      { agentId: 'a', toolConfig: { blockedDomains: ['blocked.example'] } }
+    );
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/blocked by agent policy/);
+  });
+
+  test('blocked wins over allowed', async () => {
+    const wt = makeTool();
+    const result = await wt.execute(
+      { operation: 'fetch', url: 'https://github.com/x' },
+      {
+        agentId: 'a',
+        toolConfig: {
+          allowedDomains: ['github.com'],
+          blockedDomains: ['github.com'],
+        },
+      }
+    );
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/blocked by agent policy/);
+  });
+
+  test('no toolConfig → vacuous interactive path still completes', async () => {
+    const wt = makeTool();
+    const result = await wt.execute(
+      { operation: 'interactive', actions: [] },
+      { agentId: 'a' }
+    );
+    expect(result.success).toBe(true);
+  });
+});

package/src/tools/agentCommunicationTool.js

@@ -37,6 +37,11 @@ class AgentCommunicationTool extends BaseTool {
     
     // Message storage - in production, this would be a database
     this.messages = new Map(); // messageId -> message object
+
+    // Shared helper for every check-point to resolve effective limits
+    // from global defaults + per-agent overrides (agent.toolConfig.agentcommunication).
+    // See BaseTool#getEffectiveConfig — per-agent fields win.
+    this._limits = (context) => this.getEffectiveConfig(context || {}, this.config);
     this.conversations = new Map(); // conversationId -> conversation metadata
     this.agentInboxes = new Map(); // agentId -> Set of messageIds
     this.agentConversations = new Map(); // agentId -> Set of conversationIds
@@ -347,11 +352,12 @@ LIMITS:
         throw new Error('At least one recipient is required');
       }
       
-      // Validate recipient count
-      if (recipientList.length > this.config.maxRecipientsPerMessage) {
-        throw new Error(`Maximum ${this.config.maxRecipientsPerMessage} recipients allowed`);
+      // Validate recipient count — effective limit from per-agent config.
+      const _sendLimits = this._limits(context);
+      if (recipientList.length > _sendLimits.maxRecipientsPerMessage) {
+        throw new Error(`Maximum ${_sendLimits.maxRecipientsPerMessage} recipients allowed`);
       }
-      
+
       // Get agent pool and sender agent
       const agentPool = context.agentPool;
       const senderAgent = await agentPool.getAgent(senderAgentId);
@@ -434,7 +440,7 @@ LIMITS:
       const senderName = senderAgent ? senderAgent.name : senderAgentId;
       
       // Process attachments if provided
-      const processedAttachments = await this._processAttachments(attachments, senderAgentId);
+      const processedAttachments = await this._processAttachments(attachments, senderAgentId, context);
       
       // Create message object
       const messageId = this._generateMessageId();
@@ -564,11 +570,12 @@ LIMITS:
       // Check conversation depth to prevent infinite loops
       const conversation = this.conversations.get(originalMessage.conversationId);
       const currentDepth = this._getConversationDepth(originalMessage.conversationId);
-      
-      if (currentDepth >= this.config.maxConversationDepth) {
+      const _replyLimits = this._limits(context);
+
+      if (currentDepth >= _replyLimits.maxConversationDepth) {
         return {
           success: false,
-          error: `Conversation depth limit reached (${this.config.maxConversationDepth}). Please start a new conversation.`,
+          error: `Conversation depth limit reached (${_replyLimits.maxConversationDepth}). Please start a new conversation.`,
           suggestion: 'Consider marking this conversation as ended and starting fresh if needed.'
         };
       }
@@ -589,9 +596,9 @@ LIMITS:
       // Remove sender from recipients
       replyRecipients = replyRecipients.filter(id => id !== senderAgentId);
       
-      // Validate recipient count
-      if (replyRecipients.length > this.config.maxRecipientsPerMessage) {
-        throw new Error(`Maximum ${this.config.maxRecipientsPerMessage} recipients allowed`);
+      // Validate recipient count — effective limit from per-agent config.
+      if (replyRecipients.length > _replyLimits.maxRecipientsPerMessage) {
+        throw new Error(`Maximum ${_replyLimits.maxRecipientsPerMessage} recipients allowed`);
       }
       
       // Get agent names
@@ -608,7 +615,7 @@ LIMITS:
       }
       
       // Process attachments
-      const processedAttachments = await this._processAttachments(attachments, senderAgentId);
+      const processedAttachments = await this._processAttachments(attachments, senderAgentId, context);
       
       // Create reply message
       const replyMessageId = this._generateMessageId();
@@ -861,9 +868,9 @@ LIMITS:
    * Process and validate attachments
    * @private
    */
-  async _processAttachments(attachments, agentId) {
+  async _processAttachments(attachments, agentId, context = {}) {
     if (!attachments) return [];
-    
+
     let attachmentList = [];
     if (typeof attachments === 'string') {
       try {
@@ -874,25 +881,29 @@ LIMITS:
     } else {
       attachmentList = attachments;
     }
-    
+
     if (!Array.isArray(attachmentList)) {
       attachmentList = [attachmentList];
     }
-    
+
+    // Effective limits merge global defaults with per-agent overrides.
+    // When context is missing (legacy callers), falls back to this.config.
+    const _attLimits = this._limits(context);
+
     // Validate attachment count
-    if (attachmentList.length > this.config.maxAttachmentsPerMessage) {
-      throw new Error(`Maximum ${this.config.maxAttachmentsPerMessage} attachments allowed`);
+    if (attachmentList.length > _attLimits.maxAttachmentsPerMessage) {
+      throw new Error(`Maximum ${_attLimits.maxAttachmentsPerMessage} attachments allowed`);
     }
-    
+
     const processedAttachments = [];
-    
+
     for (const attachment of attachmentList) {
       if (!attachment.path) continue;
-      
+
       try {
         // Check file exists and size
         const stats = await fs.stat(attachment.path);
-        if (stats.size > this.config.maxAttachmentSize) {
+        if (stats.size > _attLimits.maxAttachmentSize) {
           throw new Error(`Attachment exceeds size limit: ${attachment.path}`);
         }