testronaut 1.3.1 → 1.3.2

package/tests/coreTests/config.test.js

@@ -11,6 +11,8 @@ import {
   getRetryLimit,
   resolveTurnLimits,
   enforceTurnBudget,
+  getDomListLimit,
+  getResourceGuardConfig,
 } from '../../core/config.js';
 
 describe('core/config', () => {
@@ -105,6 +107,100 @@ describe('core/config', () => {
     });
   });
 
+  describe('getDomListLimit', () => {
+    const OLD_ENV = { ...process.env };
+    beforeEach(() => {
+      process.env = { ...OLD_ENV };
+      delete process.env.TESTRONAUT_DOM_LIST_LIMIT;
+    });
+    afterEach(() => {
+      process.env = { ...OLD_ENV };
+    });
+
+    it('returns default when missing', () => {
+      const res = getDomListLimit({});
+      expect(res.value).toBe(3);
+      expect(res.mode).toBe('number');
+      expect(res.source).toBe('default');
+      expect(res.clamped).toBe(false);
+    });
+
+    it('uses config value (nested) and clamps to range', () => {
+      const res = getDomListLimit({ dom: { listItemLimit: 250 } });
+      expect(res.value).toBe(100);
+      expect(res.mode).toBe('number');
+      expect(res.source).toBe('config');
+      expect(res.clamped).toBe(true);
+
+      const nestedAlt = getDomListLimit({ dom: { listLimit: '9' } });
+      expect(nestedAlt.value).toBe(9);
+      expect(nestedAlt.source).toBe('config');
+    });
+
+    it('prefers env override and accepts keywords', () => {
+      process.env.TESTRONAUT_DOM_LIST_LIMIT = 'all';
+      const allRes = getDomListLimit({ domListLimit: 2 });
+      expect(allRes.value).toBe(Infinity);
+      expect(allRes.mode).toBe('all');
+      expect(allRes.source).toBe('env');
+
+      process.env.TESTRONAUT_DOM_LIST_LIMIT = 'none';
+      const noneRes = getDomListLimit({ domListLimit: 5 });
+      expect(noneRes.value).toBe(0);
+      expect(noneRes.mode).toBe('none');
+      expect(noneRes.source).toBe('env');
+    });
+
+    it('accepts numeric strings', () => {
+      const res = getDomListLimit({ domListLimit: '7' });
+      expect(res.value).toBe(7);
+      expect(res.mode).toBe('number');
+    });
+  });
+
+  describe('getResourceGuardConfig', () => {
+    const OLD_ENV = { ...process.env };
+    beforeEach(() => {
+      process.env = { ...OLD_ENV };
+      delete process.env.TESTRONAUT_RESOURCE_GUARD;
+      delete process.env.TESTRONAUT_RESOURCE_HREF_PATTERNS;
+      delete process.env.TESTRONAUT_RESOURCE_DATA_TYPES;
+    });
+    afterEach(() => {
+      process.env = { ...OLD_ENV };
+    });
+
+    it('returns defaults when nothing is set', () => {
+      const res = getResourceGuardConfig({});
+      expect(res.enabled).toBe(true);
+      expect(res.hrefIncludes.length).toBeGreaterThan(0);
+      expect(res.dataTypes).toContain('document');
+    });
+
+    it('respects env toggles and lists', () => {
+      process.env.TESTRONAUT_RESOURCE_GUARD = 'false';
+      process.env.TESTRONAUT_RESOURCE_HREF_PATTERNS = '/a,/b';
+      process.env.TESTRONAUT_RESOURCE_DATA_TYPES = 'doc,file';
+      const res = getResourceGuardConfig({ resourceGuard: { enabled: true } });
+      expect(res.enabled).toBe(false);
+      expect(res.hrefIncludes).toEqual(['/a', '/b']);
+      expect(res.dataTypes).toEqual(['doc', 'file']);
+    });
+
+    it('falls back to config arrays when env missing', () => {
+      const res = getResourceGuardConfig({
+        resourceGuard: {
+          enabled: 'yes',
+          hrefIncludes: ['/x', '/y'],
+          dataTypes: ['row'],
+        },
+      });
+      expect(res.enabled).toBe(true);
+      expect(res.hrefIncludes).toEqual(['/x', '/y']);
+      expect(res.dataTypes).toEqual(['row']);
+    });
+  });
+
   describe('enforceTurnBudget (lenient)', () => {
     it('clamps > hardMaxTurns', () => {
       const cfg = { maxTurns: 1000 };

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() {
@@ -226,4 +228,47 @@ describe('turnLoop', () => {
     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

@@ -10,19 +10,25 @@ 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, getRetryLimit } 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 () => {
@@ -50,7 +56,7 @@ describe('cli/testronaut.runMissions (with enforceTurnBudget)', () => {
       expect.stringContaining('Clamping to 200')
     );
     expect(runAgent).toHaveBeenCalledWith(
-      expect.any(Array), 'Budgeted Run', 200, 2
+      expect.any(Array), 'Budgeted Run', 200, 2, { domListLimit: 3, debug: false, resourceGuard: { enabled: true, hrefIncludes: ['/document/'], dataTypes: ['document'] } }
     );
 
     warn.mockRestore();
@@ -77,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, 3);
+    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();
@@ -144,7 +176,7 @@ describe('cli/testronaut.runMissions (with enforceTurnBudget)', () => {
     expect(goals[1].submissionName).toMatch(/^My Mission/);
 
     // Effective max turns and retry limit passed through
-    expect(runAgent).toHaveBeenCalledWith(expect.any(Array), 'My Mission', 15, 2);
+    expect(runAgent).toHaveBeenCalledWith(expect.any(Array), 'My Mission', 15, 2, { domListLimit: 3, debug: false, resourceGuard: { enabled: true, hrefIncludes: ['/document/'], dataTypes: ['document'] } });
 
     log.mockRestore();
   });
@@ -166,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/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');
+  });
+});