onbuzz 4.1.0 → 4.3.0

package/src/tools/__tests__/videoTool.jobs.test.js

@@ -0,0 +1,147 @@
+/**
+ * Tests for VideoTool.getJobsSnapshot + cancelJob — the surface the
+ * web-UI's `/api/videos/jobs` routes consume. We construct a tool
+ * instance, hand-populate its queue/active/completed maps with the
+ * same shape the execute() path builds, and verify the snapshot.
+ */
+
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+
+// Mock the heavy helpers VideoTool pulls in so the import is cheap.
+jest.unstable_mockModule('fs', () => ({
+  default: { promises: {} },
+  promises: {},
+}));
+jest.unstable_mockModule('fs/promises', () => ({
+  default: {},
+}));
+jest.unstable_mockModule('axios', () => ({
+  default: { post: jest.fn(), get: jest.fn() },
+}));
+
+const { default: VideoTool } = await import('../videoTool.js');
+
+function makeTool() {
+  const tool = new VideoTool({});
+  tool.logger = { info() {}, warn() {}, error() {}, debug() {} };
+  return tool;
+}
+
+function queuedJob(overrides = {}) {
+  return {
+    jobId: overrides.jobId || `q-${Math.random().toString(36).slice(2, 8)}`,
+    agentId: 'agent-A',
+    sessionId: 'sess-A',
+    prompt: 'a cat playing piano',
+    model: 'sora-2',
+    width: 1080, height: 1080,
+    duration: 5, variants: 1,
+    projectDir: '/tmp/x',
+    status: 'queued',
+    soraJobId: null,
+    createdAt: new Date().toISOString(),
+    ...overrides,
+  };
+}
+
+describe('VideoTool.getJobsSnapshot', () => {
+  test('returns empty arrays when nothing queued', () => {
+    const tool = makeTool();
+    const snap = tool.getJobsSnapshot();
+    expect(snap.queued).toEqual([]);
+    expect(snap.active).toEqual([]);
+    expect(snap.completed).toEqual([]);
+    expect(snap.limits).toBeDefined();
+  });
+
+  test('serialises a queued job to summary shape', () => {
+    const tool = makeTool();
+    const j = queuedJob({ jobId: 'j1', prompt: 'a fox' });
+    tool.queue.push(j);
+    const snap = tool.getJobsSnapshot();
+    expect(snap.queued).toHaveLength(1);
+    const s = snap.queued[0];
+    expect(s.jobId).toBe('j1');
+    expect(s.agentId).toBe('agent-A');
+    expect(s.prompt).toBe('a fox');
+    expect(s.status).toBe('queued');
+  });
+
+  test('builds a videoUrl for completed jobs with an outputPath', () => {
+    const tool = makeTool();
+    const j = queuedJob({
+      jobId: 'done-1',
+      status: 'completed',
+      sessionId: 'sess-X',
+      outputPath: 'videos/out-42.mp4',
+    });
+    tool.completedJobs.set(j.jobId, j);
+    const snap = tool.getJobsSnapshot();
+    expect(snap.completed[0].videoUrl).toBe('/api/videos/sess-X/out-42.mp4');
+  });
+
+  test('trims very long prompts to a preview', () => {
+    const tool = makeTool();
+    const big = 'x'.repeat(500);
+    tool.queue.push(queuedJob({ prompt: big }));
+    const snap = tool.getJobsSnapshot();
+    expect(snap.queued[0].prompt.length).toBe(300);
+  });
+
+  test('separates queued / active / completed correctly', () => {
+    const tool = makeTool();
+    tool.queue.push(queuedJob({ jobId: 'q1' }));
+    tool.activeJobs.set('a1', queuedJob({ jobId: 'a1', status: 'active' }));
+    tool.completedJobs.set('c1', queuedJob({ jobId: 'c1', status: 'completed' }));
+    const snap = tool.getJobsSnapshot();
+    expect(snap.queued.map(j => j.jobId)).toEqual(['q1']);
+    expect(snap.active.map(j => j.jobId)).toEqual(['a1']);
+    expect(snap.completed.map(j => j.jobId)).toEqual(['c1']);
+  });
+});
+
+describe('VideoTool.cancelJob', () => {
+  test('cancels a queued job (removes from queue, adds to completed)', () => {
+    const tool = makeTool();
+    tool.queue.push(queuedJob({ jobId: 'j1' }));
+    const r = tool.cancelJob('j1');
+    expect(r.success).toBe(true);
+    expect(r.state).toBe('queued');
+    expect(tool.queue).toHaveLength(0);
+    expect(tool.completedJobs.get('j1').status).toBe('cancelled');
+  });
+
+  test('cancels an active job', () => {
+    const tool = makeTool();
+    tool.activeJobs.set('a1', queuedJob({ jobId: 'a1', status: 'active' }));
+    const r = tool.cancelJob('a1');
+    expect(r.success).toBe(true);
+    expect(r.state).toBe('active');
+    expect(tool.activeJobs.has('a1')).toBe(false);
+    expect(tool.completedJobs.get('a1').status).toBe('cancelled');
+  });
+
+  test('returns not found for unknown jobId', () => {
+    const tool = makeTool();
+    const r = tool.cancelJob('never-existed');
+    expect(r.success).toBe(false);
+  });
+
+  test('returns not found for already completed job (terminal)', () => {
+    const tool = makeTool();
+    tool.completedJobs.set('done', queuedJob({ jobId: 'done', status: 'completed' }));
+    const r = tool.cancelJob('done');
+    expect(r.success).toBe(false);
+  });
+
+  test('clears any poll timer for active jobs on cancel', () => {
+    const tool = makeTool();
+    tool.activeJobs.set('a1', queuedJob({ jobId: 'a1', status: 'active' }));
+    // Simulate a live timer handle.
+    const handle = setTimeout(() => {}, 10_000);
+    tool.pollTimers.set('a1', handle);
+    tool.cancelJob('a1');
+    expect(tool.pollTimers.has('a1')).toBe(false);
+    clearTimeout(handle);
+  });
+});

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}`);
         }