onbuzz 4.0.2 → 4.2.0

package/src/tools/webTool.js

@@ -643,14 +643,78 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
     const { operation } = params;
     const { agentId } = context;
 
+    // Per-agent config overrides for the web tool (agent.toolConfig.web).
+    // Supported knobs:
+    //   - defaultStealthLevel — fallback when caller doesn't pass one.
+    //   - allowedDomains      — if set, URLs must match.
+    //   - blockedDomains      — URLs on these hosts refused.
+    const webAgentConfig = this.getEffectiveConfig(context, {});
+    const agentDefaultStealth = typeof webAgentConfig.defaultStealthLevel === 'string'
+      ? webAgentConfig.defaultStealthLevel
+      : null;
+    const agentAllowedDomains = Array.isArray(webAgentConfig.allowedDomains) && webAgentConfig.allowedDomains.length > 0
+      ? webAgentConfig.allowedDomains.map(d => String(d).toLowerCase())
+      : null;
+    const agentBlockedDomains = Array.isArray(webAgentConfig.blockedDomains) && webAgentConfig.blockedDomains.length > 0
+      ? webAgentConfig.blockedDomains.map(d => String(d).toLowerCase())
+      : null;
+
+    // Host-match helper: true when `host` equals `pattern` or is a
+    // subdomain of `pattern`. Case-insensitive.
+    const _hostMatches = (host, pattern) => {
+      const h = String(host || '').toLowerCase();
+      const p = String(pattern || '').toLowerCase();
+      return h === p || h.endsWith('.' + p);
+    };
+    const _checkUrl = (url) => {
+      if (!url) return null;
+      let host;
+      try { host = new URL(url).host; } catch { return null; } // non-URL input → skip
+      if (agentBlockedDomains && agentBlockedDomains.some(p => _hostMatches(host, p))) {
+        return `URL host ${host} is blocked by agent policy`;
+      }
+      if (agentAllowedDomains && !agentAllowedDomains.some(p => _hostMatches(host, p))) {
+        return `URL host ${host} is not in the agent's allowed domains`;
+      }
+      return null;
+    };
+
+    // Gate URL-bearing operations upfront. `interactive` has per-action
+    // navigate URLs — those get checked too.
+    {
+      const urlsToCheck = [];
+      if (operation === 'fetch' || operation === 'search') {
+        if (params.url) urlsToCheck.push(params.url);
+        // `search` typically uses search-engine URLs (ddg, google) that
+        // callers don't pass directly, so we don't attempt to check them.
+      }
+      if (operation === 'interactive' && Array.isArray(params.actions)) {
+        for (const a of params.actions) {
+          if (a && a.type === 'navigate' && a.url) urlsToCheck.push(a.url);
+        }
+      }
+      for (const u of urlsToCheck) {
+        const err = _checkUrl(u);
+        if (err) {
+          return { success: false, operation, error: err };
+        }
+      }
+    }
+
     try {
       let result;
 
       // Fix 1: Compute effective stealth level BEFORE ensuring browser
       // This preserves current browser stealth level instead of defaulting to 'standard'
       // which prevents browser restart when agent forgets to specify stealthLevel after authenticate
+      //
+      // Precedence: caller's stealthLevel > current browser setting > per-agent
+      // default from toolConfig > hard 'standard'.
       const currentBrowserStealth = this.browser?._stealthConfig?.stealthLevel;
-      const effectiveStealthLevel = params.stealthLevel || currentBrowserStealth || 'standard';
+      const effectiveStealthLevel = params.stealthLevel
+        || currentBrowserStealth
+        || agentDefaultStealth
+        || 'standard';
 
       // Ensure browser is initialized with the correct stealth level
       // Note: Each operation also calls ensureBrowser internally, but this pre-check

package/src/utilities/__tests__/auditReport.test.js

@@ -0,0 +1,328 @@
+/**
+ * Tests for auditReport — pure classification + markdown rendering.
+ *
+ * Coverage priority: the CLASSIFIER. Every real audit JSON flows through
+ * it, and a single misclassification (e.g. a "direct-breaking" shown as
+ * "transitive-auto") would silently let a known-bad release through the
+ * gate. The six-bucket contract is locked hard.
+ */
+
+import { describe, test, expect } from '@jest/globals';
+import {
+  classifyVulnerability,
+  classifyAudit,
+  renderMarkdown,
+  shouldFail,
+  getAlternative,
+  ALTERNATIVES,
+} from '../auditReport.js';
+
+// ────────────────────────────────────────────────────────────────────────
+// classifyVulnerability
+// ────────────────────────────────────────────────────────────────────────
+
+describe('classifyVulnerability — bucket assignment', () => {
+  test('direct + fixAvailable=true → direct-auto', () => {
+    const out = classifyVulnerability('ajv', {
+      severity: 'moderate', isDirect: true, fixAvailable: true,
+      via: [], range: '<6.14.0',
+    });
+    expect(out.bucket).toBe('direct-auto');
+    expect(out.fixHint).toMatch(/npm audit fix/);
+  });
+
+  test('transitive + fixAvailable=true → transitive-auto', () => {
+    const out = classifyVulnerability('@xmldom/xmldom', {
+      severity: 'high', isDirect: false, fixAvailable: true,
+      via: [], range: '<0.8.12',
+    });
+    expect(out.bucket).toBe('transitive-auto');
+  });
+
+  test('direct + fixAvailable object with isSemVerMajor=true → direct-breaking', () => {
+    const out = classifyVulnerability('webpack', {
+      severity: 'high', isDirect: true,
+      fixAvailable: { name: 'webpack', version: '5.94.0', isSemVerMajor: true },
+      via: [], range: '<5.94.0',
+    });
+    expect(out.bucket).toBe('direct-breaking');
+    expect(out.fixHint).toMatch(/Breaking upgrade/);
+    expect(out.fixHint).toContain('webpack@5.94.0');
+  });
+
+  test('transitive + fixAvailable object with isSemVerMajor=true → transitive-needs-parent-bump', () => {
+    const out = classifyVulnerability('lodash', {
+      severity: 'high', isDirect: false,
+      fixAvailable: { name: 'some-parent', version: '2.0.0', isSemVerMajor: true },
+      via: [], range: '<4.17.21',
+    });
+    expect(out.bucket).toBe('transitive-needs-parent-bump');
+    expect(out.fixHint).toContain('some-parent@2.0.0');
+  });
+
+  test('direct + fixAvailable object with isSemVerMajor=false → direct-auto (non-breaking targeted)', () => {
+    const out = classifyVulnerability('foo', {
+      severity: 'moderate', isDirect: true,
+      fixAvailable: { name: 'foo', version: '1.2.4', isSemVerMajor: false },
+      via: [], range: '<1.2.4',
+    });
+    expect(out.bucket).toBe('direct-auto');
+    expect(out.fixHint).toMatch(/Targeted upgrade/);
+  });
+
+  test('direct + fixAvailable=false → direct-orphan', () => {
+    const out = classifyVulnerability('abandonware', {
+      severity: 'high', isDirect: true, fixAvailable: false,
+      via: [], range: '*',
+    });
+    expect(out.bucket).toBe('direct-orphan');
+    expect(out.fixHint).toMatch(/No fix available/);
+  });
+
+  test('transitive + fixAvailable=false → transitive-orphan', () => {
+    const out = classifyVulnerability('abandonware', {
+      severity: 'high', isDirect: false, fixAvailable: false,
+      via: [], range: '*',
+    });
+    expect(out.bucket).toBe('transitive-orphan');
+    expect(out.fixHint).toMatch(/overrides|replace/i);
+  });
+
+  test('missing fixAvailable treated as no fix (defensive)', () => {
+    const out = classifyVulnerability('mystery', {
+      severity: 'moderate', isDirect: true,
+      via: [], range: '*',
+    });
+    expect(out.bucket).toBe('direct-orphan');
+  });
+});
+
+describe('classifyVulnerability — advisory extraction', () => {
+  test('object entries in `via` become advisories; string entries are ignored', () => {
+    const out = classifyVulnerability('pkg', {
+      severity: 'high', isDirect: false, fixAvailable: true,
+      via: [
+        { title: 'RCE via tag injection', url: 'https://example/1', cvss: { score: 9.8 }, cwe: ['CWE-77'] },
+        'some-other-vuln-ref',
+        { title: 'XXE', url: 'https://example/2' },
+      ],
+      range: '<1.0.0',
+    });
+    expect(out.advisories).toHaveLength(2);
+    expect(out.advisories[0]).toEqual({ title: 'RCE via tag injection', url: 'https://example/1', cvss: 9.8, cwe: ['CWE-77'] });
+    expect(out.advisories[1]).toEqual({ title: 'XXE', url: 'https://example/2', cvss: null, cwe: [] });
+  });
+
+  test('missing via array → empty advisories list (no throw)', () => {
+    const out = classifyVulnerability('pkg', { severity: 'low', isDirect: true, fixAvailable: true });
+    expect(out.advisories).toEqual([]);
+  });
+});
+
+describe('classifyVulnerability — alternatives lookup', () => {
+  test('known orphan gets an alternative attached', () => {
+    const out = classifyVulnerability('request', {
+      severity: 'high', isDirect: true, fixAvailable: false,
+      via: [], range: '*',
+    });
+    expect(out.alternative).not.toBeNull();
+    expect(out.alternative.replacement).toMatch(/undici|fetch/i);
+  });
+
+  test('unknown package gets no alternative', () => {
+    const out = classifyVulnerability('some-obscure-pkg', {
+      severity: 'low', isDirect: false, fixAvailable: true,
+      via: [], range: '*',
+    });
+    expect(out.alternative).toBeNull();
+  });
+});
+
+// ────────────────────────────────────────────────────────────────────────
+// classifyAudit
+// ────────────────────────────────────────────────────────────────────────
+
+describe('classifyAudit', () => {
+  const sample = {
+    vulnerabilities: {
+      'pkg-a': { severity: 'critical', isDirect: true, fixAvailable: true, via: [], range: '<1' },
+      'pkg-b': { severity: 'high', isDirect: false, fixAvailable: false, via: [], range: '<2' },
+      'pkg-c': { severity: 'moderate', isDirect: true, fixAvailable: { name: 'pkg-c', version: '2.0.0', isSemVerMajor: true }, via: [], range: '<2' },
+      'pkg-d': { severity: 'low', isDirect: false, fixAvailable: true, via: [], range: '<1' },
+    },
+  };
+
+  test('returns summary with severity + bucket counts', () => {
+    const out = classifyAudit(sample);
+    expect(out.summary.total).toBe(4);
+    expect(out.summary.bySeverity.critical).toBe(1);
+    expect(out.summary.bySeverity.high).toBe(1);
+    expect(out.summary.bySeverity.moderate).toBe(1);
+    expect(out.summary.bySeverity.low).toBe(1);
+    expect(out.summary.byBucket['direct-auto']).toBe(1);      // pkg-a
+    expect(out.summary.byBucket['transitive-orphan']).toBe(1); // pkg-b
+    expect(out.summary.byBucket['direct-breaking']).toBe(1);   // pkg-c
+    expect(out.summary.byBucket['transitive-auto']).toBe(1);   // pkg-d
+  });
+
+  test('findings are ordered by severity descending (critical first)', () => {
+    const out = classifyAudit(sample);
+    expect(out.findings.map(f => f.severity)).toEqual(['critical', 'high', 'moderate', 'low']);
+  });
+
+  test('empty vulnerabilities object → empty findings, zero counts', () => {
+    const out = classifyAudit({ vulnerabilities: {} });
+    expect(out.summary.total).toBe(0);
+    expect(out.findings).toEqual([]);
+  });
+
+  test('completely malformed input is handled without throwing', () => {
+    expect(() => classifyAudit(null)).not.toThrow();
+    expect(() => classifyAudit(undefined)).not.toThrow();
+    expect(() => classifyAudit({})).not.toThrow();
+    expect(classifyAudit(null).summary.total).toBe(0);
+  });
+});
+
+// ────────────────────────────────────────────────────────────────────────
+// renderMarkdown
+// ────────────────────────────────────────────────────────────────────────
+
+describe('renderMarkdown', () => {
+  test('empty audit renders the "no vulnerabilities" notice', () => {
+    const out = renderMarkdown(classifyAudit({ vulnerabilities: {} }));
+    expect(out).toMatch(/No vulnerabilities/);
+    expect(out).not.toMatch(/## Summary/);
+  });
+
+  test('workspace label shows in header when provided', () => {
+    const out = renderMarkdown(classifyAudit({ vulnerabilities: {} }), { workspace: 'web-ui' });
+    expect(out).toMatch(/^# Dependency audit report — `web-ui`/m);
+  });
+
+  test('summary table lists only non-zero severity rows', () => {
+    const audit = {
+      vulnerabilities: {
+        a: { severity: 'high', isDirect: true, fixAvailable: true, via: [], range: '<1' },
+        b: { severity: 'high', isDirect: false, fixAvailable: true, via: [], range: '<2' },
+      },
+    };
+    const md = renderMarkdown(classifyAudit(audit));
+    expect(md).toMatch(/\| high \| 2 \|/);
+    expect(md).not.toMatch(/\| critical \|/);   // zero, must not appear
+    expect(md).not.toMatch(/\| low \|/);        // zero, must not appear
+  });
+
+  test('findings grouped under bucket headers in action-priority order', () => {
+    const audit = {
+      vulnerabilities: {
+        'auto-pkg':  { severity: 'moderate', isDirect: true, fixAvailable: true, via: [], range: '<1' },
+        'orphan-pkg':{ severity: 'high', isDirect: true, fixAvailable: false, via: [], range: '<1' },
+      },
+    };
+    const md = renderMarkdown(classifyAudit(audit));
+    const idxOrphan = md.indexOf('Direct · no fix available');
+    const idxAuto   = md.indexOf('Direct · auto-fixable');
+    expect(idxOrphan).toBeGreaterThan(-1);
+    expect(idxAuto).toBeGreaterThan(-1);
+    // Orphan section comes first — that's the "needs human decision" pile.
+    expect(idxOrphan).toBeLessThan(idxAuto);
+  });
+
+  test('alternative hint is surfaced for orphan vulns with a mapped replacement', () => {
+    const audit = {
+      vulnerabilities: {
+        request: { severity: 'high', isDirect: true, fixAvailable: false, via: [], range: '*' },
+      },
+    };
+    const md = renderMarkdown(classifyAudit(audit));
+    expect(md).toMatch(/Alternative/);
+    expect(md).toMatch(/undici|fetch/i);
+  });
+
+  test('advisory bullets render with title, cvss, cwe when present', () => {
+    const audit = {
+      vulnerabilities: {
+        pkg: {
+          severity: 'high', isDirect: true, fixAvailable: true,
+          via: [{ title: 'XSS', url: 'https://x', cvss: { score: 7.5 }, cwe: ['CWE-79'] }],
+          range: '<1',
+        },
+      },
+    };
+    const md = renderMarkdown(classifyAudit(audit));
+    expect(md).toMatch(/\[XSS\]\(https:\/\/x\)/);
+    expect(md).toMatch(/CVSS 7\.5/);
+    expect(md).toMatch(/CWE-79/);
+  });
+
+  test('path list collapses when there are more than 5 paths', () => {
+    const paths = Array.from({ length: 8 }, (_, i) => `node_modules/n${i}/dep`);
+    const audit = {
+      vulnerabilities: {
+        pkg: { severity: 'high', isDirect: false, fixAvailable: true, via: [], range: '<1', nodes: paths },
+      },
+    };
+    const md = renderMarkdown(classifyAudit(audit));
+    expect(md).toMatch(/and 7 more/);
+  });
+});
+
+// ────────────────────────────────────────────────────────────────────────
+// shouldFail — release-gate decision
+// ────────────────────────────────────────────────────────────────────────
+
+describe('shouldFail', () => {
+  const audit = (sev) => classifyAudit({
+    vulnerabilities: { x: { severity: sev, isDirect: true, fixAvailable: true, via: [], range: '<1' } },
+  });
+
+  test('fails on cutoff severity and anything above it', () => {
+    expect(shouldFail(audit('critical'), 'high')).toBe(true);
+    expect(shouldFail(audit('high'),     'high')).toBe(true);
+    expect(shouldFail(audit('moderate'), 'high')).toBe(false);
+  });
+
+  test('cutoff=moderate fails on moderate, high, and critical', () => {
+    expect(shouldFail(audit('critical'), 'moderate')).toBe(true);
+    expect(shouldFail(audit('high'),     'moderate')).toBe(true);
+    expect(shouldFail(audit('moderate'), 'moderate')).toBe(true);
+    expect(shouldFail(audit('low'),      'moderate')).toBe(false);
+  });
+
+  test('cutoff=none never fails regardless of severity', () => {
+    expect(shouldFail(audit('critical'), 'none')).toBe(false);
+  });
+
+  test('empty audit never fails', () => {
+    expect(shouldFail(classifyAudit({ vulnerabilities: {} }), 'low')).toBe(false);
+  });
+
+  test('unknown failLevel returns false (safe default)', () => {
+    expect(shouldFail(audit('critical'), 'not-a-level')).toBe(false);
+  });
+});
+
+// ────────────────────────────────────────────────────────────────────────
+// Alternatives map sanity
+// ────────────────────────────────────────────────────────────────────────
+
+describe('ALTERNATIVES map', () => {
+  test('is frozen — accidental mutation should fail silently or throw', () => {
+    expect(Object.isFrozen(ALTERNATIVES)).toBe(true);
+  });
+
+  test('every entry has replacement, note, and a valid confidence', () => {
+    const valid = new Set(['high', 'medium', 'low']);
+    for (const [name, entry] of Object.entries(ALTERNATIVES)) {
+      expect(typeof entry.replacement).toBe('string');
+      expect(entry.replacement.length).toBeGreaterThan(0);
+      expect(typeof entry.note).toBe('string');
+      expect(valid.has(entry.confidence)).toBe(true);
+    }
+  });
+
+  test('getAlternative returns null for unmapped packages', () => {
+    expect(getAlternative('lodash-really-not-here')).toBeNull();
+  });
+});

package/src/utilities/__tests__/modeTransitionReasons.test.js

@@ -0,0 +1,105 @@
+/**
+ * Tests for modeTransitionReasons — the natural-language catalog.
+ *
+ * The UI copy surfaced here is the main visible output of the whole
+ * mode-flip feature, so the contract is locked hard: every known code
+ * produces a full English sentence; templated tokens get replaced; unknown
+ * codes degrade gracefully to a readable fallback.
+ */
+
+import { describe, test, expect } from '@jest/globals';
+import {
+  MODE_TRANSITION_REASONS,
+  render,
+  isKnownReasonCode,
+} from '../modeTransitionReasons.js';
+
+describe('MODE_TRANSITION_REASONS catalog', () => {
+  test('is frozen so no runtime mutation can corrupt the catalog', () => {
+    expect(Object.isFrozen(MODE_TRANSITION_REASONS)).toBe(true);
+  });
+
+  test('every entry has a non-empty template', () => {
+    for (const [code, entry] of Object.entries(MODE_TRANSITION_REASONS)) {
+      expect(typeof entry.template).toBe('string');
+      expect(entry.template.length).toBeGreaterThan(0);
+    }
+  });
+
+  test('includes the full set of reason codes the scheduler emits', () => {
+    for (const code of ['user-stop', 'user-toggle', 'ai-request-timeout',
+                         'empty-response-stall', 'loop-detected', 'flow-init']) {
+      expect(MODE_TRANSITION_REASONS[code]).toBeDefined();
+    }
+  });
+});
+
+describe('render()', () => {
+  test('static template (no tokens) returns the template verbatim', () => {
+    expect(render('user-stop')).toBe('Stopped by user.');
+  });
+
+  test('empty-response-stall template interpolates count + elapsedSec', () => {
+    const out = render('empty-response-stall', { count: 5, elapsedSec: 57 });
+    expect(out).toMatch(/^The model returned 5 empty responses in a row over 57s/);
+    expect(out).toMatch(/\.$/);
+  });
+
+  test('loop-detected template interpolates occurrences + windowSize', () => {
+    const out = render('loop-detected', { occurrences: 7, windowSize: 10 });
+    expect(out).toMatch(/7 times in a 10-step window/);
+  });
+
+  test('ai-request-timeout template interpolates elapsedSec', () => {
+    const out = render('ai-request-timeout', { elapsedSec: 60 });
+    expect(out).toContain('60s');
+  });
+
+  test('missing detail keys degrade to `?` so the gap is visible', () => {
+    const out = render('empty-response-stall', { count: 5 });
+    expect(out).toContain('5 empty responses');
+    expect(out).toContain('?s');   // elapsedSec missing
+  });
+
+  test('unknown reason code produces a readable fallback, not a bare symbol', () => {
+    const out = render('some-new-reason');
+    expect(out).toMatch(/^Mode change \(some new reason\)\./);
+    expect(out).not.toContain('{');
+  });
+
+  test('null / undefined / empty code falls back without throwing', () => {
+    expect(render(null)).toBe('Mode changed.');
+    expect(render(undefined)).toBe('Mode changed.');
+    expect(render('')).toBe('Mode changed.');
+  });
+
+  test('all rendered strings end with sentence punctuation', () => {
+    for (const code of Object.keys(MODE_TRANSITION_REASONS)) {
+      const out = render(code, { count: 1, elapsedSec: 1, occurrences: 1, windowSize: 1 });
+      expect(out).toMatch(/[.!?]$/);
+    }
+  });
+
+  test('interpolation is safe against prototype-pollution tricks', () => {
+    // Keys that aren't own-properties of the detail object should not be read.
+    const detail = Object.create({ count: 'INJECTED' });
+    const out = render('empty-response-stall', detail);
+    expect(out).not.toContain('INJECTED');
+    expect(out).toContain('? empty responses');
+  });
+});
+
+describe('isKnownReasonCode()', () => {
+  test('true for catalog entries', () => {
+    expect(isKnownReasonCode('user-stop')).toBe(true);
+    expect(isKnownReasonCode('empty-response-stall')).toBe(true);
+  });
+
+  test('false for unknown / empty / non-string', () => {
+    expect(isKnownReasonCode('nope')).toBe(false);
+    expect(isKnownReasonCode('')).toBe(false);
+    expect(isKnownReasonCode(null)).toBe(false);
+    expect(isKnownReasonCode(undefined)).toBe(false);
+    expect(isKnownReasonCode(42)).toBe(false);
+  });
+});