testronaut 1.0.25 → 1.0.27

package/core/turnLoop.js

@@ -21,6 +21,14 @@ let turnTimestamps = [];
 let shouldBackoff;
 let steps = [];
 
+function formatBytes(n) {
+  if (!Number.isFinite(n)) return `${n}`;
+  const u = ['B','KB','MB','GB','TB'];
+  let i = 0, v = n;
+  while (v >= 1024 && i < u.length - 1) { v /= 1024; i++; }
+  return `${v.toFixed(v >= 10 || i === 0 ? 0 : 1)} ${u[i]}`;
+}
+
 const pushDOMAssistant = async (browser, messages, agentMemory, { skipIfLastTool } = {}) => {
   if (skipIfLastTool && skipIfLastTool.includes(messages.at(-1)?.name)) {
     console.log(`[skip] Skipping DOM push after redundant tool: ${messages.at(-1)?.name}`);
@@ -187,6 +195,25 @@ export const turnLoop = async (
           result = errorMessage;
         }
 
+        // ------ Capture file upload/download events for mission report ------
+        try {
+          const maybeJson = JSON.parse(result);
+          if (maybeJson && maybeJson._testronaut_file_event) {
+            currentStep.files = currentStep.files || [];
+            currentStep.files.push(maybeJson);
+
+            if (maybeJson._testronaut_file_event === 'upload') {
+              const msgLine = `📤 Uploaded "${maybeJson.fileName}" (${formatBytes(maybeJson.bytes)}) via ${maybeJson.method}`;
+              currentStep.events.push(msgLine);
+              console.log(msgLine);
+            } else if (maybeJson._testronaut_file_event === 'download') {
+              const msgLine = `📥 Downloaded "${maybeJson.fileName}" (${formatBytes(maybeJson.bytes)}) via ${maybeJson.mode}`;
+              currentStep.events.push(msgLine);
+              console.log(msgLine);
+            }
+          }
+        } catch { /* not JSON / ignore */ }
+
         console.log(`[tool ] ← ${fnName} result:`, errorMessage ? '❌ Failed' : '✅ Success');
         currentStep.events.push(`[tool ] ← ${fnName} result: ${errorMessage ? '❌ Failed' : '✅ Success'}`)
         const truncated = result.length > 100 ? result.slice(0, 100) + '…' : result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testronaut",
-  "version": "1.0.25",
+  "version": "1.0.27",
   "main": "./runner/testronaut.js",
   "bin": {
     "testronaut": "./bin/cli.js"

package/tools/chromeBrowser.js

@@ -19,8 +19,26 @@ import {
   removeObfuscatedClassNames, 
 } from './domControl.js';
 import fs from 'fs';
+import path from 'path';
 import { ensureBrowsers } from '../tools/playwrightSetup.js';
 
+const FILES_DIR = path.join('missions', 'files');
+const REPORTS_DIR = path.join('missions', 'mission_reports');
+const FILES_LOG = path.join(REPORTS_DIR, 'files.jsonl');
+
+function ensureDir(p) {
+  try { fs.mkdirSync(p, { recursive: true }); } catch {}
+}
+
+function appendFileEvent(eventObj = {}) {
+  try {
+    ensureDir(REPORTS_DIR);
+    fs.appendFileSync(FILES_LOG, JSON.stringify(eventObj) + '\n', 'utf8');
+  } catch (e) {
+    console.warn('⚠️ Could not append file event:', e?.message);
+  }
+}
+
 export class ChromeBrowser {
   constructor() {
     this.browser = null;
@@ -504,11 +522,24 @@ export class ChromeBrowser {
     throw new Error('Could not input text with any strategy');
   }
 
+  _chromiumLaunchArgsForCI() {
+    const inCI = !!(process.env.CI || process.env.GITHUB_ACTIONS || process.env.TESTRONAUT_CI_CHROMIUM);
+    return inCI ? ['--no-sandbox', '--disable-setuid-sandbox'] : [];
+  }
+
 
   async start() {
     try {
       const pw = await loadPlaywright();
-      this.browser = await pw.chromium.launch({ headless: true });    
+      const launchArgs = [
+       '--disable-dev-shm-usage',
+       '--disable-gpu',
+       ...this._chromiumLaunchArgsForCI(),
+     ];
+      this.browser = await pw.chromium.launch({ 
+        headless: true,
+        args: launchArgs,
+      });    
     } catch (err) {
       const msg = String(err?.message || err);
       const needsInstall =
@@ -525,9 +556,24 @@ export class ChromeBrowser {
 
       // Retry
       const pw = await loadPlaywright();
-      return await pw.chromium.launch({ headless: true });
+      const launchArgs = [
+        '--disable-dev-shm-usage',
+        '--disable-gpu',
+        ...this._chromiumLaunchArgsForCI(),
+      ];
+      this.browser = await pw.chromium.launch({
+        headless: true,
+        args: launchArgs,
+      });
+      // return await pw.chromium.launch({ headless: true });
     }
-    this.context = await this.browser.newContext();
+
+    ensureDir(FILES_DIR); // ⬅️ make sure missions/files exists
+
+    this.context = await this.browser.newContext({
+      acceptDownloads: true // ⬅️ important for Playwright download handling
+    });
+    // this.context = await this.browser.newContext();
     const first = await this.context.newPage();
     const id = this._addAndFocus(first);
 
@@ -740,34 +786,97 @@ export class ChromeBrowser {
 
 
 
-  async get_dom({ limit = 100000, exclude = true, focus = [] }, agentMemory = {}) {
-    let html;
+  async get_dom(
+    { limit = 100000, exclude = true, focus = [], loadState = 'networkidle', timeout = 10000 } = {},
+    agentMemory = {}
+  ) {
+    // --- 1) Ensure we have a live page ---
+    const hasContext = !!this.context;
+
+    // Recover a page if missing/closed
+    const recoverPage = async () => {
+      if (hasContext) {
+        const pages = (this.context.pages?.() || []).filter(p => !p.isClosed?.());
+        if (pages.length) {
+          // Prefer the last page (often the active one / popup)
+          this.page = pages[pages.length - 1];
+          return;
+        }
+        // No pages at all in a live context -> make one
+        this.page = await this.context.newPage();
+        return;
+      }
+      // No context yet but a browser exists -> create context + page
+      if (this.browser?.newContext) {
+        this.context = await this.browser.newContext();
+        this.page = await this.context.newPage();
+        return;
+      }
+      throw new Error('No browser context/page available in get_dom().');
+    };
+
+    if (!this.page || this.page.isClosed?.()) {
+      await recoverPage();
+    }
+
+    // --- 2) Try to reach a usable load state (best-effort) ---
     try {
-      html = await this.page.content();
-    } catch (err) {
-      console.warn('⚠️ get_dom retrying due to navigation:', err.message);
-      // Wait for navigation to settle
-      await this.page.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => {});
-      html = await this.page.content();
+      await this.page.waitForLoadState(loadState, { timeout });
+    } catch {
+      // Non-fatal: some apps never reach 'load', we’ll still try to read the DOM.
+    }
+
+    // If navigation changed active page (e.g., popup), reselect a live page
+    try {
+      const pages = this.context?.pages?.() || [];
+      if (pages.length && (this.page.isClosed?.() || !pages.includes(this.page))) {
+        this.page = pages[pages.length - 1];
+      }
+    } catch { /* ignore */ }
+
+    // --- 3) Get HTML content with a small retry on failure ---
+    let html = '';
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        html = await this.page.content();
+        if (html && html.trim()) break;
+      } catch (err) {
+        // First failure: try waiting for network to settle, then retry
+        if (attempt === 0) {
+          try { await this.page.waitForLoadState('networkidle', { timeout: 5000 }); } catch {}
+          // Also re-check active page (popups can swap)
+          try {
+            const pages = this.context?.pages?.() || [];
+            if (pages.length) this.page = pages[pages.length - 1];
+          } catch {}
+        } else {
+          // Second failure: bubble up a clearer message
+          throw new Error(`get_dom() failed to read page content: ${err?.message || err}`);
+        }
+      }
     }
+
+    // Fallback to empty string if still nothing (keeps caller logic simple)
+    if (!html) html = '';
+
+    // --- 4) Optional DOM reduction/cleanup (your existing steps) ---
     let $ = cheerio.load(html);
-    
-    // Remove non-content tags
+
     if (exclude) {
       $ = await removeNonContentTags($);
-      // console.log('🔧 Non-content tags removed from DOM.');
       $ = await reduceRepeatedDivs($);
-      // console.log('🔧 Repeated divs reduced in DOM.');
+      // If you later re-enable:
       // $ = await removeObfuscatedClassNames($);
-      // console.log('🔧 Obfuscated class names removed from DOM.')
       // $ = await removeAutoGeneratedClasses($);
-      // console.log('🔧 Auto-generated classes removed from DOM.');
     }
-    // console.log('🔧 DOM cleaned up:', $);
+
+    // (Optional: If you'd like to use `focus`, you could filter here by selectors/keywords.)
+
+    // --- 5) Return trimmed HTML ---
     const finalHtml = $.html();
-    const trimmed = finalHtml.slice(0, limit);
-    return trimmed; 
+    return finalHtml.slice(0, limit);
   }
+
   
   async check_text({ text }) {
     const html = await this.page.content();
@@ -906,7 +1015,127 @@ export class ChromeBrowser {
     return `Screenshot saved at: ./screenshots/${name}_${timestamp}.png`;
   }
   
-  
+  async upload_file({ selector, fileName, useChooser = false, timeoutMs = 15000 }) {
+    if (!selector) throw new Error('upload_file: selector is required');
+    if (!fileName) throw new Error('upload_file: fileName is required');
+
+    ensureDir(FILES_DIR);
+    const filePath = path.resolve(FILES_DIR, fileName);
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`upload_file: file not found at ${filePath}`);
+    }
+
+    await this.page.waitForSelector(selector, { timeout: timeoutMs });
+
+    let method = 'input';
+    if (useChooser) {
+      method = 'chooser';
+      const [fileChooser] = await Promise.all([
+        this.page.waitForEvent('filechooser', { timeout: timeoutMs }),
+        this.page.click(selector, { timeout: timeoutMs })
+      ]);
+      await fileChooser.setFiles(filePath);
+    } else {
+      const input = this.page.locator(selector).first();
+      await input.waitFor({ state: 'visible', timeout: timeoutMs }).catch(() => {});
+      await input.setInputFiles(filePath, { timeout: timeoutMs });
+    }
+
+    const stats = fs.statSync(filePath);
+    const payload = {
+      _testronaut_file_event: 'upload',
+      method,                       // 'input' | 'chooser'
+      fileName,
+      sourcePath: filePath,
+      bytes: stats.size,
+      selector,
+      ts: new Date().toISOString()
+    };
+
+    appendFileEvent(payload);
+    return JSON.stringify(payload);
+  }
+
+
+  async download_file({ selector, url, fileName, timeoutMs = 30000 }) {
+    ensureDir(FILES_DIR);
+
+    if (!selector && !url) {
+      throw new Error('download_file: provide either selector or url');
+    }
+
+    const sanitize = (name) => name.replace(/[\\/:*?"<>|]+/g, '_').trim();
+
+    // Mode 1: page click triggers a browser download
+    if (selector) {
+      await this.page.waitForSelector(selector, { timeout: timeoutMs });
+
+      const [download] = await Promise.all([
+        this.page.waitForEvent('download', { timeout: timeoutMs }),
+        this.page.click(selector)
+      ]);
+
+      const suggested = sanitize(download.suggestedFilename?.() || 'download.bin');
+      const targetPath = path.join(FILES_DIR, sanitize(fileName || suggested));
+      await download.saveAs(targetPath);
+
+      const stats = fs.statSync(targetPath);
+      const payload = {
+        _testronaut_file_event: 'download',
+        mode: 'click',
+        fileName: path.basename(targetPath),
+        destPath: targetPath,
+        bytes: stats.size,
+        selector,
+        url: null,
+        ts: new Date().toISOString()
+      };
+
+      appendFileEvent(payload);
+      return JSON.stringify(payload);
+    }
+
+    // Mode 2: direct URL fetch (no page interaction)
+    const res = await fetch(url);
+    if (!res.ok) {
+      throw new Error(`download_file: GET ${url} failed with ${res.status}`);
+    }
+
+    // Try to infer a filename if not provided
+    const cd = res.headers.get('content-disposition') || '';
+    let inferred = 'download.bin';
+    const match = /filename\*=UTF-8''([^;]+)|filename="([^"]+)"/i.exec(cd);
+    if (match) {
+      inferred = decodeURIComponent(match[1] || match[2]);
+    } else {
+      try {
+        const u = new URL(url);
+        const tail = u.pathname.split('/').filter(Boolean).pop();
+        if (tail) inferred = tail;
+      } catch {}
+    }
+
+    const targetPath = path.join(FILES_DIR, sanitize(fileName || inferred));
+    const buf = Buffer.from(await res.arrayBuffer());
+    fs.writeFileSync(targetPath, buf);
+
+    const stats = fs.statSync(targetPath);
+    const payload = {
+      _testronaut_file_event: 'download',
+      mode: 'url',
+      fileName: path.basename(targetPath),
+      destPath: targetPath,
+      bytes: stats.size,
+      selector: null,
+      url,
+      ts: new Date().toISOString()
+    };
+
+    appendFileEvent(payload);
+    return JSON.stringify(payload);
+  }
+
+
   async close() {
     await this.browser?.close();
   }
@@ -931,4 +1160,6 @@ export const CHROME_TOOL_MAP = {
   click_and_follow_popup: (b, args) => b.click_and_follow_popup(args),
   switch_to_page: (b, args) => b.switch_to_page(args),
   close_current_page: (b, args) => b.close_current_page(args),
+  upload_file: (b, args) => b.upload_file(args),
+  download_file: (b, args) => b.download_file(args),
 };

package/tools/toolSchema.js

@@ -174,59 +174,118 @@ const toolsSchema = [
     },
   },
   {
-  type: 'function',
-  function: {
-    name: 'click_and_follow_popup',
-    description:
-      'Click a selector that opens a new tab/window (e.g., OAuth) and switch control to it. Falls back to same-tab navigation if no popup appears.',
-    parameters: {
-      type: 'object',
-      properties: {
-        selector: { type: 'string', description: 'CSS or text selector to click' },
-        expectedUrlHost: {
-          type: 'string',
-          description: "Optional hostname hint like 'accounts.google.com'"
+    type: 'function',
+    function: {
+      name: 'click_and_follow_popup',
+      description:
+        'Click a selector that opens a new tab/window (e.g., OAuth) and switch control to it. Falls back to same-tab navigation if no popup appears.',
+      parameters: {
+        type: 'object',
+        properties: {
+          selector: { type: 'string', description: 'CSS or text selector to click' },
+          expectedUrlHost: {
+            type: 'string',
+            description: "Optional hostname hint like 'accounts.google.com'"
+          },
+          timeoutMs: {
+            type: 'number',
+            default: 20000,
+            description: 'How long to wait for the popup or navigation'
+          }
         },
-        timeoutMs: {
-          type: 'number',
-          default: 20000,
-          description: 'How long to wait for the popup or navigation'
-        }
-      },
-      required: ['selector']
+        required: ['selector']
+      }
     }
-  }
-},
-{
-  type: 'function',
-  function: {
-    name: 'switch_to_page',
-    description:
-      "Switch agent focus between known tabs/pages (e.g., back to 'main' or to the latest popup). Use a pageId previously returned by click_and_follow_popup to target a specific tab.",
-    parameters: {
-      type: 'object',
-      properties: {
-        target: {
-          type: 'string',
-          description: "One of: 'main', 'latest', or a pageId returned by click_and_follow_popup"
-        }
-      },
-      required: ['target']
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'switch_to_page',
+      description:
+        "Switch agent focus between known tabs/pages (e.g., back to 'main' or to the latest popup). Use a pageId previously returned by click_and_follow_popup to target a specific tab.",
+      parameters: {
+        type: 'object',
+        properties: {
+          target: {
+            type: 'string',
+            description: "One of: 'main', 'latest', or a pageId returned by click_and_follow_popup"
+          }
+        },
+        required: ['target']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'close_current_page',
+      description:
+        'Close the current tab/page and automatically switch back to another open page if available.',
+      parameters: { type: 'object', properties: {} }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'upload_file',
+      description:
+        'Upload a file into an <input type="file"> or via a file chooser. Defaults to missions/files as the file source.',
+      parameters: {
+        type: 'object',
+        properties: {
+          selector: {
+            type: 'string',
+            description: 'CSS selector for the file input or a button that opens a file chooser'
+          },
+          fileName: {
+            type: 'string',
+            description: 'File name located in missions/files (e.g., "sample.pdf")'
+          },
+          useChooser: {
+            type: 'boolean',
+            default: false,
+            description: 'If true, click the selector and fulfill the file chooser instead of setInputFiles'
+          },
+          timeoutMs: {
+            type: 'number',
+            default: 15000
+          }
+        },
+        required: ['selector', 'fileName']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'download_file',
+      description:
+        'Download a file to missions/files. Either click a selector that triggers a download or fetch a direct URL.',
+      parameters: {
+        type: 'object',
+        properties: {
+          selector: {
+            type: 'string',
+            description: 'An element to click that triggers a download'
+          },
+          url: {
+            type: 'string',
+            description: 'Direct URL to download without clicking the page'
+          },
+          fileName: {
+            type: 'string',
+            description: 'Optional override for the saved filename'
+          },
+          timeoutMs: {
+            type: 'number',
+            default: 30000
+          }
+        },
+        // At least one of selector or url should be provided (enforced in code)
+        required: []
+      }
     }
   }
-},
-{
-  type: 'function',
-  function: {
-    name: 'close_current_page',
-    description:
-      'Close the current tab/page and automatically switch back to another open page if available.',
-    parameters: { type: 'object', properties: {} }
-  }
-}
-
-  
-    
 ];
 
 export default toolsSchema;