@q-agent/agent 0.1.0

package/dist/src/session.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * Local session store: captured `storageState.json` + `sessionStorage.json`
+ * per project origin, kept under the agent's config dir. These files hold
+ * the user's actual cookies/localStorage/sessionStorage and are NEVER
+ * uploaded to the server — only referenced by the local
+ * `playwright.config.ts` (storageState) and the generated `fixtures.ts`
+ * (sessionStorage replay), mirroring `project_config_service.auth_path` /
+ * `.session_path` on the server, but scoped to this machine instead of a
+ * server-side owner.
+ */
+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.sessionPathsForOrigin = sessionPathsForOrigin;
+exports.hasValidSession = hasValidSession;
+exports.hasSessionStorage = hasSessionStorage;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+/** Turn an origin like "https://app.example.com" into a filesystem-safe dir name. */
+function sanitizeOrigin(origin) {
+    return origin.replace(/[^a-zA-Z0-9.-]/g, "_");
+}
+/** Resolve the on-disk paths for a given origin's captured session. */
+function sessionPathsForOrigin(origin) {
+    const dir = path.join((0, config_1.configDir)(), "sessions", sanitizeOrigin(origin));
+    return {
+        dir,
+        storageStatePath: path.join(dir, "storageState.json"),
+        sessionStoragePath: path.join(dir, "sessionStorage.json"),
+    };
+}
+/** True if a non-empty captured `storageState.json` exists for `origin`. */
+function hasValidSession(origin) {
+    const { storageStatePath } = sessionPathsForOrigin(origin);
+    try {
+        return fs.statSync(storageStatePath).size > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/** True if a non-empty captured `sessionStorage.json` exists for `origin`. */
+function hasSessionStorage(origin) {
+    const { sessionStoragePath } = sessionPathsForOrigin(origin);
+    try {
+        return fs.statSync(sessionStoragePath).size > 0;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/test/api.test.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Mocked-fetch tests for the wire-protocol client (`src/api.ts`) — verifies
+ * the agent builds correct requests (method, auth header, body shape) for
+ * claim/results/evidence without needing a live server.
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = require("node:test");
+const api = __importStar(require("../src/api"));
+const cfg = {
+    serverUrl: "http://127.0.0.1:8787",
+    deviceToken: "test-token",
+    deviceId: 1,
+    deviceName: "test-machine",
+};
+let calls = [];
+const originalFetch = globalThis.fetch;
+function mockFetch(handler) {
+    globalThis.fetch = (async (url, init) => {
+        const u = typeof url === "string" ? url : url.toString();
+        calls.push({ url: u, init: init ?? {} });
+        return handler(u, init ?? {});
+    });
+}
+(0, node_test_1.afterEach)(() => {
+    globalThis.fetch = originalFetch;
+    calls = [];
+});
+(0, node_test_1.test)("claimNextJob returns null on 204 (no queued job)", async () => {
+    mockFetch(() => new Response(null, { status: 204 }));
+    const job = await api.claimNextJob(cfg);
+    strict_1.default.equal(job, null);
+    strict_1.default.equal(calls[0].url, "http://127.0.0.1:8787/agent/jobs/next");
+    strict_1.default.equal(calls[0].init.headers.Authorization, "Bearer test-token");
+    strict_1.default.equal(calls[0].init.method, "POST");
+});
+(0, node_test_1.test)("claimNextJob returns the parsed job payload on 200", async () => {
+    const payload = {
+        executionId: 42,
+        runCode: "RUN-1",
+        env: "Staging",
+        browser: "chromium",
+        workers: 2,
+        headless: true,
+        baseUrl: "https://app.example.com",
+        manualAuth: true,
+        authOrigins: ["https://app.example.com"],
+        specs: [{ filename: "1428-TC-01.spec.ts", code: "// spec" }],
+    };
+    mockFetch(() => Response.json(payload));
+    const job = await api.claimNextJob(cfg);
+    strict_1.default.deepEqual(job, payload);
+});
+(0, node_test_1.test)("claimNextJob throws ApiError on a non-ok, non-204 response", async () => {
+    mockFetch(() => new Response("nope", { status: 500 }));
+    await strict_1.default.rejects(() => api.claimNextJob(cfg), api.ApiError);
+});
+(0, node_test_1.test)("postResult sends the parsed-report shape as JSON", async () => {
+    mockFetch(() => new Response(null, { status: 200 }));
+    await api.postResult(cfg, 42, { file: "1428-TC-01.spec.ts", status: "pass", duration_ms: 900, error_message: "" });
+    strict_1.default.equal(calls[0].url, "http://127.0.0.1:8787/agent/jobs/42/results");
+    const body = JSON.parse(calls[0].init.body);
+    strict_1.default.deepEqual(body, { file: "1428-TC-01.spec.ts", status: "pass", duration_ms: 900, error_message: "" });
+});
+(0, node_test_1.test)("postEvent wraps event+payload", async () => {
+    mockFetch(() => new Response(null, { status: 200 }));
+    await api.postEvent(cfg, 42, "exec.auth.waiting", { url: "https://app.example.com" });
+    const body = JSON.parse(calls[0].init.body);
+    strict_1.default.deepEqual(body, { event: "exec.auth.waiting", payload: { url: "https://app.example.com" } });
+});
+(0, node_test_1.test)("postEvidence sends a multipart form with the right fields", async () => {
+    const fs = await Promise.resolve().then(() => __importStar(require("node:fs")));
+    const os = await Promise.resolve().then(() => __importStar(require("node:os")));
+    const path = await Promise.resolve().then(() => __importStar(require("node:path")));
+    const tmpFile = path.join(os.tmpdir(), `qagent-test-${Date.now()}.png`);
+    fs.writeFileSync(tmpFile, "fake-png-bytes");
+    mockFetch(() => new Response(null, { status: 200 }));
+    await api.postEvidence(cfg, 42, {
+        ticketExternalId: "SUR-1428",
+        caseCode: "TC-01",
+        kind: "screenshot",
+        filePath: tmpFile,
+        filename: "shot.png",
+    });
+    fs.rmSync(tmpFile);
+    const init = calls[0].init;
+    strict_1.default.equal(calls[0].url, "http://127.0.0.1:8787/agent/jobs/42/evidence");
+    strict_1.default.ok(init.body instanceof FormData);
+    const form = init.body;
+    strict_1.default.equal(form.get("ticket_external_id"), "SUR-1428");
+    strict_1.default.equal(form.get("case_code"), "TC-01");
+    strict_1.default.equal(form.get("kind"), "screenshot");
+    strict_1.default.ok(form.get("file") instanceof Blob);
+});
+(0, node_test_1.test)("postComplete sends the aggregate body", async () => {
+    mockFetch(() => new Response(null, { status: 200 }));
+    await api.postComplete(cfg, 42, { passed: 3, failed: 1, log: "tail" });
+    const body = JSON.parse(calls[0].init.body);
+    strict_1.default.deepEqual(body, { passed: 3, failed: 1, log: "tail" });
+});
+(0, node_test_1.test)("redeemDevice posts code+name with no auth header", async () => {
+    mockFetch(() => Response.json({ deviceToken: "abc", deviceId: 7 }));
+    const result = await api.redeemDevice("http://127.0.0.1:8787", "PAIR123", "my-laptop");
+    strict_1.default.deepEqual(result, { deviceToken: "abc", deviceId: 7 });
+    strict_1.default.equal(calls[0].url, "http://127.0.0.1:8787/agent/devices/redeem");
+    strict_1.default.equal(calls[0].init.headers.Authorization, undefined);
+    const body = JSON.parse(calls[0].init.body);
+    strict_1.default.deepEqual(body, { code: "PAIR123", name: "my-laptop" });
+});

package/dist/test/report.test.js

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * Unit tests for the `parse_playwright_report` port (`src/report.ts`).
+ * Feeds a sample Playwright JSON-reporter report and asserts the flattened
+ * per-spec dicts match what the Python original would produce for the same
+ * input (status mapping, last-retry-wins, attachment filtering, nested
+ * suites, and the spec-filename convention).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = require("node:test");
+const report_1 = require("../src/report");
+(0, node_test_1.test)("maps a passing spec with no attachments", () => {
+    const report = {
+        suites: [
+            {
+                file: "1428-TC-01.spec.ts",
+                specs: [
+                    {
+                        file: "1428-TC-01.spec.ts",
+                        title: "logs in successfully",
+                        tests: [
+                            {
+                                results: [{ status: "passed", duration: 1234, attachments: [] }],
+                            },
+                        ],
+                    },
+                ],
+            },
+        ],
+    };
+    const out = (0, report_1.parsePlaywrightReport)(report);
+    strict_1.default.equal(out.length, 1);
+    strict_1.default.deepEqual(out[0], {
+        file: "1428-TC-01.spec.ts",
+        title: "logs in successfully",
+        status: "pass",
+        duration_ms: 1234,
+        error_message: "",
+        attachments: [],
+    });
+});
+(0, node_test_1.test)("maps failed/timedOut/interrupted to fail and skipped to skipped", () => {
+    const makeSuite = (status) => ({
+        file: `case-${status}.spec.ts`,
+        specs: [
+            {
+                file: `case-${status}.spec.ts`,
+                title: "t",
+                tests: [{ results: [{ status, duration: 1, attachments: [] }] }],
+            },
+        ],
+    });
+    for (const [input, expected] of [
+        ["failed", "fail"],
+        ["timedOut", "fail"],
+        ["interrupted", "fail"],
+        ["skipped", "skipped"],
+    ]) {
+        const out = (0, report_1.parsePlaywrightReport)({ suites: [makeSuite(input)] });
+        strict_1.default.equal(out[0].status, expected, `expected ${input} -> ${expected}`);
+    }
+});
+(0, node_test_1.test)("unknown status defaults to fail", () => {
+    const out = (0, report_1.parsePlaywrightReport)({
+        suites: [
+            {
+                file: "x.spec.ts",
+                specs: [{ file: "x.spec.ts", title: "t", tests: [{ results: [{ status: "weird" }] }] }],
+            },
+        ],
+    });
+    strict_1.default.equal(out[0].status, "fail");
+});
+(0, node_test_1.test)("uses the LAST retry result for status/duration/error", () => {
+    const out = (0, report_1.parsePlaywrightReport)({
+        suites: [
+            {
+                file: "retry.spec.ts",
+                specs: [
+                    {
+                        file: "retry.spec.ts",
+                        title: "flaky then passes",
+                        tests: [
+                            {
+                                results: [
+                                    { status: "failed", duration: 500, error: { message: "first attempt failed" } },
+                                    { status: "passed", duration: 900, error: undefined },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            },
+        ],
+    });
+    strict_1.default.equal(out[0].status, "pass");
+    strict_1.default.equal(out[0].duration_ms, 900);
+    strict_1.default.equal(out[0].error_message, "");
+});
+(0, node_test_1.test)("extracts error message from an object and a bare string", () => {
+    const withObjectError = (0, report_1.parsePlaywrightReport)({
+        suites: [
+            {
+                file: "e1.spec.ts",
+                specs: [{ file: "e1.spec.ts", title: "t", tests: [{ results: [{ status: "failed", error: { message: "boom" } }] }] }],
+            },
+        ],
+    });
+    strict_1.default.equal(withObjectError[0].error_message, "boom");
+    const withStringError = (0, report_1.parsePlaywrightReport)({
+        suites: [
+            {
+                file: "e2.spec.ts",
+                specs: [{ file: "e2.spec.ts", title: "t", tests: [{ results: [{ status: "failed", error: "plain string" }] }] }],
+            },
+        ],
+    });
+    strict_1.default.equal(withStringError[0].error_message, "plain string");
+});
+(0, node_test_1.test)("filters attachments to known kinds and drops attachments without a path", () => {
+    const out = (0, report_1.parsePlaywrightReport)({
+        suites: [
+            {
+                file: "att.spec.ts",
+                specs: [
+                    {
+                        file: "att.spec.ts",
+                        title: "t",
+                        tests: [
+                            {
+                                results: [
+                                    {
+                                        status: "failed",
+                                        attachments: [
+                                            { name: "screenshot", path: "/tmp/shot.png" },
+                                            { name: "video", path: "/tmp/vid.webm" },
+                                            { name: "trace", path: "/tmp/trace.zip" },
+                                            { name: "stdout", path: "/tmp/stdout.txt" },
+                                            { name: "screenshot", path: "" },
+                                        ],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            },
+        ],
+    });
+    strict_1.default.deepEqual(out[0].attachments, [
+        { kind: "screenshot", path: "/tmp/shot.png" },
+        { kind: "video", path: "/tmp/vid.webm" },
+        { kind: "trace", path: "/tmp/trace.zip" },
+    ]);
+});
+(0, node_test_1.test)("flattens nested describe-block suites under one file", () => {
+    const out = (0, report_1.parsePlaywrightReport)({
+        suites: [
+            {
+                file: "nested.spec.ts",
+                specs: [],
+                suites: [
+                    {
+                        specs: [{ title: "inner test", tests: [{ results: [{ status: "passed", duration: 5 }] }] }],
+                    },
+                ],
+            },
+        ],
+    });
+    strict_1.default.equal(out.length, 1);
+    strict_1.default.equal(out[0].file, "nested.spec.ts");
+    strict_1.default.equal(out[0].title, "inner test");
+});
+(0, node_test_1.test)("empty results array yields a fail with zero duration", () => {
+    const out = (0, report_1.parsePlaywrightReport)({
+        suites: [{ file: "none.spec.ts", specs: [{ file: "none.spec.ts", title: "t", tests: [{ results: [] }] }] }],
+    });
+    strict_1.default.equal(out[0].status, "fail");
+    strict_1.default.equal(out[0].duration_ms, 0);
+});
+(0, node_test_1.test)("specFilename strips the ticket prefix down to its short suffix", () => {
+    strict_1.default.equal((0, report_1.specFilename)("SUR-1428", "TC-01"), "1428-TC-01.spec.ts");
+    strict_1.default.equal((0, report_1.specFilename)("1428", "TC-02"), "1428-TC-02.spec.ts");
+});
+(0, node_test_1.test)("parseSpecIdentity recovers shortTicket + caseCode from the TC-NN convention", () => {
+    strict_1.default.deepEqual((0, report_1.parseSpecIdentity)("1428-TC-01.spec.ts"), { shortTicket: "1428", caseCode: "TC-01" });
+    strict_1.default.deepEqual((0, report_1.parseSpecIdentity)("weird-name.spec.ts"), { shortTicket: "weird-name", caseCode: "" });
+});

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@q-agent/agent",
+  "version": "0.1.0",
+  "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": {
+    "qagent-agent": "dist/src/cli.js"
+  },
+  "files": [
+    "dist",
+    "vendor",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chuongduong2810/q-agent.git",
+    "directory": "agent"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node --test dist/test",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@playwright/test": "^1.61.1",
+    "commander": "^12.1.0",
+    "playwright": "^1.61.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "typescript": "^5.5.4"
+  }
+}

package/vendor/capture_auth.cjs

@@ -0,0 +1,136 @@
+// Manual-login capture that survives Microsoft/Entra's anti-automation checks.
+// Args: baseUrl, storageDest, sessionDest.
+//
+// Approach: launch a NORMAL Chrome/Edge via a plain command (with a remote
+// debugging port) — NOT via Playwright's launcher — so the page sees a real,
+// non-automated browser and federated sign-in (Microsoft) works without looping.
+// Playwright only ATTACHES read-only over CDP to snapshot cookies+localStorage
+// (storageState) and sessionStorage (where MSAL/SPA tokens live). We finish when
+// the operator closes the browser.
+const { chromium } = require('playwright');
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const [, , baseUrl, storageDest, sessionDest] = process.argv;
+
+process.on('unhandledRejection', (e) => console.error('capture unhandledRejection:', e && (e.message || e)));
+process.on('uncaughtException', (e) => console.error('capture uncaughtException:', e && (e.message || e)));
+
+const profileDir = path.join(path.dirname(storageDest), 'browser-profile');
+const PORT = 9222 + Math.floor(Math.random() * 400);
+
+function findBrowser() {
+  const c = [
+    'C:/Program Files/Google/Chrome/Application/chrome.exe',
+    'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe',
+    (process.env.LOCALAPPDATA || '') + '/Google/Chrome/Application/chrome.exe',
+    'C:/Program Files (x86)/Microsoft/Edge/Application/msedge.exe',
+    'C:/Program Files/Microsoft/Edge/Application/msedge.exe',
+  ];
+  for (const p of c) { try { if (p && fs.existsSync(p)) return p; } catch {} }
+  return null;
+}
+
+async function waitForCDP(port, timeoutMs) {
+  const end = Date.now() + timeoutMs;
+  while (Date.now() < end) {
+    try { const r = await fetch(`http://127.0.0.1:${port}/json/version`); if (r.ok) return true; } catch {}
+    await new Promise((r) => setTimeout(r, 300));
+  }
+  return false;
+}
+
+(async () => {
+  const exe = findBrowser();
+  if (!exe) { console.error('capture_auth: no Chrome/Edge found on this machine'); process.exit(1); }
+  fs.mkdirSync(profileDir, { recursive: true });
+
+  // Fresh profiles block third-party cookies by default, which breaks the
+  // MSAL/Entra federation redirects (app <-> ciamlogin.com <-> login.microsoftonline.com)
+  // and makes the Microsoft sign-in loop. Pre-seed the profile to allow cookies.
+  try {
+    const defDir = path.join(profileDir, 'Default');
+    fs.mkdirSync(defDir, { recursive: true });
+    const prefsPath = path.join(defDir, 'Preferences');
+    if (!fs.existsSync(prefsPath)) {
+      fs.writeFileSync(prefsPath, JSON.stringify({
+        profile: { cookie_controls_mode: 0, block_third_party_cookies: false,
+          default_content_setting_values: { cookies: 1 } },
+      }));
+    }
+  } catch (e) { console.error('pref seed failed:', e && e.message); }
+
+  // Launch a real, non-automated browser. No Playwright launch flags => no
+  // automation fingerprint => Microsoft login behaves normally.
+  const child = spawn(exe, [
+    `--remote-debugging-port=${PORT}`,
+    `--user-data-dir=${profileDir}`,
+    '--no-first-run', '--no-default-browser-check', '--new-window',
+    baseUrl,
+  ], { detached: false, stdio: 'ignore' });
+  console.error('capture launched real browser:', exe, 'port', PORT);
+
+  if (!(await waitForCDP(PORT, 20000))) {
+    console.error('capture_auth: CDP endpoint never came up on port', PORT);
+    try { child.kill(); } catch {}
+    process.exit(1);
+  }
+
+  const browser = await chromium.connectOverCDP(`http://127.0.0.1:${PORT}`);
+  const context = browser.contexts()[0];
+
+  // IMPORTANT: never call context.storageState() here. For origins whose tab has
+  // navigated away, Playwright reads their localStorage by OPENING A TEMP TAB to
+  // that origin — every snapshot — which the operator sees as a tab rapidly
+  // flashing open/closed during the federated (Microsoft) login. Instead we
+  // compose the state ourselves: cookies via context.cookies() (no page churn),
+  // and local/sessionStorage read only from tabs that are already open, merged
+  // across snapshots so nothing is lost when the flow navigates between origins.
+  const localByOrigin = {};   // origin -> { key: value }
+  const sessionByOrigin = {}; // origin -> { key: value }
+
+  async function snapshot() {
+    if (!context) return;
+    for (const p of context.pages()) {
+      try {
+        const dump = await p.evaluate(() => {
+          const read = (s) => {
+            const out = {};
+            for (let i = 0; i < s.length; i++) { const k = s.key(i); out[k] = s.getItem(k); }
+            return out;
+          };
+          return { origin: location.origin, local: read(localStorage), session: read(sessionStorage) };
+        });
+        if (!dump.origin || !dump.origin.startsWith('http')) continue;
+        if (Object.keys(dump.local).length) localByOrigin[dump.origin] = dump.local;
+        if (Object.keys(dump.session).length) sessionByOrigin[dump.origin] = dump.session;
+      } catch {}
+    }
+    try {
+      const cookies = await context.cookies();
+      const origins = Object.entries(localByOrigin).map(([origin, kv]) => ({
+        origin,
+        localStorage: Object.entries(kv).map(([name, value]) => ({ name, value })),
+      }));
+      fs.writeFileSync(storageDest, JSON.stringify({ cookies, origins }, null, 2));
+    } catch {}
+    try { fs.writeFileSync(sessionDest, JSON.stringify(sessionByOrigin, null, 2)); } catch {}
+  }
+
+  const timer = setInterval(() => { snapshot().catch(() => {}); }, 1500);
+
+  // Finish when the operator closes the browser (child exits) or CDP drops.
+  await new Promise((resolve) => {
+    child.on('exit', resolve);
+    browser.on('disconnected', resolve);
+  });
+
+  clearInterval(timer);
+  await snapshot().catch(() => {});
+  try { await browser.close(); } catch {}
+  try { child.kill(); } catch {}
+  process.exit(0);
+})().catch((e) => {
+  console.error('capture_auth fatal:', e && (e.stack || e.message || e));
+  process.exit(1);
+});