@q-agent/agent 0.1.1 → 0.1.7

package/dist/src/runner.js

@@ -48,15 +48,17 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const api = __importStar(require("./api"));
+const bus_1 = require("./bus");
 const ensureBrowser_1 = require("./ensureBrowser");
 const paths_1 = require("./paths");
 const playwrightConfig_1 = require("./playwrightConfig");
 const report_1 = require("./report");
 const session_1 = require("./session");
+const version_1 = require("./version");
 // Mirrors api/app/config.py's Settings.exec_timeout_s / auth_capture_timeout_s.
 const EXEC_TIMEOUT_MS = 600_000;
 const AUTH_CAPTURE_TIMEOUT_MS = 300_000;
-const IDLE_POLL_MS = 3_000;
+const IDLE_POLL_MS = 1_000;
 let activeChild = null;
 /** Kill whatever child process (capture browser or Playwright run) is active. Used by the CLI's SIGINT handler. */
 function killActiveChild() {
@@ -71,7 +73,7 @@ function killActiveChild() {
 }
 function nodePathEnv(nm) {
     const existing = process.env.NODE_PATH;
-    return { ...process.env, NODE_PATH: existing ? `${nm}${path.delimiter}${existing}` : nm };
+    return { ...process.env, ...(0, paths_1.childNodeEnv)(), NODE_PATH: existing ? `${nm}${path.delimiter}${existing}` : nm };
 }
 function runProcess(cmd, args, cwd, env, timeoutMs) {
     return new Promise((resolve) => {
@@ -166,64 +168,88 @@ async function failAllResults(cfg, job, message) {
     const total = job.specs.length;
     await api.postComplete(cfg, job.executionId, { passed: 0, failed: total, log: message }).catch((err) => console.error("postComplete failed:", err));
 }
+/** Reuse a valid local session, or capture one headed — shared by the run + heal paths. */
+async function resolveJobAuth(cfg, job) {
+    if (!job.manualAuth)
+        return { storageState: "", sessionStoragePath: "" };
+    let origin = job.authOrigins[0] || "";
+    if (!origin && job.baseUrl) {
+        try {
+            origin = new URL(job.baseUrl).origin;
+        }
+        catch {
+            origin = "";
+        }
+    }
+    if (origin && (0, session_1.hasValidSession)(origin)) {
+        const paths = (0, session_1.sessionPathsForOrigin)(origin);
+        return { storageState: paths.storageStatePath, sessionStoragePath: paths.sessionStoragePath };
+    }
+    if (origin && job.baseUrl) {
+        const paths = (0, session_1.sessionPathsForOrigin)(origin);
+        await api.postEvent(cfg, job.executionId, "exec.auth.waiting", { url: job.baseUrl });
+        (0, bus_1.emit)("auth-waiting", { url: job.baseUrl });
+        const captured = await captureAuth(job.baseUrl, paths.storageStatePath, paths.sessionStoragePath);
+        if (captured) {
+            await api.postEvent(cfg, job.executionId, "exec.auth.captured", {});
+            (0, bus_1.emit)("auth-captured", {});
+            return { storageState: paths.storageStatePath, sessionStoragePath: paths.sessionStoragePath };
+        }
+        const message = "Manual login was not completed — enable/redo login capture";
+        await api.postEvent(cfg, job.executionId, "exec.auth.error", { message });
+        (0, bus_1.emit)("error", { message });
+        return { storageState: "", sessionStoragePath: "", error: message };
+    }
+    const message = "Set a base URL for the project first.";
+    await api.postEvent(cfg, job.executionId, "exec.auth.error", { message });
+    (0, bus_1.emit)("error", { message });
+    return { storageState: "", sessionStoragePath: "", error: message };
+}
+/** Best-effort: read the distilled DOM JSON from a parsed attachment list. */
+function loadDistilledDom(workDir, attachments) {
+    const att = attachments.find((a) => a.kind === "dom-distilled");
+    if (!att)
+        return null;
+    const p = path.isAbsolute(att.path) ? att.path : path.join(workDir, att.path);
+    try {
+        return JSON.parse(fs.readFileSync(p, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
 /** Process one claimed job end-to-end: write specs/config, resolve auth, run Playwright, push results. */
 async function processJob(cfg, job) {
+    if (job.heal) {
+        await processHealJob(cfg, job, job.heal);
+        return;
+    }
     const workDir = fs.mkdtempSync(path.join(os.tmpdir(), "qagent-"));
+    // Set once the (detached) evidence uploader takes ownership of workDir — it
+    // then removes the dir when its uploads finish. Until then, this function's
+    // finally cleans up (error / early-return paths).
+    let handedOff = false;
     try {
         for (const spec of job.specs) {
             fs.writeFileSync(path.join(workDir, spec.filename), spec.code, "utf-8");
         }
-        // ---- Resolve auth: reuse a valid local session, or capture one headed.
-        let storageState = "";
-        let sessionStoragePath = "";
-        if (job.manualAuth) {
-            let origin = job.authOrigins[0] || "";
-            if (!origin && job.baseUrl) {
-                try {
-                    origin = new URL(job.baseUrl).origin;
-                }
-                catch {
-                    origin = "";
-                }
-            }
-            if (origin && (0, session_1.hasValidSession)(origin)) {
-                const paths = (0, session_1.sessionPathsForOrigin)(origin);
-                storageState = paths.storageStatePath;
-                sessionStoragePath = paths.sessionStoragePath;
-            }
-            else if (origin && job.baseUrl) {
-                const paths = (0, session_1.sessionPathsForOrigin)(origin);
-                await api.postEvent(cfg, job.executionId, "exec.auth.waiting", { url: job.baseUrl });
-                const captured = await captureAuth(job.baseUrl, paths.storageStatePath, paths.sessionStoragePath);
-                if (captured) {
-                    storageState = paths.storageStatePath;
-                    sessionStoragePath = paths.sessionStoragePath;
-                    await api.postEvent(cfg, job.executionId, "exec.auth.captured", {});
-                }
-                else {
-                    const message = "Manual login was not completed — enable/redo login capture";
-                    await api.postEvent(cfg, job.executionId, "exec.auth.error", { message });
-                    await failAllResults(cfg, job, message);
-                    return;
-                }
-            }
-            else {
-                const message = "Set a base URL for the project first.";
-                await api.postEvent(cfg, job.executionId, "exec.auth.error", { message });
-                await failAllResults(cfg, job, message);
-                return;
-            }
+        const auth = await resolveJobAuth(cfg, job);
+        if (auth.error) {
+            await failAllResults(cfg, job, auth.error);
+            return;
         }
+        const { storageState, sessionStoragePath } = auth;
         (0, playwrightConfig_1.writeConfig)(workDir, job.workers, job.headless, job.baseUrl, storageState);
-        // Replay captured sessionStorage (MSAL/SPA tokens) only when a manual-auth
-        // session actually exists; otherwise normalize spec imports back to
-        // '@playwright/test' (mirrors `_apply_auth_fixtures`'s `use_fixtures` gate).
-        const useFixtures = Boolean(job.manualAuth && storageState && sessionStoragePath && fs.statSync(sessionStoragePath).size > 0);
-        (0, playwrightConfig_1.applyAuthFixtures)(workDir, job.specs.map((s) => s.filename), sessionStoragePath || path.join(workDir, "sessionStorage.json"), useFixtures);
+        // 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;
         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 });
+            (0, bus_1.emit)("case-running", { ticket, caseCode, index: i + 1, total });
         }
         // A single-spec job targets just that one file (the "run this test"
         // action); a multi-case job executes the whole suite — same distinction
@@ -255,6 +281,11 @@ async function processJob(cfg, job) {
         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.
+        const pendingEvidence = [];
         for (const spec of job.specs) {
             const entry = parsed.find((e) => path.basename(e.file) === spec.filename);
             if (!entry)
@@ -271,21 +302,6 @@ async function processJob(cfg, job) {
                 passed++;
             else if (entry.status === "fail")
                 failed++;
-            for (const att of entry.attachments) {
-                const filePath = path.isAbsolute(att.path) ? att.path : path.join(workDir, att.path);
-                if (!fs.existsSync(filePath))
-                    continue;
-                const { ticket, caseCode } = identityFor(spec);
-                await api
-                    .postEvidence(cfg, job.executionId, {
-                    ticketExternalId: ticket,
-                    caseCode,
-                    kind: att.kind,
-                    filePath,
-                    filename: path.basename(filePath),
-                })
-                    .catch((err) => console.error("postEvidence failed:", err));
-            }
             const { ticket, caseCode } = identityFor(spec);
             await api.postEvent(cfg, job.executionId, "exec.case.result", {
                 ticket,
@@ -293,6 +309,7 @@ async function processJob(cfg, job) {
                 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,
@@ -300,6 +317,13 @@ async function processJob(cfg, job) {
                 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 });
+            }
         }
         // Any spec Playwright didn't report on (e.g. run_error) is marked failed.
         for (const spec of job.specs) {
@@ -325,6 +349,259 @@ async function processJob(cfg, job) {
         // matching the server's own log persistence.
         const logText = (procOutput || runError || "").slice(-20000);
         await api.postComplete(cfg, job.executionId, { passed, failed, log: logText });
+        (0, bus_1.emit)("job-complete", { executionId: job.executionId, passed, failed });
+        // Now that the run is marked done, upload the (deferred) evidence artifacts.
+        // These run DETACHED from the claim loop: the run's outcome is already
+        // reported, so the agent must be free to claim the next run immediately
+        // rather than blocking here until every (potentially multi-MB) artifact
+        // finishes uploading — that block is what stalled the agent when a new run
+        // was started mid-upload. The uploader owns workDir cleanup from here.
+        handedOff = true;
+        void uploadEvidenceThenCleanup(cfg, job.executionId, pendingEvidence, workDir);
+    }
+    finally {
+        if (!handedOff)
+            fs.rmSync(workDir, { recursive: true, force: true });
+    }
+}
+/**
+ * Upload a completed job's deferred evidence artifacts, then remove its workDir.
+ * Runs detached from the claim loop (see {@link processJob}) so uploads never
+ * delay claiming the next run. Never throws: each upload's failure is logged and
+ * the workDir is always removed, even if some uploads fail or time out.
+ */
+async function uploadEvidenceThenCleanup(cfg, executionId, pendingEvidence, workDir) {
+    try {
+        for (const ev of pendingEvidence) {
+            await api
+                .postEvidence(cfg, executionId, {
+                ticketExternalId: ev.ticket,
+                caseCode: ev.caseCode,
+                kind: ev.kind,
+                filePath: ev.filePath,
+                filename: path.basename(ev.filePath),
+            })
+                .catch((err) => console.error("postEvidence failed:", err));
+        }
+    }
+    finally {
+        fs.rmSync(workDir, { recursive: true, force: true });
+    }
+}
+/**
+ * Process a standalone manual-login capture: open a headed browser at the
+ * project's base URL ON THIS MACHINE, let the operator log in, and save the
+ * session locally (keyed by origin) so subsequent runs reuse it. The session
+ * never leaves this machine — only the pass/fail outcome is reported back.
+ */
+async function processCapture(cfg, capture) {
+    let origin = capture.origin;
+    if (!origin && capture.baseUrl) {
+        try {
+            origin = new URL(capture.baseUrl).origin;
+        }
+        catch {
+            origin = "";
+        }
+    }
+    if (!origin || !capture.baseUrl) {
+        await api.postCaptureComplete(cfg, capture.captureId, false, "Missing base URL / origin").catch(() => { });
+        return;
+    }
+    const paths = (0, session_1.sessionPathsForOrigin)(origin);
+    // Force a fresh login: remove any prior session so captureAuth's
+    // "storageState is non-empty" success check can't pass off a stale file
+    // (which would falsely report success without opening a browser).
+    try {
+        fs.rmSync(paths.storageStatePath, { force: true });
+        fs.rmSync(paths.sessionStoragePath, { force: true });
+    }
+    catch {
+        // best-effort
+    }
+    (0, bus_1.emit)("auth-waiting", { url: capture.baseUrl });
+    console.log(`Capturing login for ${capture.projectKey} at ${capture.baseUrl}`);
+    let ok = false;
+    try {
+        ok = await captureAuth(capture.baseUrl, paths.storageStatePath, paths.sessionStoragePath);
+    }
+    catch (err) {
+        console.error("Capture crashed:", err.message);
+    }
+    if (ok)
+        (0, bus_1.emit)("auth-captured", {});
+    else
+        (0, bus_1.emit)("error", { message: "Login was not captured — the window closed before a session was saved." });
+    await api
+        .postCaptureComplete(cfg, capture.captureId, ok, ok ? undefined : "Login was not captured")
+        .catch((err) => console.error("postCaptureComplete failed:", err));
+}
+/**
+ * Run the self-heal LOOP for one case locally (#260): run the spec + capture DOM,
+ * and while it fails ask the server to classify + fix it (Claude + KB live
+ * server-side), apply the returned code, and re-run — up to `maxAttempts`. Streams
+ * `heal.progress`, uploads the final attempt's result + evidence, then posts the
+ * outcome to `/agent/heal/{caseId}/finalize`.
+ */
+async function processHealJob(cfg, job, heal) {
+    const spec = job.specs[0];
+    const { ticket, caseCode } = identityFor(spec);
+    const workDir = fs.mkdtempSync(path.join(os.tmpdir(), "qagent-heal-"));
+    const progress = (phase, attempt, message, error = "") => api
+        .postEvent(cfg, job.executionId, "heal.progress", {
+        caseId: heal.caseId, ticket, caseCode, attempt, maxAttempts: heal.maxAttempts,
+        phase, message, error: (error || "").slice(0, 600),
+    })
+        .catch(() => { });
+    let currentCode = spec.code;
+    let finalStatus = "fail";
+    let finalError = "";
+    let elapsedMs = 0;
+    let lastDom = null;
+    let lastAttachments = [];
+    let lastFixBefore = null;
+    let lastFixAfter = null;
+    let blockReason = "";
+    let gateReport = "";
+    const attempts = [];
+    try {
+        const auth = await resolveJobAuth(cfg, job);
+        if (auth.error) {
+            finalError = auth.error;
+        }
+        else {
+            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);
+                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);
+                await progress("running", attempt, `Running spec (attempt ${attempt}/${heal.maxAttempts})`);
+                const started = Date.now();
+                const { stdout, stderr, timedOut } = await runPlaywright(workDir, 1, spec.filename);
+                elapsedMs = Date.now() - started;
+                const output = [stdout, stderr].filter(Boolean).join("\n").trim();
+                let entry;
+                const reportPath = path.join(workDir, "report.json");
+                if (!timedOut && fs.existsSync(reportPath)) {
+                    try {
+                        const parsed = (0, report_1.parsePlaywrightReport)(JSON.parse(fs.readFileSync(reportPath, "utf-8")));
+                        entry = parsed.find((e) => path.basename(e.file) === spec.filename);
+                    }
+                    catch {
+                        // fall through to the no-report error below
+                    }
+                }
+                const rec = { attempt };
+                if (entry) {
+                    lastAttachments = entry.attachments;
+                    lastDom = loadDistilledDom(workDir, entry.attachments);
+                }
+                if (entry && entry.status === "pass") {
+                    finalStatus = "pass";
+                    finalError = "";
+                    rec.status = "pass";
+                    attempts.push(rec);
+                    await progress("passed", attempt, "Spec passed");
+                    break;
+                }
+                finalStatus = "fail";
+                finalError = entry
+                    ? entry.error_message || output || "Test failed"
+                    : timedOut
+                        ? "Playwright run timed out"
+                        : output || "No result reported by Playwright";
+                rec.status = "fail";
+                rec.error = finalError;
+                if (attempt >= heal.maxAttempts) {
+                    attempts.push(rec);
+                    await progress("failed", attempt, "Still failing after max attempts", finalError);
+                    break;
+                }
+                await progress("fixing", attempt, "Asking the server to fix the spec", finalError);
+                let fix;
+                try {
+                    fix = await api.postHealFix(cfg, heal.caseId, {
+                        currentCode, error: finalError, output, domDistilled: lastDom, attempt,
+                    });
+                }
+                catch (err) {
+                    finalError = `Heal fix request failed: ${err.message}`;
+                    rec.error = finalError;
+                    attempts.push(rec);
+                    await progress("failed", attempt, finalError, finalError);
+                    break;
+                }
+                rec.action = fix.action;
+                if (fix.action === "product_defect") {
+                    finalStatus = "product_defect";
+                    rec.failureClass = fix.failureClass;
+                    rec.reason = fix.reason;
+                    attempts.push(rec);
+                    await progress("product_defect", attempt, "Product defect suspected — routing to report", finalError);
+                    break;
+                }
+                if (fix.action === "blocked") {
+                    finalStatus = "blocked";
+                    blockReason = fix.reason || "";
+                    gateReport = fix.gate || "";
+                    rec.gate = "blocked";
+                    rec.error = fix.reason;
+                    attempts.push(rec);
+                    await progress("failed", attempt, "Fix blocked by placeholder gate", fix.reason || "");
+                    break;
+                }
+                if (fix.action === "rejected") {
+                    finalStatus = "fail";
+                    rec.gate = "rejected";
+                    rec.error = fix.reason;
+                    attempts.push(rec);
+                    await progress("failed", attempt, "Fix rejected", fix.reason || "");
+                    break;
+                }
+                // action === "fixed": apply it and re-run.
+                rec.fixed = true;
+                rec.diff = fix.diff;
+                attempts.push(rec);
+                lastFixBefore = currentCode;
+                lastFixAfter = fix.code || currentCode;
+                currentCode = fix.code || currentCode;
+            }
+        }
+        // Report the final attempt's result + evidence against the heal execution.
+        const passResult = finalStatus === "pass";
+        await api
+            .postResult(cfg, job.executionId, {
+            file: spec.filename, status: passResult ? "pass" : "fail",
+            duration_ms: elapsedMs, error_message: passResult ? "" : finalError,
+        })
+            .catch((err) => console.error("postResult failed:", err));
+        for (const att of lastAttachments) {
+            const filePath = path.isAbsolute(att.path) ? att.path : path.join(workDir, att.path);
+            if (!fs.existsSync(filePath))
+                continue;
+            await api
+                .postEvidence(cfg, job.executionId, {
+                ticketExternalId: ticket, caseCode, kind: att.kind, filePath, filename: path.basename(filePath),
+            })
+                .catch((err) => console.error("postEvidence failed:", err));
+        }
+        await api
+            .postEvent(cfg, job.executionId, "exec.case.result", {
+            ticket, caseCode, status: passResult ? "pass" : "fail", durationMs: elapsedMs,
+        })
+            .catch(() => { });
+        await api
+            .postHealFinalize(cfg, heal.caseId, {
+            finalStatus, finalError, finalCode: currentCode,
+            blockReason, gateReport, domDistilled: lastDom,
+            lastFixBefore, lastFixAfter, attempts,
+        })
+            .catch((err) => console.error("postHealFinalize failed:", err));
+        await api
+            .postComplete(cfg, job.executionId, { passed: passResult ? 1 : 0, failed: passResult ? 0 : 1, log: finalError })
+            .catch((err) => console.error("postComplete failed:", err));
+        (0, bus_1.emit)("job-complete", { executionId: job.executionId, passed: passResult ? 1 : 0, failed: passResult ? 0 : 1 });
     }
     finally {
         fs.rmSync(workDir, { recursive: true, force: true });
@@ -339,7 +616,7 @@ async function runAgentLoop(cfg, signal) {
         console.error("Chromium is required to run tests — aborting.");
         return;
     }
-    console.log(`Local Agent started — polling ${cfg.serverUrl} as device #${cfg.deviceId} (${cfg.deviceName})`);
+    console.log(`Local Agent v${(0, version_1.agentVersion)()} started — polling ${cfg.serverUrl} as device #${cfg.deviceId} (${cfg.deviceName})`);
     while (!signal.aborted) {
         let job = null;
         try {
@@ -349,16 +626,30 @@ async function runAgentLoop(cfg, signal) {
             console.error("Claim failed:", err.message);
         }
         if (!job) {
+            // No execution queued — check for a standalone login-capture request.
+            let capture = null;
+            try {
+                capture = await api.claimNextCapture(cfg);
+            }
+            catch (err) {
+                console.error("Capture claim failed:", err.message);
+            }
+            if (capture) {
+                await processCapture(cfg, capture);
+                continue;
+            }
             await new Promise((r) => setTimeout(r, IDLE_POLL_MS));
             continue;
         }
         console.log(`Claimed execution #${job.executionId} (run ${job.runCode}, ${job.specs.length} spec(s))`);
+        (0, bus_1.emit)("job-claimed", { executionId: job.executionId, runCode: job.runCode, total: job.specs.length });
         try {
             await processJob(cfg, job);
             console.log(`Execution #${job.executionId} complete`);
         }
         catch (err) {
             console.error(`Execution #${job.executionId} crashed:`, err);
+            (0, bus_1.emit)("error", { message: `Execution #${job.executionId} crashed: ${err.message}` });
             await api
                 .postComplete(cfg, job.executionId, {
                 passed: 0,