testronaut 1.3.0 → 1.3.2

package/tests/coreTests/missionDiscovery.test.js

@@ -0,0 +1,81 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { discoverMissionFiles } from '../../core/missionDiscovery.js';
+
+function makeTempDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'testronaut-missions-'));
+}
+
+function writeJson(p, obj) {
+  fs.writeFileSync(p, JSON.stringify(obj, null, 2));
+}
+
+const temps = [];
+
+afterEach(() => {
+  while (temps.length) {
+    const dir = temps.pop();
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe('discoverMissionFiles', () => {
+  it('falls back to legacy discovery when missions block is missing', async () => {
+    const tmp = makeTempDir();
+    temps.push(tmp);
+    const missionsDir = path.join(tmp, 'missions');
+    fs.mkdirSync(missionsDir, { recursive: true });
+    fs.writeFileSync(path.join(missionsDir, 'alpha.mission.js'), '// ok');
+    fs.writeFileSync(path.join(missionsDir, 'beta.txt'), '// ignore');
+    fs.mkdirSync(path.join(missionsDir, 'nested'), { recursive: true });
+    fs.writeFileSync(path.join(missionsDir, 'nested', 'gamma.mission.js'), '// nested');
+    fs.writeFileSync(path.join(missionsDir, 'delta.mission.ts'), '// ts not included by default');
+
+    const res = await discoverMissionFiles({ cwd: tmp });
+    expect(res.root).toBe(path.resolve(tmp, 'missions'));
+    expect(res.files).toEqual(['alpha.mission.js']);
+  });
+
+  it('respects missions.root with include patterns', async () => {
+    const tmp = makeTempDir();
+    temps.push(tmp);
+    const missionsDir = path.join(tmp, 'custom');
+    fs.mkdirSync(path.join(missionsDir, 'nested'), { recursive: true });
+    fs.writeFileSync(path.join(missionsDir, 'root.mission.js'), '// root');
+    fs.writeFileSync(path.join(missionsDir, 'nested', 'deep.mission.ts'), '// nested ts');
+
+    writeJson(path.join(tmp, 'testronaut-config.json'), {
+      missions: {
+        root: './custom',
+        include: ['*.mission.js', 'nested/**/*.mission.ts'],
+      },
+    });
+
+    const res = await discoverMissionFiles({ cwd: tmp });
+    expect(res.root).toBe(path.resolve(tmp, 'custom'));
+    expect(res.files).toEqual(['nested/deep.mission.ts', 'root.mission.js']);
+  });
+
+  it('applies missions.exclude after includes', async () => {
+    const tmp = makeTempDir();
+    temps.push(tmp);
+    const missionsDir = path.join(tmp, 'custom');
+    fs.mkdirSync(path.join(missionsDir, 'ignore'), { recursive: true });
+    fs.writeFileSync(path.join(missionsDir, 'keep.mission.js'), '// keep');
+    fs.writeFileSync(path.join(missionsDir, 'ignore', 'skip.mission.js'), '// skip');
+    fs.writeFileSync(path.join(missionsDir, 'keep.wip.mission.js'), '// skip by pattern');
+
+    writeJson(path.join(tmp, 'testronaut-config.json'), {
+      missions: {
+        root: './custom',
+        include: ['**/*.mission.js'],
+        exclude: ['ignore/**', '**/*.wip.mission.js'],
+      },
+    });
+
+    const res = await discoverMissionFiles({ cwd: tmp });
+    expect(res.files).toEqual(['keep.mission.js']);
+  });
+});

package/tests/coreTests/turnLoop.test.js

@@ -22,6 +22,7 @@ const { shared } = vi.hoisted(() => {
             mode: 'save',
           })
         ),
+        list_local_files: vi.fn(async () => JSON.stringify({ files: ['a.pdf', 'b.pdf'] })),
       },
     },
   };
@@ -63,6 +64,7 @@ vi.mock('../../tools/toolSchema.js', () => ({
     { type: 'function', function: { name: 'click_text', description: 'click by text', parameters: {} } },
     { type: 'function', function: { name: 'get_dom', description: 'get DOM html', parameters: {} } },
     { type: 'function', function: { name: 'screenshot', description: 'take a screenshot', parameters: {} } },
+    { type: 'function', function: { name: 'list_local_files', description: 'list files', parameters: {} } },
   ],
 }));
 
@@ -96,7 +98,7 @@ vi.mock('../../core/redaction.js', () => ({
 }));
 
 // Import SUT after mocks
-import { turnLoop } from '../../core/turnLoop.js';
+import { turnLoop, __docProgressInternals } from '../../core/turnLoop.js';
 
 // Helper
 function baseMessages() {
@@ -128,7 +130,7 @@ describe('turnLoop', () => {
     const messages = baseMessages();
     const result = await turnLoop(browser, messages, 1, 0, 0, {}, { steps: [], missionName: 'demo' });
 
-    expect(result).toBeTruthy();
+    expect(result.success).toBe(true);
     expect(result.steps?.length).toBe(1);
     const step = result.steps[0];
     expect(step.tokensUsed).toBe(42);
@@ -163,7 +165,7 @@ describe('turnLoop', () => {
     const messages = baseMessages();
     const res = await turnLoop(browser, messages, 2, 0, 0, {}, { steps: [], missionName: 'demo' });
 
-    expect(res).toBeTruthy();
+    expect(res.success).toBe(true);
     expect(res.steps.length).toBe(2);
 
     const step1 = res.steps[0];
@@ -174,4 +176,99 @@ describe('turnLoop', () => {
     const step2 = res.steps[1];
     expect(step2.result).toMatch(/Success/);
   });
+
+  it('retries a turn on tool error before marking issues', async () => {
+    // First turn: tool call → click_text will throw
+    shared.chatMock.mockResolvedValueOnce({
+      message: {
+        role: 'assistant',
+        content: '',
+        tool_calls: [
+          {
+            id: 'tool_retry',
+            type: 'function',
+            function: { name: 'click_text', arguments: JSON.stringify({ text: 'Hello' }) },
+          },
+        ],
+      },
+      usage: { total_tokens: 7 },
+    });
+    // Retry turn: same tool call, click_text succeeds
+    shared.chatMock.mockResolvedValueOnce({
+      message: {
+        role: 'assistant',
+        content: '',
+        tool_calls: [
+          {
+            id: 'tool_retry_2',
+            type: 'function',
+            function: { name: 'click_text', arguments: JSON.stringify({ text: 'Hello' }) },
+          },
+        ],
+      },
+      usage: { total_tokens: 6 },
+    });
+    // Final turn: mission completes
+    shared.chatMock.mockResolvedValueOnce({
+      message: { role: 'assistant', content: 'FINAL: done' },
+      usage: { total_tokens: 5 },
+    });
+
+    // click_text fails once, then succeeds
+    shared.chromeToolSpies.click_text
+      .mockImplementationOnce(async () => { throw new Error('no locator'); })
+      .mockImplementationOnce(async () => JSON.stringify({ ok: true, clicked: 'Hello' }));
+
+    const messages = baseMessages();
+    const res = await turnLoop(browser, messages, 3, 0, 0, {}, { steps: [], missionName: 'demo' });
+
+    expect(res.success).toBe(true);
+    expect(res.steps.length).toBe(3);
+    expect(res.steps[0].result).toBe('⏳ Retrying turn');
+    expect(res.steps[1].result).toBe('✅ Passed');
+    expect(res.steps[2].result).toMatch(/Success/);
+  });
+
+  describe('__docProgressInternals helpers', () => {
+    const { parseDocListFromDom, extractDocIdFromUrl, ensureDocProgress } = __docProgressInternals;
+
+    it('parses injected doc list summary', () => {
+      const html = `<pre data-testronaut-doc-list>
+List
+- [123] File A /document/123
+- [456] File B /document/456
+</pre>`;
+      const { items, scriptDocs } = parseDocListFromDom(html);
+      expect(items).toHaveLength(2);
+      expect(items[0].id).toBe('123');
+      expect(items[1].title.length).toBeGreaterThan(0);
+      expect(scriptDocs).toBe(2);
+    });
+
+    it('extracts doc id from url and tracks progress', () => {
+      expect(extractDocIdFromUrl('https://x.com/document/999/foo')).toBe('999');
+      expect(extractDocIdFromUrl('nope')).toBe('');
+
+      const mem = {};
+      const cfg = { enabled: true, hrefIncludes: ['/doc'], dataTypes: ['doc'] };
+      const prog = ensureDocProgress(mem, cfg);
+      expect(prog.patterns).toBe(cfg);
+      prog.items = [{ id: '1', title: 'Doc 1' }];
+      prog.downloaded.add('1');
+      expect(prog.downloaded.has('1')).toBe(true);
+    });
+
+    it('updates progress from list_local_files results', () => {
+      const mem = {};
+      const cfg = { enabled: true, hrefIncludes: ['/doc'], dataTypes: ['doc'] };
+      const prog = ensureDocProgress(mem, cfg);
+      prog.items = [];
+      // simulate list_local_files JSON result
+      const parsed = JSON.parse(JSON.stringify({ files: ['x.pdf', 'y.pdf'] }));
+      prog.items = parsed.files.map(f => ({ id: f, title: f, href: f }));
+      prog.downloaded.add('x.pdf');
+      expect(prog.items).toHaveLength(2);
+      expect(prog.downloaded.has('x.pdf')).toBe(true);
+    });
+  });
 });

package/tests/runnerTests/testronaut.test.js

@@ -9,17 +9,26 @@ vi.mock('../../core/redaction.js', () => ({
 vi.mock('../../core/config.js', () => ({
   loadConfig: vi.fn(),
   enforceTurnBudget: vi.fn(),
+  getRetryLimit: vi.fn(),
+  getDomListLimit: vi.fn(),
+  getResourceGuardConfig: vi.fn(),
 }));
 
 import { runAgent } from '../../core/agent.js';
-import { loadConfig, enforceTurnBudget } from '../../core/config.js';
+import { loadConfig, enforceTurnBudget, getRetryLimit, getDomListLimit, getResourceGuardConfig } from '../../core/config.js';
 
 // Adjust the import path if your file lives elsewhere
-import { runMissions } from '../../runner/testronaut.js';
+import { runMissions, __test__ as testronautInternals } from '../../runner/testronaut.js';
 
 describe('cli/testronaut.runMissions (with enforceTurnBudget)', () => {
+  const OLD_ENV = { ...process.env };
   beforeEach(() => {
+    process.env = { ...OLD_ENV };
     vi.clearAllMocks();
+    // Default retry limit unless overridden in a test
+    getRetryLimit.mockReturnValue({ value: 2, source: 'default', clamped: false });
+    getDomListLimit.mockReturnValue({ value: 3, mode: 'number', source: 'default', clamped: false });
+    getResourceGuardConfig.mockReturnValue({ enabled: true, hrefIncludes: ['/document/'], dataTypes: ['document'] });
   });
 
   it('passes effectiveMax to runAgent and logs any notes', async () => {
@@ -30,6 +39,7 @@ describe('cli/testronaut.runMissions (with enforceTurnBudget)', () => {
       notes: ['⚠️ maxTurns (999) exceeds hardMaxTurns (200). Clamping to 200.'],
       strict: false,
     });
+    getRetryLimit.mockReturnValue({ value: 2, source: 'default', clamped: false });
 
     const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
     const log = vi.spyOn(console, 'log').mockImplementation(() => {});
@@ -46,7 +56,7 @@ describe('cli/testronaut.runMissions (with enforceTurnBudget)', () => {
       expect.stringContaining('Clamping to 200')
     );
     expect(runAgent).toHaveBeenCalledWith(
-      expect.any(Array), 'Budgeted Run', 200
+      expect.any(Array), 'Budgeted Run', 200, 2, { domListLimit: 3, debug: false, resourceGuard: { enabled: true, hrefIncludes: ['/document/'], dataTypes: ['document'] } }
     );
 
     warn.mockRestore();
@@ -61,6 +71,7 @@ describe('cli/testronaut.runMissions (with enforceTurnBudget)', () => {
       notes: [],
       strict: false,
     });
+    getRetryLimit.mockReturnValue({ value: 3, source: 'default', clamped: false });
 
     const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
     const log = vi.spyOn(console, 'log').mockImplementation(() => {});
@@ -72,7 +83,33 @@ describe('cli/testronaut.runMissions (with enforceTurnBudget)', () => {
     await runMissions({ mission: 'No warnings' }, 'Clean');
 
     expect(warn).not.toHaveBeenCalled();
-    expect(runAgent).toHaveBeenCalledWith(expect.any(Array), 'Clean', 20);
+    expect(runAgent).toHaveBeenCalledWith(expect.any(Array), 'Clean', 20, 3, { domListLimit: 3, debug: false, resourceGuard: { enabled: true, hrefIncludes: ['/document/'], dataTypes: ['document'] } });
+
+    warn.mockRestore();
+    log.mockRestore();
+  });
+
+  it('warns when the DOM list limit is clamped', async () => {
+    loadConfig.mockResolvedValue({});
+    enforceTurnBudget.mockReturnValue({
+      effectiveMax: 20,
+      limits: {},
+      notes: [],
+      strict: false,
+    });
+    getDomListLimit.mockReturnValue({ value: 100, mode: 'number', source: 'config', clamped: true });
+
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    runAgent.mockResolvedValue([
+      { steps: [{ result: 'SUCCESS: ok' }], status: 'passed' },
+    ]);
+
+    await runMissions({ mission: 'Clamp lists' }, 'Clamp Mission');
+
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining('DOM list limit clamped to 100')
+    );
 
     warn.mockRestore();
     log.mockRestore();
@@ -138,8 +175,8 @@ describe('cli/testronaut.runMissions (with enforceTurnBudget)', () => {
     // Mission name is the passed-in missionName for main
     expect(goals[1].submissionName).toMatch(/^My Mission/);
 
-    // Effective max turns passed through
-    expect(runAgent).toHaveBeenCalledWith(expect.any(Array), 'My Mission', 15);
+    // Effective max turns and retry limit passed through
+    expect(runAgent).toHaveBeenCalledWith(expect.any(Array), 'My Mission', 15, 2, { domListLimit: 3, debug: false, resourceGuard: { enabled: true, hrefIncludes: ['/document/'], dataTypes: ['document'] } });
 
     log.mockRestore();
   });
@@ -161,4 +198,37 @@ describe('cli/testronaut.runMissions (with enforceTurnBudget)', () => {
 
     log.mockRestore();
   });
+
+  it('passes debug flag through when TESTRONAUT_DEBUG is set', async () => {
+    process.env.TESTRONAUT_DEBUG = 'true';
+    loadConfig.mockResolvedValue({});
+    enforceTurnBudget.mockReturnValue({
+      effectiveMax: 20,
+      limits: {},
+      notes: [],
+      strict: false,
+    });
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    runAgent.mockResolvedValue([
+      { steps: [{ result: 'SUCCESS: ok' }], status: 'passed' },
+    ]);
+
+    await runMissions({ mission: 'Debug' }, 'Debug Mission');
+
+    expect(runAgent).toHaveBeenCalledWith(expect.any(Array), 'Debug Mission', 20, 2, { domListLimit: 3, debug: true, resourceGuard: { enabled: true, hrefIncludes: ['/document/'], dataTypes: ['document'] } });
+
+    log.mockRestore();
+  });
+
+  describe('__test__ helpers', () => {
+    it('formats list limits and reads debug env', () => {
+      const { isDebugEnabled, formatListLimit } = testronautInternals;
+      process.env.TESTRONAUT_DEBUG = 'on';
+      expect(isDebugEnabled()).toBe(true);
+      process.env.TESTRONAUT_DEBUG = '0';
+      expect(isDebugEnabled()).toBe(false);
+      expect(formatListLimit(Infinity)).toBe('all');
+      expect(formatListLimit(5)).toBe(5);
+    });
+  });
 });

package/tests/toolsTests/domControl.test.js

@@ -195,6 +195,41 @@ describe('domControl helpers', () => {
       // Total children: 2 cards + 1 other + 1 marker
       expect(rootChildren.length).toBe(4);
     });
+
+    it('keeps all repeated divs when maxAllowed is Infinity', () => {
+      const html = `
+        <div id="root">
+          <div class="card">1</div>
+          <div class="card">2</div>
+          <div class="card">3</div>
+          <div class="card">4</div>
+        </div>
+      `;
+      const $ = cheerio.load(html);
+
+      reduceRepeatedDivs($, Infinity);
+
+      const cardDivs = $('#root').children('div.card');
+      expect(cardDivs.length).toBe(4);
+      expect($('#root').children('div[data-collapsed="true"]').length).toBe(0);
+    });
+
+    it('removes all repeated divs when maxAllowed is 0', () => {
+      const html = `
+        <div id="root">
+          <div class="card">A</div>
+          <div class="card">B</div>
+        </div>
+      `;
+      const $ = cheerio.load(html);
+
+      reduceRepeatedDivs($, 0);
+
+      const cardDivs = $('#root').children('div.card');
+      expect(cardDivs.length).toBe(0);
+      const markers = $('#root').children('div[data-collapsed="true"]');
+      expect(markers.length).toBe(1);
+    });
   });
 
   describe('removeObfuscatedClassNames', () => {

package/tests/toolsTests/generateHtmlReport.test.js

@@ -0,0 +1,90 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { generateHtmlReport } from '../../tools/generateHtmlReport.js';
+
+let tmpDir;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'testronaut-report-'));
+});
+
+afterEach(() => {
+  try {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  } catch {}
+});
+
+describe('generateHtmlReport', () => {
+  it('writes an HTML report containing mission and retry metadata', () => {
+    const report = {
+      runId: 'run_test',
+      missions: [
+        {
+          missionName: 'Mission A',
+          submissionType: 'mission',
+          submissionName: 'Main',
+          status: 'passed',
+          steps: [
+            {
+              turn: 0,
+              retryAttempt: 2,
+              retryLimit: 5,
+              events: ['did something'],
+              result: '⚠️ Turn Issues',
+              summary: 'Do thing',
+              tokensUsed: 10,
+              totalTokensUsed: 20,
+            },
+          ],
+        },
+      ],
+    };
+
+    const outPath = path.join(tmpDir, 'report.html');
+    const written = generateHtmlReport(report, outPath);
+
+    expect(written).toBe(outPath);
+    expect(fs.existsSync(outPath)).toBe(true);
+    const html = fs.readFileSync(outPath, 'utf8');
+
+    expect(html).toContain('Testronaut Report');
+    expect(html).toContain('Mission A');
+    expect(html).toContain('Turn 1 (re-attempt 1/5)');
+    expect(html).toContain('⚠️ Turn Issues');
+  });
+
+  it('escapes unsafe text in output', () => {
+    const report = {
+      runId: 'run<&>',
+      missions: [
+        {
+          missionName: 'Mission <X>',
+          submissionType: 'mission',
+          submissionName: 'Main',
+          status: 'passed',
+          steps: [
+            {
+              turn: 0,
+              retryAttempt: 1,
+              events: ['<script>alert(1)</script>'],
+              result: '✅ Passed',
+              summary: '<b>bold</b>',
+            },
+          ],
+        },
+      ],
+    };
+
+    const outPath = path.join(tmpDir, 'safe.html');
+    generateHtmlReport(report, outPath);
+    const html = fs.readFileSync(outPath, 'utf8');
+
+    expect(html).toContain('run&lt;&amp;&gt;');
+    expect(html).toContain('Mission &lt;X&gt;');
+    expect(html).toContain('&lt;script&gt;alert(1)&lt;/script&gt;');
+    expect(html).toContain('&lt;b&gt;bold&lt;/b&gt;');
+  });
+});

package/tests/toolsTests/toolSchema.test.js

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest';
+import toolsSchema from '../../tools/toolSchema.js';
+
+describe('tools/toolSchema', () => {
+  it('includes resource_progress tool with empty params', () => {
+    const entry = toolsSchema.find(t => t.function?.name === 'resource_progress');
+    expect(entry?.type).toBe('function');
+    expect(entry.function.parameters).toEqual({ type: 'object', properties: {} });
+    expect(entry.function.description).toMatch(/remaining/i);
+  });
+
+  it('includes list_local_files tool', () => {
+    const entry = toolsSchema.find(t => t.function?.name === 'list_local_files');
+    expect(entry?.type).toBe('function');
+    expect(entry.function.parameters?.properties).toHaveProperty('dir');
+  });
+
+  it('defines navigate and download_file with required fields', () => {
+    const nav = toolsSchema.find(t => t.function?.name === 'navigate');
+    const download = toolsSchema.find(t => t.function?.name === 'download_file');
+    expect(nav?.function?.parameters?.required).toContain('url');
+    expect(download?.function?.parameters?.properties).toHaveProperty('url');
+  });
+});