testronaut 1.1.0 → 1.1.1

package/core/redaction.js

@@ -0,0 +1,79 @@
+// core/redaction.js
+
+function clone(obj) {
+  try { return structuredClone(obj); } catch { return JSON.parse(JSON.stringify(obj ?? {})); }
+}
+
+export function maskPreview(val, showLength = true) {
+  const s = String(val ?? '');
+  if (!s) return '••••••';
+  // Show length for debugging without leaking the value
+  return showLength ? `•••••• (${s.length})` : '••••••';
+}
+
+function hasPasswordHint(str = '') {
+  return /\b(pass(word)?|pwd|passwd)\b/i.test(String(str || ''));
+}
+
+function isPasswordCall(fnName, args = {}) {
+  if (!(fnName === 'type' || fnName === 'fill')) return false;
+  const { selector, label, placeholder, name, inputType, role, testId } = args;
+  return (
+    hasPasswordHint(selector) ||
+    hasPasswordHint(label) ||
+    hasPasswordHint(placeholder) ||
+    hasPasswordHint(name) ||
+    String(inputType || '').toLowerCase() === 'password' ||
+    hasPasswordHint(role) ||
+    hasPasswordHint(testId)
+  );
+}
+
+/**
+ * Redact ONLY password values in tool args:
+ * - Applies to type/fill on password-looking fields
+ * - Also masks any arg property explicitly named password/pwd/passwd (shallow)
+ */
+export function redactArgs(fnName, args = {}, { showLength = true } = {}) {
+  const out = clone(args);
+
+  // Mask direct props named password/pwd/passwd if present
+  for (const k of Object.keys(out || {})) {
+    if (hasPasswordHint(k)) {
+      out[k] = maskPreview(out[k], showLength);
+    }
+  }
+
+  // For typing into a password field, mask the value
+  if (isPasswordCall(fnName, args)) {
+    if ('text'  in out) out.text  = maskPreview(out.text, showLength);
+    if ('value' in out) out.value = maskPreview(out.value, showLength);
+    if ('input' in out) out.input = maskPreview(out.input, showLength);
+    if ('keys'  in out) out.keys  = maskPreview(out.keys, showLength);
+  }
+
+  return out;
+}
+
+/**
+ * Redact password literals in freeform mission text.
+ * Heuristic: look for the word "password" then the next quoted string OR
+ * a token after "with|as|to|=" within ~80 chars.
+ */
+export function redactPasswordInText(text = '', { showLength = true } = {}) {
+  let s = String(text ?? '');
+
+  // Case 1: password ... "VALUE"
+  s = s.replace(
+    /(\bpassword\b[^"'\\\n]{0,80}["'])([^"']+)(["'])/gi,
+    (_m, pre, pwd, post) => pre + maskPreview(pwd, showLength) + post
+  );
+
+  // Case 2: password ... (with|as|to|=) VALUE
+  s = s.replace(
+    /(\bpassword\b[^.\n]{0,80}?\b(with|as|to|=)\s*)([^\s"'`]+)/gi,
+    (_m, pre, _kw, pwd) => pre + maskPreview(pwd, showLength)
+  );
+
+  return s;
+}

package/core/turnIntent.js

@@ -0,0 +1,64 @@
+import { redactArgs } from './redaction.js';
+
+export function truncateMiddle(str = '', max = 80) {
+  if (!str || str.length <= max) return str;
+  const half = Math.floor((max - 1) / 2);
+  return `${str.slice(0, half)}…${str.slice(-half)}`;
+}
+
+function pickArg(args, keys) {
+  for (const k of keys) {
+    if (args?.[k] != null && String(args[k]).trim() !== '') return String(args[k]);
+  }
+  return null;
+}
+
+export function summarizeToolCall(fnName, args = {}) {
+  const safeArgs = redactArgs(fnName, args);
+
+  const selector = pickArg(safeArgs, ['selector','xpath','css','role','testId']);
+  const text     = pickArg(safeArgs, ['text','value','keys','input','query','label']);
+  const url      = pickArg(safeArgs, ['url','href','to']);
+  const file     = pickArg(safeArgs, ['filePath','fileName','downloadPath']);
+  const x        = pickArg(safeArgs, ['x']);
+  const y        = pickArg(safeArgs, ['y']);
+  const timeout  = pickArg(safeArgs, ['timeoutMs','timeout']);
+
+  const sel = selector ? ` (${truncateMiddle(selector, 60)})` : '';
+  const val = text ? ` "${truncateMiddle(text, 60)}"` : '';
+  const tmo = timeout ? ` [≤${timeout}ms]` : '';
+
+  switch (fnName) {
+    case 'navigate': return `Navigate to ${truncateMiddle(url || '(no url)', 80)}`;
+    case 'click_text': return `Click text${val}`;
+    case 'click': return `Click element${sel}`;
+    case 'type':
+    case 'fill': return `Type${val}${selector ? ` into ${truncateMiddle(selector, 60)}` : ''}`;
+    case 'press': return `Press key${val || ''}${selector ? ` in ${truncateMiddle(selector, 60)}` : ''}`;
+    case 'hover': return `Hover over${sel || val || ''}`;
+    case 'wait_for_selector': return `Wait for${sel}${tmo}`;
+    case 'wait': return `Wait${tmo || ''}`;
+    case 'screenshot': return `Capture screenshot${selector ? ` of ${truncateMiddle(selector, 60)}` : ''}`;
+    case 'get_dom': return `Inspect DOM (focused extract)`;
+    case 'check_text': return `Check page for${val || ' specific text'}`;
+    case 'scroll': return `Scroll to coords (${x ?? '?'}, ${y ?? '?'})`;
+    case 'upload_file': return `Upload file ${truncateMiddle(file || '(unknown)', 60)}${selector ? ` via ${truncateMiddle(selector, 60)}` : ''}`;
+    case 'download_file': return `Download file to ${truncateMiddle(file || '(unknown)', 60)}`;
+    case 'expand_menu': return `Expand menu${sel || ''}`;
+    case 'set_viewport': return `Set viewport ${safeArgs?.width}×${safeArgs?.height}`;
+    default:
+      return `Run ${fnName} with ${truncateMiddle(JSON.stringify(safeArgs ?? {}), 80)}`;
+  }
+}
+
+export function summarizeTurnIntentFromMessage(msg) {
+  try {
+    if (msg?.tool_calls?.length) {
+      return msg.tool_calls
+        .map(c => summarizeToolCall(c.function?.name || 'unknown', JSON.parse(c.function?.arguments || '{}')))
+        .join(' → ');
+    }
+    if (msg?.content) return `Reasoning: ${truncateMiddle(msg.content, 120)}`;
+  } catch {}
+  return 'No intent detected';
+}

package/core/turnLoop.js

@@ -16,6 +16,8 @@ import {
   updateLimitsFromHeaders
 } from '../tools/tokenControl.js';
 import { resolveModel } from '../openAI/modelResolver.js';
+import { summarizeTurnIntentFromMessage } from './turnIntent.js';
+import { redactArgs } from './redaction.js';
 
 
 const MODEL_ID = resolveModel();
@@ -178,6 +180,11 @@ export const turnLoop = async (
     
     const msg = response.choices[0].message;
 
+    const planLine = summarizeTurnIntentFromMessage(msg);
+    currentStep.summary = planLine;
+    currentStep.events.unshift(`📝 Plan: ${planLine}`);
+    console.log(`📝 Plan: ${planLine}`);
+
     if (msg.tool_calls?.length) {
       console.log('Processing tool calls...');
       const toolResponses = [];
@@ -187,8 +194,9 @@ export const turnLoop = async (
         const fnName = call.function.name;
         lastToolName = fnName;
         const args = JSON.parse(call.function.arguments || '{}');
-        console.log(`[model] → ${fnName}`, args);
-        currentStep.events.push(`[model] → ${fnName} ${args}`);
+        const safeArgs = redactArgs(fnName, args);
+        console.log(`[model] → ${fnName}`, safeArgs);
+        currentStep.events.push(`[model] → ${fnName} ${safeArgs}`);
         // console.log('Calling tool:', fnName);
         let result;
         let errorMessage = null;

package/package.json

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

package/runner/testronaut.js

@@ -1,37 +1,68 @@
 import { runAgent } from '../core/agent.js';
-import { runSuite } from './suiteRunner.js';
+import { redactPasswordInText } from '../core/redaction.js';
+// import { runSuite } from './suiteRunner.js';
 
-const objectives = [];
+// const objectives = [];
 
-export function mission(title, fn) {
-  console.log(`\n🚀 Mission: ${title}`);
-  fn();
-}
+// export function mission(title, fn) {
+//   console.log(`\n🚀 Mission: ${title}`);
+//   fn();
+// }
+
+// export function objective(desc, workflow) {
+//   objectives.push({ name: desc, workflow });
+// }
+
+// export async function launch(preMissionSetup) {
+//   await runSuite(objectives, preMissionSetup);
+// }
 
-export function objective(desc, workflow) {
-  objectives.push({ name: desc, workflow });
-}
 
-export async function launch(preMissionSetup) {
-  await runSuite(objectives, preMissionSetup);
-}
 
 export async function runMissions({ preMission, mission, postMission }, missionName) {
   const normalizeToArray = (x) => (Array.isArray(x) ? x : x ? [x] : []);
-  
-  const pre = normalizeToArray(preMission);
+
+  const pre  = normalizeToArray(preMission);
   const main = normalizeToArray(mission);
   const post = normalizeToArray(postMission);
 
   const goals = [];
 
+  const pickName = (kind, fn, i) => {
+    const baseFallback =
+      kind === 'premission'   ? `pre-${i + 1}` :
+      kind === 'postmission'  ? `post-${i + 1}` :
+                                `mission-${i + 1}`;
+
+    // MAIN mission: prefer the missionName argument
+    if (kind === 'mission') {
+      if (missionName) {
+        // if multiple main items, disambiguate nicely
+        const suffix = main.length > 1 ? ` (${i + 1}/${main.length})` : '';
+        return `${missionName}${suffix}`;
+      }
+      // no missionName: if mission is a string, derive from its first non-empty line
+      if (typeof fn === 'string') {
+        const firstLine = (fn.trim().split('\n').find(Boolean) || fn.trim()).slice(0, 60);
+        return firstLine.length === 60 ? `${firstLine}…` : firstLine || baseFallback;
+      }
+    }
+
+    // PRE/POST (and fallback for mission): prefer author-provided labels on the function
+    const explicit =
+      fn?.submissionName || fn?.displayName || fn?.title || fn?.name;
+    if (explicit && String(explicit).trim()) return String(explicit).trim();
+
+    return baseFallback;
+  };
+
   if (pre.length) {
     goals.push(
       ...pre.map((fn, i) => ({
         goal: fn,
-        label: 'pre-mission',              // legacy label
-        submissionType: 'premission',      // normalized
-        submissionName: fn?.name || `pre-${i + 1}`,
+        label: 'pre-mission',          // legacy label (kept for logs)
+        submissionType: 'premission',  // normalized
+        submissionName: pickName('premission', fn, i),
       }))
     );
   }
@@ -42,7 +73,7 @@ export async function runMissions({ preMission, mission, postMission }, missionN
         goal: fn,
         label: 'mission',
         submissionType: 'mission',
-        submissionName: fn?.name || `mission-${i + 1}`,
+        submissionName: pickName('mission', fn, i),
       }))
     );
   }
@@ -53,28 +84,30 @@ export async function runMissions({ preMission, mission, postMission }, missionN
         goal: fn,
         label: 'post-mission',
         submissionType: 'postmission',
-        submissionName: fn?.name || `post-${i + 1}`,
+        submissionName: pickName('postmission', fn, i),
       }))
     );
   }
 
   console.log(
     '\n🧭 Running mission flow:\n',
-    goals.map(g => `${g.label}: ${g.goal?.name ?? g.goal}`)
+    goals.map(g => {
+      if (typeof g.goal === 'string') {
+        // redact only the password literal in the human-readable mission text
+        return `${g.label}: ${redactPasswordInText(g.goal)}`;
+      }
+      return `${g.label}: ${g.goal?.name || g.submissionName || g.goal}`;
+    })
   );
-  
+
   const success = await runAgent(goals, missionName);
   if (!success) {
     console.log(`❌ Aborting after failed goal.`);
     return;
   }
-  // console.log("success[0]: ", success[0]);
-  // console.log("success[0].steps.length: ", success[0].steps.length);
-  // console.log("success[0].steps[success[0].steps.length - 1].result: ", success[0].steps[success[0].steps.length - 1].result)
+
   const missionStatus = success[0].steps[success[0].steps.length - 1].result;
-  // console.log("missionStatus: ", missionStatus)
   if (missionStatus.toLowerCase().includes('failure')) {
-    // console.log("we detected the failure!")
     success[0].status = 'failed';
   }
   console.log('\n✅ Mission flow complete.');

package/tools/generateHtmlReport.js

@@ -13,6 +13,7 @@ export function generateHtmlReport(report, outputPath) {
   const esc = (s) => String(s ?? '')
     .replace(/&/g, '&amp;').replace(/</g, '&lt;')
     .replace(/>/g, '&gt;');
+  const escAttr = (s) => esc(s).replace(/"/g, '&quot;'); // for HTML attributes
   const badge = (status) =>
     status === 'passed' ? '✅ Passed' :
     status === 'failed' ? '❌ Failed' : (status || '—');
@@ -31,10 +32,18 @@ export function generateHtmlReport(report, outputPath) {
         ? `<img src="${esc(step.screenshotPath)}" alt="screenshot turn ${esc(step.turn ?? idx)}">`
         : '';
 
+      const plan = (typeof step.summary === 'string' && step.summary.trim())
+        ? step.summary.trim()
+        : '';
+      const planSpan = plan
+        ? `<span class="plan" title="${escAttr(plan)}">${esc(plan)}</span>`
+        : '';
+
       return `
         <details class="step" ${ok ? '' : 'open'}>
           <summary>
             <span class="turn">Turn ${esc((step.turn ?? idx) + 1)}</span>
+            ${planSpan}
             <span class="step-result ${ok ? 'ok' : 'bad'}">${esc(step.result || '—')}</span>
             <span class="tokens">tokens: ${esc(step.tokensUsed ?? '—')} / total: ${esc(step.totalTokensUsed ?? '—')}</span>
           </summary>
@@ -210,6 +219,10 @@ export function generateHtmlReport(report, outputPath) {
     .step summary:hover{ background: rgba(255,255,255,.08); }
 
     .turn{ font-weight:700; }
+    .plan{
+      flex:1; color: var(--text-muted); font-size:12px;
+      white-space:nowrap; overflow:hidden; text-overflow:ellipsis;
+    }
     .step-result.ok{ color: var(--ok); font-weight:700; }
     .step-result.bad{ color: var(--bad); font-weight:700; }
     .tokens{ color: var(--text-muted); font-size:12px; margin-left:auto; font-variant-numeric: tabular-nums; }