@q-agent/agent 0.1.11 → 0.1.13

package/dist/src/playwrightConfig.js

@@ -49,14 +49,14 @@ const PLAYWRIGHT_CONFIG_TEMPLATE = `import { defineConfig } from '@playwright/te
 
 export default defineConfig({
   testDir: '.',
-  timeout: 30000,
+  timeout: __TIMEOUT__,
   workers: __WORKERS__,
   reporter: [['json', { outputFile: 'report.json' }]],
   use: {
     headless: __HEADLESS__,
     screenshot: 'only-on-failure',
-    video: 'retain-on-failure',
-    trace: 'retain-on-failure',
+    video: '__VIDEO__',
+    trace: '__TRACE__',
 __EXTRA_USE__  },
 });
 `;
@@ -69,16 +69,26 @@ __EXTRA_USE__  },
  * @param headless Whether the browser runs headless.
  * @param baseUrl When non-empty, injected as `use.baseURL`.
  * @param storageState When non-empty, an absolute path injected as `use.storageState`.
+ * @param opts Heal-tuning knobs (timeouts + evidence); defaults match a normal run.
  */
-function writeConfig(specDir, workers, headless, baseUrl = "", storageState = "") {
+function writeConfig(specDir, workers, headless, baseUrl = "", storageState = "", opts = {}) {
+    const { testTimeoutMs = 30000, actionTimeoutMs, heavyEvidence = true } = opts;
     const extraLines = [];
     if (baseUrl)
         extraLines.push(`    baseURL: ${JSON.stringify(baseUrl)},`);
     if (storageState)
         extraLines.push(`    storageState: ${JSON.stringify(storageState)},`);
+    if (actionTimeoutMs != null) {
+        extraLines.push(`    actionTimeout: ${Math.trunc(actionTimeoutMs)},`);
+        extraLines.push(`    navigationTimeout: ${Math.trunc(actionTimeoutMs)},`);
+    }
     const extraUse = extraLines.length ? extraLines.join("\n") + "\n" : "";
-    const content = PLAYWRIGHT_CONFIG_TEMPLATE.replace("__WORKERS__", String(workers))
+    const retain = heavyEvidence ? "retain-on-failure" : "off";
+    const content = PLAYWRIGHT_CONFIG_TEMPLATE.replace("__TIMEOUT__", String(Math.trunc(testTimeoutMs)))
+        .replace("__WORKERS__", String(workers))
         .replace("__HEADLESS__", headless ? "true" : "false")
+        .replace("__VIDEO__", retain)
+        .replace("__TRACE__", retain)
         .replace("__EXTRA_USE__", extraUse);
     fs.writeFileSync(path.join(specDir, "playwright.config.ts"), content, "utf-8");
 }
@@ -102,7 +112,7 @@ function writeConfig(specDir, workers, headless, baseUrl = "", storageState = ""
  * @param replaySession Whether to inject the sessionStorage-replay `context`
  *   override (DOM capture is always injected regardless).
  */
-function fixturesTs(sessionFile, replaySession) {
+function fixturesTs(sessionFile, replaySession, captureRaw = true) {
     const contextFixture = replaySession
         ? "  context: async ({ context }, use) => {\n" +
             "    await context.addInitScript((sessions: Record<string, Record<string, string>>) => {\n" +
@@ -114,6 +124,14 @@ function fixturesTs(sessionFile, replaySession) {
             "    await use(context);\n" +
             "  },\n"
         : "";
+    const rawBlock = captureRaw
+        ? "    try {\n" +
+            "      const raw = await page.content();\n" +
+            "      const rawPath = testInfo.outputPath('qagent-dom-raw.html');\n" +
+            "      fs.writeFileSync(rawPath, raw, 'utf-8');\n" +
+            "      await testInfo.attach('qagent-dom-raw', { path: rawPath, contentType: 'text/html' });\n" +
+            "    } catch {}\n"
+        : "";
     return ("import { test as base, expect } from '@playwright/test';\n" +
         "import * as fs from 'fs';\n" +
         "\n" +
@@ -127,35 +145,42 @@ function fixturesTs(sessionFile, replaySession) {
         "  // runner (evidence) and self-heal loop (real selectors) can use it.\n" +
         "  _domCapture: [async ({ page }, use, testInfo) => {\n" +
         "    await use();\n" +
-        "    try {\n" +
-        "      const raw = await page.content();\n" +
-        "      const rawPath = testInfo.outputPath('qagent-dom-raw.html');\n" +
-        "      fs.writeFileSync(rawPath, raw, 'utf-8');\n" +
-        "      await testInfo.attach('qagent-dom-raw', { path: rawPath, contentType: 'text/html' });\n" +
-        "    } catch {}\n" +
-        "    try {\n" +
-        "      const snapshot = await page.evaluate(() => {\n" +
-        "        const SEL = 'a,button,input,select,textarea,[role],[data-testid],[data-test],[id]';\n" +
-        "        const elements = Array.from(document.querySelectorAll(SEL)).slice(0, 400).map((node) => {\n" +
-        "          const el = node as HTMLElement;\n" +
-        "          const text = (el.innerText || '').trim().slice(0, 80);\n" +
-        "          return {\n" +
-        "            tag: el.tagName.toLowerCase(),\n" +
-        "            role: el.getAttribute('role') || undefined,\n" +
-        "            testId: el.getAttribute('data-testid') || el.getAttribute('data-test') || undefined,\n" +
-        "            id: el.id || undefined,\n" +
-        "            name: el.getAttribute('name') || undefined,\n" +
-        "            text: text || undefined,\n" +
-        "            placeholder: el.getAttribute('placeholder') || undefined,\n" +
-        "            type: el.getAttribute('type') || undefined,\n" +
-        "          };\n" +
-        "        });\n" +
-        "        return { path: location.pathname, url: location.href, elements };\n" +
+        "    // Distilled inventory FIRST (what self-heal needs) — retry once after a\n" +
+        "    // short settle so a transiently-busy failure page still yields real\n" +
+        "    // elements instead of leaving the fixer with no DOM (#398).\n" +
+        "    const runDistill = () => page.evaluate(() => {\n" +
+        "      const SEL = 'a,button,input,select,textarea,[role],[data-testid],[data-test],[id]';\n" +
+        "      const elements = Array.from(document.querySelectorAll(SEL)).slice(0, 400).map((node) => {\n" +
+        "        const el = node as HTMLElement;\n" +
+        "        const text = (el.innerText || '').trim().slice(0, 80);\n" +
+        "        return {\n" +
+        "          tag: el.tagName.toLowerCase(),\n" +
+        "          role: el.getAttribute('role') || undefined,\n" +
+        "          testId: el.getAttribute('data-testid') || el.getAttribute('data-test') || undefined,\n" +
+        "          id: el.id || undefined,\n" +
+        "          name: el.getAttribute('name') || undefined,\n" +
+        "          text: text || undefined,\n" +
+        "          placeholder: el.getAttribute('placeholder') || undefined,\n" +
+        "          type: el.getAttribute('type') || undefined,\n" +
+        "        };\n" +
         "      });\n" +
-        "      const distilledPath = testInfo.outputPath('qagent-dom-distilled.json');\n" +
-        "      fs.writeFileSync(distilledPath, JSON.stringify(snapshot), 'utf-8');\n" +
-        "      await testInfo.attach('qagent-dom-distilled', { path: distilledPath, contentType: 'application/json' });\n" +
-        "    } catch {}\n" +
+        "      return { path: location.pathname, url: location.href, elements };\n" +
+        "    });\n" +
+        "    let snapshot: { path: string; url: string; elements: unknown[] } | null = null;\n" +
+        "    for (let i = 0; i < 2; i++) {\n" +
+        "      if (page.isClosed()) break;\n" +
+        "      try { snapshot = await runDistill(); } catch { snapshot = null; }\n" +
+        "      if (snapshot && Array.isArray(snapshot.elements) && snapshot.elements.length > 0) break;\n" +
+        "      try { await page.waitForTimeout(400); } catch { break; }\n" +
+        "    }\n" +
+        "    if (snapshot) {\n" +
+        "      try {\n" +
+        "        const distilledPath = testInfo.outputPath('qagent-dom-distilled.json');\n" +
+        "        fs.writeFileSync(distilledPath, JSON.stringify(snapshot), 'utf-8');\n" +
+        "        await testInfo.attach('qagent-dom-distilled', { path: distilledPath, contentType: 'application/json' });\n" +
+        "      } catch {}\n" +
+        "    }\n" +
+        rawBlock +
         "  }, { auto: true }],\n" +
         "});\n" +
         "\n" +
@@ -180,8 +205,10 @@ function fixturesTs(sessionFile, replaySession) {
  * @param sessionFile Absolute path to the `sessionStorage.json` snapshot embedded
  *   in the generated `fixtures.ts`.
  * @param replaySession Whether sessionStorage replay is active for this run.
+ * @param captureRaw Whether to also capture the raw-HTML DOM attachment (off for
+ *   intermediate heal attempts — #398).
  */
-function applyFixtures(specDir, specFilenames, sessionFile, replaySession) {
+function applyFixtures(specDir, specFilenames, sessionFile, replaySession, captureRaw = true) {
     const replacements = [
         ["'@playwright/test'", "'./fixtures'"],
         ['"@playwright/test"', '"./fixtures"'],
@@ -203,5 +230,5 @@ function applyFixtures(specDir, specFilenames, sessionFile, replaySession) {
             fs.writeFileSync(specPath, newText, "utf-8");
         }
     }
-    fs.writeFileSync(path.join(specDir, "fixtures.ts"), fixturesTs(sessionFile, replaySession), "utf-8");
+    fs.writeFileSync(path.join(specDir, "fixtures.ts"), fixturesTs(sessionFile, replaySession, captureRaw), "utf-8");
 }

package/dist/src/runner.js

@@ -476,9 +476,16 @@ async function processHealJob(cfg, job, heal) {
             const { storageState, sessionStoragePath } = auth;
             for (let attempt = 1; attempt <= heal.maxAttempts; attempt++) {
                 fs.writeFileSync(path.join(workDir, spec.filename), currentCode, "utf-8");
-                (0, playwrightConfig_1.writeConfig)(workDir, 1, job.headless, job.baseUrl, storageState);
+                // Heal re-runs fail fast (shorter timeouts) and skip heavy trace/video +
+                // raw-DOM capture except on the final attempt (#398).
+                const isFinalAttempt = attempt === heal.maxAttempts;
+                (0, playwrightConfig_1.writeConfig)(workDir, 1, job.headless, job.baseUrl, storageState, {
+                    testTimeoutMs: heal.testTimeoutMs,
+                    actionTimeoutMs: heal.actionTimeoutMs,
+                    heavyEvidence: isFinalAttempt,
+                });
                 const replaySession = Boolean(job.manualAuth && storageState && sessionStoragePath && fs.statSync(sessionStoragePath).size > 0);
-                (0, playwrightConfig_1.applyFixtures)(workDir, [spec.filename], sessionStoragePath || path.join(workDir, "sessionStorage.json"), replaySession);
+                (0, playwrightConfig_1.applyFixtures)(workDir, [spec.filename], sessionStoragePath || path.join(workDir, "sessionStorage.json"), replaySession, isFinalAttempt);
                 await progress("running", attempt, `Running spec (attempt ${attempt}/${heal.maxAttempts})`);
                 const started = Date.now();
                 const { stdout, stderr, timedOut } = await runPlaywright(workDir, 1, spec.filename);
@@ -849,11 +856,18 @@ async function processExplorationJob(cfg, session) {
         }
     }
     const storageState = origin && (0, session_1.hasValidSession)(origin) ? (0, session_1.sessionPathsForOrigin)(origin).storageStatePath : "";
+    // Pair the sessionStorage snapshot (MSAL/SPA auth tokens) with the saved
+    // session so the explore browser authenticates the same way a run does — the
+    // run path replays it via fixtures (see `replaySession`). Without it an
+    // MSAL/SPA app boots unauthenticated and bounces to login.
+    const sessionStoragePath = storageState && origin && (0, session_1.hasSessionStorage)(origin) ? (0, session_1.sessionPathsForOrigin)(origin).sessionStoragePath : "";
     const script = (0, paths_1.vendorExploreScript)();
     const nm = (0, paths_1.agentNodeModules)();
     const args = [script, session.baseUrl];
     if (storageState)
         args.push(storageState);
+    if (storageState && sessionStoragePath)
+        args.push(sessionStoragePath);
     // Run the explore browser HEADED on the paired device: the user watches the
     // session, and a headed browser dodges WAF/bot-protection that blocks headless.
     const child = (0, child_process_1.spawn)((0, paths_1.nodeBin)(), args, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@q-agent/agent",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Q-Agent Local Agent — claims execution jobs from the Q-Agent server and runs Playwright locally, so manual login/MFA happens on the user's own machine and session credentials never leave it.",
   "license": "UNLICENSED",
   "bin": {

package/vendor/explore_session.cjs

@@ -13,8 +13,11 @@
 // whole session, reading newline-delimited JSON commands on stdin and writing
 // newline-delimited JSON responses on stdout.
 //
-// Args: baseURL, [storageState]  (storageState = absolute path to a saved
-// Playwright session for auth reuse, per ADR 0002).
+// Args: baseURL, [storageState], [sessionState]  (storageState = absolute path
+// to a saved Playwright session for auth reuse, per ADR 0002; sessionState =
+// absolute path to the sibling sessionStorage.json snapshot, replayed for auth
+// reuse on MSAL/SPA apps whose token lives in sessionStorage — which Playwright's
+// storageState cannot persist).
 //
 // Protocol (one JSON object per line, each way):
 //   {"cmd":"observe"}
@@ -29,8 +32,9 @@
 // self-heal loop's tolerance for stale actions).
 const { chromium } = require('playwright');
 const readline = require('readline');
+const fs = require('fs');
 
-const [, , baseURL, storageState] = process.argv;
+const [, , baseURL, storageState, sessionState] = process.argv;
 
 process.on('unhandledRejection', (e) => console.error('explore unhandledRejection:', e && (e.message || e)));
 process.on('uncaughtException', (e) => console.error('explore uncaughtException:', e && (e.message || e)));
@@ -166,6 +170,21 @@ async function handle(line) {
   const contextOpts = { baseURL };
   if (storageState) contextOpts.storageState = storageState;
   const context = await browser.newContext(contextOpts);
+  // Replay the captured sessionStorage (MSAL/SPA auth tokens) for the matching
+  // origin BEFORE any app code runs — mirrors playwright_runner._fixtures_ts.
+  // storageState persists cookies + localStorage but NOT sessionStorage, so
+  // without this an MSAL/SPA app boots unauthenticated and bounces to login even
+  // with a valid saved session. The snapshot is {origin: {key: value}}.
+  if (sessionState) {
+    let sessions = {};
+    try { sessions = JSON.parse(fs.readFileSync(sessionState, 'utf-8')); } catch {}
+    await context.addInitScript((byOrigin) => {
+      try {
+        const entries = byOrigin[location.origin];
+        if (entries) for (const k in entries) window.sessionStorage.setItem(k, entries[k]);
+      } catch {}
+    }, sessions);
+  }
   page = await context.newPage();
 
   // Land on the app before the first observe so step 1 sees the real page,