@q-agent/agent 0.1.0

package/dist/src/playwrightConfig.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * Port of `api/app/services/playwright_runner.py`'s config template
+ * (`_PLAYWRIGHT_CONFIG_TEMPLATE` + `_write_config`) and the sessionStorage
+ * fixture shim (`_auth_fixtures_ts` + `_apply_auth_fixtures`), reproduced
+ * faithfully so a spec that runs on the server and one that runs via the
+ * Local Agent behave identically.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeConfig = writeConfig;
+exports.authFixturesTs = authFixturesTs;
+exports.applyAuthFixtures = applyAuthFixtures;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const PLAYWRIGHT_CONFIG_TEMPLATE = `import { defineConfig } from '@playwright/test';
+
+export default defineConfig({
+  testDir: '.',
+  timeout: 30000,
+  workers: __WORKERS__,
+  reporter: [['json', { outputFile: 'report.json' }]],
+  use: {
+    headless: __HEADLESS__,
+    screenshot: 'only-on-failure',
+    video: 'retain-on-failure',
+    trace: 'retain-on-failure',
+__EXTRA_USE__  },
+});
+`;
+/**
+ * (Re)write `playwright.config.ts` into `specDir` — same shape as the
+ * server's `_write_config`.
+ *
+ * @param specDir The job's local workdir the config is written into.
+ * @param workers Parallel worker count.
+ * @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`.
+ */
+function writeConfig(specDir, workers, headless, baseUrl = "", storageState = "") {
+    const extraLines = [];
+    if (baseUrl)
+        extraLines.push(`    baseURL: ${JSON.stringify(baseUrl)},`);
+    if (storageState)
+        extraLines.push(`    storageState: ${JSON.stringify(storageState)},`);
+    const extraUse = extraLines.length ? extraLines.join("\n") + "\n" : "";
+    const content = PLAYWRIGHT_CONFIG_TEMPLATE.replace("__WORKERS__", String(workers))
+        .replace("__HEADLESS__", headless ? "true" : "false")
+        .replace("__EXTRA_USE__", extraUse);
+    fs.writeFileSync(path.join(specDir, "playwright.config.ts"), content, "utf-8");
+}
+/**
+ * TypeScript for a generated `fixtures.ts` that replays sessionStorage —
+ * port of `_auth_fixtures_ts`.
+ *
+ * @param sessionFile Absolute path to the captured `sessionStorage.json`;
+ *   embedded as a JSON-encoded string literal so the fixture reads it at
+ *   runtime.
+ */
+function authFixturesTs(sessionFile) {
+    return ("import { test as base, expect } from '@playwright/test';\n" +
+        "import * as fs from 'fs';\n" +
+        "\n" +
+        `const SESSION_FILE = ${JSON.stringify(sessionFile)};\n` +
+        "let SESSIONS: Record<string, Record<string, string>> = {};\n" +
+        "try { SESSIONS = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8')); } catch {}\n" +
+        "\n" +
+        "export const test = base.extend({\n" +
+        "  context: async ({ context }, use) => {\n" +
+        "    await context.addInitScript((sessions: Record<string, Record<string, string>>) => {\n" +
+        "      try {\n" +
+        "        const entries = sessions[location.origin];\n" +
+        "        if (entries) for (const k in entries) window.sessionStorage.setItem(k, entries[k]);\n" +
+        "      } catch {}\n" +
+        "    }, SESSIONS);\n" +
+        "    await use(context);\n" +
+        "  },\n" +
+        "});\n" +
+        "\n" +
+        "export { expect };\n" +
+        "export type * from '@playwright/test';\n");
+}
+/**
+ * Rewrite each spec's Playwright import to use (or stop using) the
+ * sessionStorage fixture — port of `_apply_auth_fixtures`. Only the module
+ * specifier is touched.
+ *
+ * The Python version globs `*.spec.ts` in `specDir`; the agent already
+ * knows exactly which spec filenames it wrote for this job, so
+ * `specFilenames` is passed explicitly instead of re-scanning the
+ * directory (equivalent behavior, no extra glob dependency).
+ *
+ * @param specDir The job's local workdir containing the spec files.
+ * @param specFilenames The spec filenames written into `specDir` for this job.
+ * @param sessionFile Absolute path to the `sessionStorage.json` snapshot embedded
+ *   in the generated `fixtures.ts`.
+ * @param enabled Whether sessionStorage replay is active for this run.
+ */
+function applyAuthFixtures(specDir, specFilenames, sessionFile, enabled) {
+    const replacements = enabled
+        ? [
+            ["'@playwright/test'", "'./fixtures'"],
+            ['"@playwright/test"', '"./fixtures"'],
+        ]
+        : [
+            ["'./fixtures'", "'@playwright/test'"],
+            ['"./fixtures"', '"@playwright/test"'],
+        ];
+    for (const filename of specFilenames) {
+        const specPath = path.join(specDir, filename);
+        let text;
+        try {
+            text = fs.readFileSync(specPath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        let newText = text;
+        for (const [oldStr, newStr] of replacements) {
+            newText = newText.split(oldStr).join(newStr);
+        }
+        if (newText !== text) {
+            fs.writeFileSync(specPath, newText, "utf-8");
+        }
+    }
+    if (enabled) {
+        fs.writeFileSync(path.join(specDir, "fixtures.ts"), authFixturesTs(sessionFile), "utf-8");
+    }
+}

package/dist/src/report.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * Port of `api/app/services/playwright_runner.py`'s `parse_playwright_report`
+ * (and the `spec_service.spec_filename` convention it depends on) — kept
+ * byte-for-byte faithful to the Python behavior so a report produced by the
+ * agent's local Playwright run maps to the exact same per-spec shape the
+ * server already understands.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePlaywrightReport = parsePlaywrightReport;
+exports.specFilename = specFilename;
+exports.parseSpecIdentity = parseSpecIdentity;
+const STATUS_MAP = {
+    passed: "pass",
+    failed: "fail",
+    timedOut: "fail",
+    interrupted: "fail",
+    skipped: "skipped",
+};
+// Evidence kind values a Playwright attachment `name` can map to.
+const ATTACHMENT_KIND_MAP = {
+    screenshot: "screenshot",
+    video: "video",
+    trace: "trace",
+};
+/* eslint-enable @typescript-eslint/no-explicit-any */
+/**
+ * Map a Playwright JSON-reporter report to per-spec result dicts.
+ *
+ * Nested suites (Playwright groups specs per file, and can nest describe
+ * blocks) are flattened. If a test was retried, the LAST result is used to
+ * determine final status/duration/error, matching what the Playwright UI
+ * reports as the outcome — same semantics as the Python `parse_playwright_report`.
+ *
+ * @param report Parsed contents of Playwright's `--reporter=json` output.
+ * @returns One entry per test spec.
+ */
+function parsePlaywrightReport(report) {
+    const out = [];
+    function walk(suite, fileHint) {
+        const fileName = suite.file || fileHint;
+        for (const spec of suite.specs || []) {
+            const specFile = spec.file || fileName;
+            for (const test of spec.tests || []) {
+                const results = test.results || [];
+                const last = results.length ? results[results.length - 1] : {};
+                const status = STATUS_MAP[last.status || ""] ?? "fail";
+                const error = last.error;
+                const errorMessage = error && typeof error === "object" ? error.message || "" : typeof error === "string" ? error : "";
+                const attachments = (last.attachments || [])
+                    .filter((a) => a.name !== undefined && a.name in ATTACHMENT_KIND_MAP && !!a.path)
+                    .map((a) => ({ kind: ATTACHMENT_KIND_MAP[a.name], path: a.path }));
+                out.push({
+                    file: specFile,
+                    title: spec.title || "",
+                    status,
+                    duration_ms: Math.trunc(last.duration || 0),
+                    error_message: errorMessage,
+                    attachments,
+                });
+            }
+        }
+        for (const child of suite.suites || []) {
+            walk(child, fileName);
+        }
+    }
+    for (const topSuite of report.suites || []) {
+        walk(topSuite, topSuite.file || "");
+    }
+    return out;
+}
+/**
+ * Build the on-disk spec filename for a case — port of
+ * `spec_service.spec_filename`.
+ *
+ * @param ticketExternalId e.g. "SUR-1428".
+ * @param caseCode e.g. "TC-01".
+ * @returns A filename like "1428-TC-01.spec.ts".
+ */
+function specFilename(ticketExternalId, caseCode) {
+    const parts = ticketExternalId.split("-");
+    const shortTicket = parts[parts.length - 1];
+    return `${shortTicket}-${caseCode}.spec.ts`;
+}
+/**
+ * Best-effort reverse of `specFilename`: recover `{shortTicket, caseCode}`
+ * from a filename, assuming the fixed `TC-NN` case-code convention used
+ * everywhere else in this codebase (`ai_service.py` `_next_case_code`).
+ *
+ * NOTE: this only recovers the short numeric suffix of the ticket id (e.g.
+ * "1428"), not its full provider-prefixed external id (e.g. "SUR-1428") —
+ * the `/agent/jobs/next` payload does not currently include that (see
+ * README "Known limitation"). Callers should prefer explicit
+ * `ticketExternalId`/`caseCode` fields on the job spec when present, and
+ * only fall back to this parse otherwise.
+ *
+ * @param filename e.g. "1428-TC-01.spec.ts".
+ */
+function parseSpecIdentity(filename) {
+    const base = filename.replace(/\.spec\.ts$/, "");
+    const match = /^(.+)-(TC-\d+)$/.exec(base);
+    if (match) {
+        return { shortTicket: match[1], caseCode: match[2] };
+    }
+    return { shortTicket: base, caseCode: "" };
+}

package/dist/src/runner.js

@@ -0,0 +1,396 @@
+"use strict";
+/**
+ * The job loop: claim a queued execution, run it locally with Playwright,
+ * and push progress/results/evidence back to the server. Faithful port of
+ * `api/app/services/playwright_runner.py`'s `run_execution`, with DB writes
+ * and `hub.publish` WS events replaced by the `/agent/jobs/*` HTTP calls
+ * (`api.ts`).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.killActiveChild = killActiveChild;
+exports.processJob = processJob;
+exports.runAgentLoop = runAgentLoop;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const api = __importStar(require("./api"));
+const ensureBrowser_1 = require("./ensureBrowser");
+const playwrightConfig_1 = require("./playwrightConfig");
+const report_1 = require("./report");
+const session_1 = require("./session");
+// 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;
+let activeChild = null;
+/** Kill whatever child process (capture browser or Playwright run) is active. Used by the CLI's SIGINT handler. */
+function killActiveChild() {
+    if (activeChild && !activeChild.killed) {
+        try {
+            activeChild.kill();
+        }
+        catch {
+            // Already gone.
+        }
+    }
+}
+function firstExisting(candidates) {
+    for (const c of candidates) {
+        if (fs.existsSync(c))
+            return c;
+    }
+    return null;
+}
+/** Resolve the vendored capture_auth.cjs, whether running from `dist/` or via ts-node from `src/`. */
+function vendorCaptureScript() {
+    const found = firstExisting([
+        path.join(__dirname, "..", "..", "vendor", "capture_auth.cjs"),
+        path.join(__dirname, "..", "vendor", "capture_auth.cjs"),
+    ]);
+    if (!found)
+        throw new Error("capture_auth.cjs not found — the agent package is missing vendor/");
+    return found;
+}
+/** The agent package's own node_modules, where @playwright/test + playwright are installed. */
+function agentNodeModules() {
+    return (firstExisting([path.join(__dirname, "..", "..", "node_modules"), path.join(__dirname, "..", "node_modules")]) ??
+        path.join(__dirname, "..", "..", "node_modules"));
+}
+function nodePathEnv(nm) {
+    const existing = process.env.NODE_PATH;
+    return { ...process.env, NODE_PATH: existing ? `${nm}${path.delimiter}${existing}` : nm };
+}
+function runProcess(cmd, args, cwd, env, timeoutMs) {
+    return new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)(cmd, args, { cwd, env, shell: process.platform === "win32" });
+        activeChild = child;
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            try {
+                child.kill();
+            }
+            catch {
+                // Already gone.
+            }
+        }, timeoutMs);
+        child.stdout?.on("data", (d) => {
+            stdout += d.toString();
+        });
+        child.stderr?.on("data", (d) => {
+            stderr += d.toString();
+        });
+        const finish = (code) => {
+            clearTimeout(timer);
+            if (activeChild === child)
+                activeChild = null;
+            resolve({ code, stdout, stderr, timedOut });
+        };
+        child.on("close", finish);
+        child.on("error", () => finish(null));
+    });
+}
+/**
+ * Open a HEADED browser for manual login (port of
+ * `playwright_runner.py`'s `_capture_once`, vendored verbatim as
+ * `vendor/capture_auth.cjs`). Returns true only once `storageStatePath` is
+ * non-empty after the browser closes.
+ */
+async function captureAuth(baseUrl, storageStatePath, sessionStoragePath) {
+    fs.mkdirSync(path.dirname(storageStatePath), { recursive: true });
+    const script = vendorCaptureScript();
+    const nm = agentNodeModules();
+    const result = await runProcess("node", [script, baseUrl, storageStatePath, sessionStoragePath], nm, nodePathEnv(nm), AUTH_CAPTURE_TIMEOUT_MS);
+    if (result.code !== 0) {
+        console.error(`Auth capture exited ${result.code}: ${(result.stderr || result.stdout || "").slice(0, 800)}`);
+    }
+    try {
+        return fs.statSync(storageStatePath).size > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/** Prefer the agent's own installed `playwright` binary over a fresh `npx` fetch. */
+function playwrightCommand() {
+    const nm = agentNodeModules();
+    const bin = path.join(nm, ".bin", process.platform === "win32" ? "playwright.cmd" : "playwright");
+    if (fs.existsSync(bin))
+        return { cmd: bin, baseArgs: ["test"] };
+    return { cmd: "npx", baseArgs: ["playwright", "test"] };
+}
+async function runPlaywright(workDir, workers, specFile) {
+    const { cmd, baseArgs } = playwrightCommand();
+    const args = [...baseArgs, `--workers=${workers}`];
+    if (specFile)
+        args.push(specFile);
+    const nm = agentNodeModules();
+    return runProcess(cmd, args, workDir, nodePathEnv(nm), EXEC_TIMEOUT_MS);
+}
+/**
+ * Best identity `{ticket, caseCode}` for wire events: prefers explicit
+ * fields on the job spec (forward-compatible with a server patch that adds
+ * them), falling back to parsing the filename convention otherwise. See
+ * README "Known limitation" — the fallback only recovers the ticket's
+ * short numeric suffix, not its full provider-prefixed external id.
+ */
+function identityFor(spec) {
+    if (spec.ticketExternalId && spec.caseCode) {
+        return { ticket: spec.ticketExternalId, caseCode: spec.caseCode };
+    }
+    const parsed = (0, report_1.parseSpecIdentity)(spec.filename);
+    return { ticket: spec.ticketExternalId || parsed.shortTicket, caseCode: spec.caseCode || parsed.caseCode };
+}
+/** Mark every spec in the job failed with `message` and finalize — used when a run cannot proceed (e.g. manual login was not completed). */
+async function failAllResults(cfg, job, message) {
+    for (const spec of job.specs) {
+        const { ticket, caseCode } = identityFor(spec);
+        await api
+            .postResult(cfg, job.executionId, { file: spec.filename, status: "fail", duration_ms: 0, error_message: message })
+            .catch((err) => console.error("postResult failed:", err));
+        await api
+            .postEvent(cfg, job.executionId, "exec.case.result", { ticket, caseCode, status: "fail", durationMs: 0 })
+            .catch((err) => console.error("postEvent failed:", err));
+    }
+    const total = job.specs.length;
+    await api.postComplete(cfg, job.executionId, { passed: 0, failed: total, log: message }).catch((err) => console.error("postComplete failed:", err));
+}
+/** Process one claimed job end-to-end: write specs/config, resolve auth, run Playwright, push results. */
+async function processJob(cfg, job) {
+    const workDir = fs.mkdtempSync(path.join(os.tmpdir(), "qagent-"));
+    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;
+            }
+        }
+        (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);
+        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 });
+        }
+        // A single-spec job targets just that one file (the "run this test"
+        // 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 : "";
+        const started = Date.now();
+        const { stdout, stderr, timedOut } = await runPlaywright(workDir, job.workers, singleSpec);
+        const elapsedMs = Date.now() - started;
+        const procOutput = [stdout, stderr].filter(Boolean).join("\n").trim();
+        let runError = "";
+        if (timedOut)
+            runError = `Playwright run timed out after ${EXEC_TIMEOUT_MS / 1000}s`;
+        const reportPath = path.join(workDir, "report.json");
+        let parsed = [];
+        if (!runError) {
+            if (fs.existsSync(reportPath)) {
+                try {
+                    parsed = (0, report_1.parsePlaywrightReport)(JSON.parse(fs.readFileSync(reportPath, "utf-8")));
+                }
+                catch (exc) {
+                    runError = `Could not parse Playwright report: ${exc.message}`;
+                }
+            }
+            else {
+                const detail = procOutput ? ` — ${procOutput.slice(0, 600)}` : "";
+                runError = `Playwright produced no report.json${detail}`;
+            }
+        }
+        let passed = 0;
+        let failed = 0;
+        const matched = new Set();
+        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++;
+            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,
+                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,
+            });
+        }
+        // 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.
+        const logText = (procOutput || runError || "").slice(-20000);
+        await api.postComplete(cfg, job.executionId, { passed, failed, log: logText });
+    }
+    finally {
+        fs.rmSync(workDir, { recursive: true, force: true });
+    }
+}
+/**
+ * Long-poll loop: claim → process → repeat, backing off `IDLE_POLL_MS`
+ * between empty claims. Runs until `signal.aborted`.
+ */
+async function runAgentLoop(cfg, signal) {
+    if (!(await (0, ensureBrowser_1.ensureChromium)())) {
+        console.error("Chromium is required to run tests — aborting.");
+        return;
+    }
+    console.log(`Local Agent started — polling ${cfg.serverUrl} as device #${cfg.deviceId} (${cfg.deviceName})`);
+    while (!signal.aborted) {
+        let job = null;
+        try {
+            job = await api.claimNextJob(cfg);
+        }
+        catch (err) {
+            console.error("Claim failed:", err.message);
+        }
+        if (!job) {
+            await new Promise((r) => setTimeout(r, IDLE_POLL_MS));
+            continue;
+        }
+        console.log(`Claimed execution #${job.executionId} (run ${job.runCode}, ${job.specs.length} spec(s))`);
+        try {
+            await processJob(cfg, job);
+            console.log(`Execution #${job.executionId} complete`);
+        }
+        catch (err) {
+            console.error(`Execution #${job.executionId} crashed:`, err);
+            await api
+                .postComplete(cfg, job.executionId, {
+                passed: 0,
+                failed: job.specs.length,
+                log: `Local Agent crashed: ${err.message}`,
+            })
+                .catch(() => { });
+        }
+    }
+}