@q-agent/agent 0.1.23 → 0.1.24

package/dist/src/paths.js

@@ -43,6 +43,7 @@ exports.playwrightCli = playwrightCli;
 exports.claudeCli = claudeCli;
 exports.vendorCaptureScript = vendorCaptureScript;
 exports.vendorExploreScript = vendorExploreScript;
+exports.vendorLiveReporter = vendorLiveReporter;
 exports.vendorAuthoringScript = vendorAuthoringScript;
 /**
  * Runtime path resolution for the agent's child processes (Playwright CLI +
@@ -190,6 +191,19 @@ function vendorExploreScript() {
         throw new Error("explore_session.cjs not found — the agent package is missing vendor/");
     return found;
 }
+/** The vendored Playwright live reporter (`live_reporter.cjs`) — emits per-test
+ * results so execution status updates immediately instead of at end-of-run. */
+function vendorLiveReporter() {
+    const root = packagedRoot();
+    const found = firstExisting([
+        ...(root ? [path.join(root, "vendor", "live_reporter.cjs")] : []),
+        path.join(__dirname, "..", "..", "vendor", "live_reporter.cjs"),
+        path.join(__dirname, "..", "vendor", "live_reporter.cjs"),
+    ]);
+    if (!found)
+        throw new Error("live_reporter.cjs not found — the agent package is missing vendor/");
+    return found;
+}
 /** The vendored live-authoring Chrome launcher (`authoring_browser.cjs`, #403).
  * Uses only Node built-ins (no Playwright), so it runs with a bare `node`. */
 function vendorAuthoringScript() {

package/dist/src/playwrightConfig.js

@@ -51,7 +51,7 @@ export default defineConfig({
   testDir: '.',
   timeout: __TIMEOUT__,
   workers: __WORKERS__,
-  reporter: [['json', { outputFile: 'report.json' }]],
+  reporter: __REPORTERS__,
   use: {
     headless: __HEADLESS__,
     screenshot: 'only-on-failure',
@@ -72,7 +72,13 @@ __EXTRA_USE__  },
  * @param opts Heal-tuning knobs (timeouts + evidence); defaults match a normal run.
  */
 function writeConfig(specDir, workers, headless, baseUrl = "", storageState = "", opts = {}) {
-    const { testTimeoutMs = 30000, actionTimeoutMs, heavyEvidence = true } = opts;
+    const { testTimeoutMs = 30000, actionTimeoutMs, heavyEvidence = true, liveReporterPath } = opts;
+    // JSON reporter (drives report.json for evidence + reconcile) + optionally the
+    // live reporter (streams per-test results). Paths JSON-escaped for Windows.
+    const reporters = ["['json', { outputFile: 'report.json' }]"];
+    if (liveReporterPath)
+        reporters.push(`[${JSON.stringify(liveReporterPath)}]`);
+    const reportersStr = `[${reporters.join(", ")}]`;
     const extraLines = [];
     if (baseUrl)
         extraLines.push(`    baseURL: ${JSON.stringify(baseUrl)},`);
@@ -87,6 +93,7 @@ function writeConfig(specDir, workers, headless, baseUrl = "", storageState = ""
     const content = PLAYWRIGHT_CONFIG_TEMPLATE.replace("__TIMEOUT__", String(Math.trunc(testTimeoutMs)))
         .replace("__WORKERS__", String(workers))
         .replace("__HEADLESS__", headless ? "true" : "false")
+        .replace("__REPORTERS__", reportersStr)
         .replace("__VIDEO__", retain)
         .replace("__TRACE__", retain)
         .replace("__EXTRA_USE__", extraUse);

package/dist/src/report.js

@@ -7,6 +7,7 @@
  * server already understands.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeStatus = normalizeStatus;
 exports.parsePlaywrightReport = parsePlaywrightReport;
 exports.specFilename = specFilename;
 exports.parseSpecIdentity = parseSpecIdentity;
@@ -17,6 +18,11 @@ const STATUS_MAP = {
     interrupted: "fail",
     skipped: "skipped",
 };
+/** Normalize a raw Playwright test status to the server's vocabulary — shared by
+ * the batch report parse and the live per-test reporter stream so both agree. */
+function normalizeStatus(pwStatus) {
+    return STATUS_MAP[pwStatus] ?? "fail";
+}
 // Evidence kind values a Playwright attachment `name` can map to.
 const ATTACHMENT_KIND_MAP = {
     screenshot: "screenshot",

package/dist/src/runner.js

@@ -81,11 +81,11 @@ function nodePathEnv(nm) {
     const existing = process.env.NODE_PATH;
     return { ...process.env, ...(0, paths_1.childNodeEnv)(), NODE_PATH: existing ? `${nm}${path.delimiter}${existing}` : nm };
 }
-function runProcess(cmd, args, cwd, env, timeoutMs) {
+function runProcess(cmd, args, cwd, env, timeoutMs, onLine) {
     return new Promise((resolve) => {
         // No shell: cmd is always an absolute node path (nodeBin()) and args are
         // absolute script/CLI paths, so this is safe even when paths contain spaces.
-        const child = (0, child_process_1.spawn)(cmd, args, { cwd, env });
+        const child = (0, child_process_1.spawn)(cmd, args, { cwd, env, windowsHide: true });
         activeChild = child;
         let stdout = "";
         let stderr = "";
@@ -99,9 +99,20 @@ function runProcess(cmd, args, cwd, env, timeoutMs) {
                 // Already gone.
             }
         }, timeoutMs);
-        child.stdout?.on("data", (d) => {
-            stdout += d.toString();
-        });
+        // Read stdout line-by-line so a per-line callback (the live test reporter)
+        // can forward results mid-run; still accumulate the full text for diagnostics.
+        if (child.stdout) {
+            const rl = readline.createInterface({ input: child.stdout });
+            rl.on("line", (line) => {
+                stdout += line + "\n";
+                if (onLine) {
+                    try {
+                        onLine(line);
+                    }
+                    catch { /* a forwarder must never break the run */ }
+                }
+            });
+        }
         child.stderr?.on("data", (d) => {
             stderr += d.toString();
         });
@@ -136,7 +147,7 @@ async function captureAuth(baseUrl, storageStatePath, sessionStoragePath) {
         return false;
     }
 }
-async function runPlaywright(workDir, workers, specFile) {
+async function runPlaywright(workDir, workers, specFile, onLine) {
     // Invoke Playwright's CLI through the resolved node runtime (`node cli.js test …`)
     // so the same path works from source, via npx, and in a packaged bundle where
     // `node`/`node_modules` live beside the executable rather than on PATH.
@@ -144,7 +155,7 @@ async function runPlaywright(workDir, workers, specFile) {
     if (specFile)
         args.push(specFile);
     const nm = (0, paths_1.agentNodeModules)();
-    return runProcess((0, paths_1.nodeBin)(), args, workDir, nodePathEnv(nm), EXEC_TIMEOUT_MS);
+    return runProcess((0, paths_1.nodeBin)(), args, workDir, nodePathEnv(nm), EXEC_TIMEOUT_MS, onLine);
 }
 /**
  * Best identity `{ticket, caseCode}` for wire events: prefers explicit
@@ -245,13 +256,16 @@ async function processJob(cfg, job) {
             return;
         }
         const { storageState, sessionStoragePath } = auth;
-        (0, playwrightConfig_1.writeConfig)(workDir, job.workers, job.headless, job.baseUrl, storageState);
+        (0, playwrightConfig_1.writeConfig)(workDir, job.workers, job.headless, job.baseUrl, storageState, {
+            liveReporterPath: (0, paths_1.vendorLiveReporter)(),
+        });
         // Always inject the generated fixtures.ts (DOM capture on every run) + rewrite
         // spec imports to it. sessionStorage replay (MSAL/SPA tokens) is additionally
         // enabled only when a manual-auth session actually exists.
         const replaySession = Boolean(job.manualAuth && storageState && sessionStoragePath && fs.statSync(sessionStoragePath).size > 0);
         (0, playwrightConfig_1.applyFixtures)(workDir, job.specs.map((s) => s.filename), sessionStoragePath || path.join(workDir, "sessionStorage.json"), replaySession);
         const total = job.specs.length;
+        const specByFile = new Map(job.specs.map((s) => [s.filename, s]));
         for (let i = 0; i < job.specs.length; i++) {
             const { ticket, caseCode } = identityFor(job.specs[i]);
             await api.postEvent(cfg, job.executionId, "exec.case.running", { ticket, caseCode, index: i + 1, total });
@@ -261,8 +275,57 @@ async function processJob(cfg, job) {
         // action); a multi-case job executes the whole suite — same distinction
         // as the server's `single_spec`.
         const singleSpec = job.specs.length === 1 ? job.specs[0].filename : "";
+        // Post one case's result + progress. The `handled` guard makes it idempotent
+        // per spec, so a result streamed live by the reporter is NOT re-posted by the
+        // end-of-run reconcile pass. Counts are reserved synchronously (before the
+        // awaits), so they're correct by the time the run ends.
+        let passed = 0;
+        let failed = 0;
+        const handled = new Set();
+        const postCaseResult = async (spec, status, durationMs, error) => {
+            if (handled.has(spec.filename))
+                return;
+            handled.add(spec.filename);
+            if (status === "pass")
+                passed++;
+            else if (status === "fail")
+                failed++;
+            const { ticket, caseCode } = identityFor(spec);
+            const progress = total ? Math.trunc((100 * handled.size) / total) : 100;
+            await api
+                .postResult(cfg, job.executionId, { file: spec.filename, status, duration_ms: durationMs, error_message: error })
+                .catch(() => { });
+            await api
+                .postEvent(cfg, job.executionId, "exec.case.result", { ticket, caseCode, status, durationMs })
+                .catch(() => { });
+            await api
+                .postEvent(cfg, job.executionId, "exec.progress", { progress, passed, failed, remaining: total - handled.size })
+                .catch(() => { });
+            (0, bus_1.emit)("case-result", { ticket, caseCode, status, durationMs });
+            (0, bus_1.emit)("progress", { progress, passed, failed, remaining: total - handled.size });
+        };
+        // Live streaming (#exec-live): the vendored reporter prints one
+        // `QAGENT_TEST {json}` line per finished test, which runProcess feeds here so
+        // each spec's status reaches the UI the moment Playwright finishes it — rather
+        // than in a burst after the whole run + report.json parse.
+        const LIVE_PREFIX = "QAGENT_TEST ";
+        const onLine = (line) => {
+            if (!line.startsWith(LIVE_PREFIX))
+                return;
+            let r;
+            try {
+                r = JSON.parse(line.slice(LIVE_PREFIX.length));
+            }
+            catch {
+                return;
+            }
+            const spec = specByFile.get(path.basename(String(r.file || "")));
+            if (!spec)
+                return;
+            void postCaseResult(spec, (0, report_1.normalizeStatus)(String(r.status || "")), Math.trunc(Number(r.durationMs) || 0), r.error || "");
+        };
         const started = Date.now();
-        const { stdout, stderr, timedOut } = await runPlaywright(workDir, job.workers, singleSpec);
+        const { stdout, stderr, timedOut } = await runPlaywright(workDir, job.workers, singleSpec, onLine);
         const elapsedMs = Date.now() - started;
         const procOutput = [stdout, stderr].filter(Boolean).join("\n").trim();
         let runError = "";
@@ -284,72 +347,30 @@ async function processJob(cfg, job) {
                 runError = `Playwright produced no report.json${detail}`;
             }
         }
-        let passed = 0;
-        let failed = 0;
-        const matched = new Set();
-        // Evidence uploads are deferred until AFTER results + complete are posted:
-        // the browser has already closed when a test finishes, so the web should mark
-        // the case/run done immediately rather than waiting on (potentially multi-MB)
-        // video/trace/DOM uploads over the network.
+        // End-of-run reconcile: gather evidence for every reported spec (from
+        // report.json), and post any case the live reporter didn't already stream (a
+        // missed test, or a run-error where nothing streamed). Already-streamed specs
+        // are skipped by postCaseResult's guard — only their evidence is collected.
+        // Evidence uploads are deferred until AFTER results + complete are posted so
+        // the web marks the run done immediately rather than waiting on (multi-MB)
+        // video/trace/DOM uploads.
         const pendingEvidence = [];
         for (const spec of job.specs) {
             const entry = parsed.find((e) => path.basename(e.file) === spec.filename);
-            if (!entry)
-                continue;
-            matched.add(spec.filename);
-            const durationMs = entry.duration_ms || elapsedMs;
-            await api.postResult(cfg, job.executionId, {
-                file: spec.filename,
-                status: entry.status,
-                duration_ms: durationMs,
-                error_message: entry.error_message,
-            });
-            if (entry.status === "pass")
-                passed++;
-            else if (entry.status === "fail")
-                failed++;
             const { ticket, caseCode } = identityFor(spec);
-            await api.postEvent(cfg, job.executionId, "exec.case.result", {
-                ticket,
-                caseCode,
-                status: entry.status,
-                durationMs,
-            });
-            (0, bus_1.emit)("case-result", { ticket, caseCode, status: entry.status, durationMs });
-            const progress = total ? Math.trunc((100 * matched.size) / total) : 100;
-            await api.postEvent(cfg, job.executionId, "exec.progress", {
-                progress,
-                passed,
-                failed,
-                remaining: total - matched.size,
-            });
-            (0, bus_1.emit)("progress", { progress, passed, failed, remaining: total - matched.size });
-            for (const att of entry.attachments) {
-                const filePath = path.isAbsolute(att.path) ? att.path : path.join(workDir, att.path);
-                if (!fs.existsSync(filePath))
-                    continue;
-                pendingEvidence.push({ ticket, caseCode, kind: att.kind, filePath });
+            if (entry) {
+                for (const att of entry.attachments) {
+                    const filePath = path.isAbsolute(att.path) ? att.path : path.join(workDir, att.path);
+                    if (fs.existsSync(filePath))
+                        pendingEvidence.push({ ticket, caseCode, kind: att.kind, filePath });
+                }
+                await postCaseResult(spec, entry.status, entry.duration_ms || elapsedMs, entry.error_message);
+            }
+            else {
+                // No report entry: if it wasn't streamed either, it's a failure (run error
+                // / crash). The guard no-ops when the reporter already streamed it.
+                await postCaseResult(spec, "fail", elapsedMs, runError || "No result reported by Playwright");
             }
-        }
-        // Any spec Playwright didn't report on (e.g. run_error) is marked failed.
-        for (const spec of job.specs) {
-            if (matched.has(spec.filename))
-                continue;
-            failed++;
-            const message = runError || "No result reported by Playwright";
-            await api.postResult(cfg, job.executionId, {
-                file: spec.filename,
-                status: "fail",
-                duration_ms: elapsedMs,
-                error_message: message,
-            });
-            const { ticket, caseCode } = identityFor(spec);
-            await api.postEvent(cfg, job.executionId, "exec.case.result", {
-                ticket,
-                caseCode,
-                status: "fail",
-                durationMs: elapsedMs,
-            });
         }
         // Keep the LAST ~20000 chars so the failing tail survives truncation,
         // matching the server's own log persistence.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@q-agent/agent",
-  "version": "0.1.23",
+  "version": "0.1.24",
   "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/live_reporter.cjs

@@ -0,0 +1,34 @@
+// Playwright reporter that emits ONE JSON line per finished test to stdout, so
+// the Local Agent can forward each spec's pass/fail to the server the moment it
+// finishes — instead of waiting for the whole run + report.json (#exec-live).
+//
+// The agent tails stdout for lines prefixed with "QAGENT_TEST " and posts
+// exec.case.result immediately. The end-of-run report.json still drives evidence
+// upload + reconciliation, so this reporter only moves the status forward in time.
+//
+// Retries are disabled in the generated config (retries: 0), so onTestEnd fires
+// exactly once per test. Status is emitted RAW (passed/failed/timedOut/…); the
+// agent normalizes it via report.ts's normalizeStatus so both paths agree.
+const path = require('path');
+
+class QAgentLiveReporter {
+  onTestEnd(test, result) {
+    try {
+      const file = test && test.location && test.location.file ? path.basename(test.location.file) : '';
+      if (!file) return;
+      const line =
+        'QAGENT_TEST ' +
+        JSON.stringify({
+          file,
+          status: result && result.status ? result.status : 'failed',
+          durationMs: Math.trunc((result && result.duration) || 0),
+          error: result && result.error && result.error.message ? String(result.error.message) : '',
+        });
+      process.stdout.write(line + '\n');
+    } catch {
+      // A reporter must never throw into the run.
+    }
+  }
+}
+
+module.exports = QAgentLiveReporter;