@cyberstrike-io/cyberstrike 1.1.17-beta.2 → 1.1.17-beta.4

package/hackbrowser-worker.js

@@ -106258,20 +106258,22 @@ import { chromium as chromium2 } from "playwright";
 // ../hackbrowser/src/stealth.ts
 import { existsSync as existsSync2 } from "fs";
 import { chromium } from "playwright";
+var PLATFORM_ARGS = process.platform === "linux" ? ["--no-sandbox", "--disable-setuid-sandbox", "--disable-dev-shm-usage", "--no-zygote"] : [];
 var LAUNCH_ARGS = [
   "--disable-blink-features=AutomationControlled",
   "--disable-features=IsolateOrigins,site-per-process",
-  "--no-sandbox",
-  "--disable-setuid-sandbox",
-  "--disable-dev-shm-usage",
   "--no-first-run",
-  "--no-zygote"
+  "--disable-backgrounding-occluded-windows",
+  "--disable-renderer-backgrounding",
+  "--disable-background-timer-throttling",
+  "--disable-hang-monitor",
+  "--disable-ipc-flooding-protection",
+  "--disable-component-update",
+  ...PLATFORM_ARGS
 ];
 function launchOptions(headless) {
-  return { headless, args: LAUNCH_ARGS };
-}
-function userAgent(version3) {
-  return `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${version3} Safari/537.36`;
+  const args = headless ? LAUNCH_ARGS : [...LAUNCH_ARGS, "--start-maximized"];
+  return { headless, args };
 }
 function findSystemChrome() {
   const candidates = process.platform === "darwin" ? ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"] : process.platform === "win32" ? [
@@ -106289,10 +106291,9 @@ async function connect(opts) {
     return chromium.launch({ ...launchOptions(opts.headless), executablePath: chrome });
   return chromium.launch(launchOptions(opts.headless));
 }
-function contextOptions(version3) {
+function contextOptions(headless = true) {
   return {
-    userAgent: userAgent(version3),
-    viewport: { width: 1920, height: 1080 },
+    viewport: headless ? { width: 1920, height: 1080 } : null,
     screen: { width: 1920, height: 1080 },
     locale: "en-US",
     timezoneId: "America/New_York",
@@ -106341,34 +106342,24 @@ Object.defineProperty(screen, 'availWidth', { get: () => 1920 });
 Object.defineProperty(screen, 'availHeight', { get: () => 1040 });
 Object.defineProperty(screen, 'colorDepth', { get: () => 24 });
 Object.defineProperty(screen, 'pixelDepth', { get: () => 24 });
-window.outerWidth = 1920;
-window.outerHeight = 1080;
-window.innerWidth = 1920;
-window.innerHeight = 969;
-
-const origGetParameter = WebGLRenderingContext.prototype.getParameter;
-WebGLRenderingContext.prototype.getParameter = function(param) {
-  if (param === 37445) return 'Intel Inc.';
-  if (param === 37446) return 'Intel Iris OpenGL Engine';
-  return origGetParameter.call(this, param);
-};
-const origGetParameter2 = WebGL2RenderingContext.prototype.getParameter;
-WebGL2RenderingContext.prototype.getParameter = function(param) {
-  if (param === 37445) return 'Intel Inc.';
-  if (param === 37446) return 'Intel Iris OpenGL Engine';
-  return origGetParameter2.call(this, param);
-};
-
-const origToDataURL = HTMLCanvasElement.prototype.toDataURL;
-HTMLCanvasElement.prototype.toDataURL = function(type, quality) {
-  const ctx = this.getContext('2d');
-  if (ctx) {
-    const pixel = ctx.getImageData(0, 0, 1, 1);
-    pixel.data[3] = pixel.data[3] ^ 1;
-    ctx.putImageData(pixel, 0, 0);
-  }
-  return origToDataURL.call(this, type, quality);
-};
+// NOTE: window.inner/outerWidth/Height are intentionally NOT spoofed. They must reflect
+// the REAL window so (a) the crawler's own geometry stays correct — scanner occlusion /
+// offscreen / scroll and the injected panel/login-bar clamp all read innerWidth — and
+// (b) they stay consistent with the actual rendered viewport (a faked 1920 over a smaller
+// real window is itself a detectable fingerprint mismatch). Monitor size is spoofed via
+// screen.* above; the window is launched at 1920x1080 (launchOptions/contextOptions) so on
+// a normal host innerWidth is already ~1920 with no spoof needed.
+
+// NOTE: WebGL vendor/renderer are intentionally NOT spoofed. The real GPU string is a
+// genuine, self-consistent value; a faked 'Intel Iris OpenGL Engine' (an old macOS GPU
+// name, in the outdated non-ANGLE format) contradicts both the platform and modern Chrome's
+// 'ANGLE (...)' renderer format, which is more detectable than reporting the truth.
+
+// NOTE: canvas toDataURL is intentionally NOT perturbed. The previous per-call XOR of one
+// pixel's alpha mutated the canvas on every read, so the same canvas hashed differently each
+// time — an unstable canvas is itself a bot signal (a real canvas is stable). Canvas-noise is
+// an anti-TRACKING measure, not anti-bot-detection (not what cleared #76); reporting the real,
+// stable canvas is the consistent choice, matching the UA/WebGL/window decisions above.
 
 const origQuery = window.Permissions?.prototype?.query;
 if (origQuery) {
@@ -116220,12 +116211,16 @@ function normalizeUrl(url3) {
     u.searchParams.sort();
     let path4 = u.pathname.replace(/\/+$/, "") || "/";
     let hash4 = u.hash;
-    if (hash4 && hash4 !== "#" && !hash4.startsWith("#/")) {
-      hash4 = "#/" + hash4.slice(1);
-    }
-    hash4 = hash4.replace(/\/+$/, "");
-    if (hash4 === "#")
+    const routeLike = hash4.startsWith("#/") || hash4.startsWith("#!") || hash4.includes("=") || hash4.includes("&");
+    if (routeLike) {
+      if (hash4.startsWith("#/") || hash4.startsWith("#!/")) {
+        hash4 = hash4.replace(/\/+$/, "");
+        if (hash4 === "#")
+          hash4 = "";
+      }
+    } else {
       hash4 = "";
+    }
     return u.origin + path4 + u.search + hash4;
   } catch {
     return url3;
@@ -117202,9 +117197,10 @@ var PANEL_CSS = `
 
 /* =========================== Card base =========================== */
 .card {
-  position: absolute;
+  position: fixed;
   bottom: 16px; right: 16px;
   width: 360px;
+  max-width: calc(100vw - 32px);
   background: #0b0f14;
   border: 1px solid #1f2937;
   /* Non-blocking HUD: the agent's own observability overlay must NEVER intercept
@@ -118045,6 +118041,20 @@ function handle(ev) {
   }
 }
 
+// ---------- keep card inside viewport on resize ----------
+function clampCard() {
+  var vv = window.visualViewport;
+  var vw = vv ? vv.width : (document.documentElement.clientWidth || window.innerWidth);
+  var vh = vv ? vv.height : (document.documentElement.clientHeight || window.innerHeight);
+  var w = card.offsetWidth;
+  var h = card.offsetHeight;
+  card.style.right  = Math.max(0, Math.min(16, vw - w - 16)) + 'px';
+  card.style.bottom = Math.max(0, Math.min(16, vh - h - 16)) + 'px';
+}
+window.addEventListener('resize', clampCard);
+if (window.visualViewport) window.visualViewport.addEventListener('resize', clampCard);
+clampCard();
+
 // ---------- render restored state ----------
 setHeader();
 setCounters();
@@ -128174,8 +128184,60 @@ var OVERLAY_ESCAPE_WAIT = 400;
 var OVERLAY_CLEAR_WAIT = 800;
 var SPA_RENDER_RETRY_WAIT = 600;
 var POST_GOTO_WAIT = 400;
+var NETWORK_IDLE_TIMEOUT = 1500;
 var MAX_INLINE_DEPTH = 2;
 var LOGIN_SUCCESS_PATTERN = /POST\s+.*\/(login|signin|authenticate)\S*\s+\[200\]/i;
+async function stabilizeAfterGoto(page) {
+  await page.waitForTimeout(POST_GOTO_WAIT);
+  await page.waitForLoadState("networkidle", { timeout: NETWORK_IDLE_TIMEOUT }).catch(() => {});
+}
+function createBrowserHealth() {
+  return { dead: false, reason: "" };
+}
+function attachLifecycleHandlers(browser, page, health) {
+  browser.on("disconnected", () => {
+    health.dead = true;
+    health.reason = "browser process disconnected";
+    log7.error("browser disconnected — crawl will terminate");
+  });
+  page.on("close", () => {
+    health.dead = true;
+    health.reason = "page closed unexpectedly";
+    log7.error("page closed — crawl will terminate");
+  });
+  page.on("crash", () => {
+    health.dead = true;
+    health.reason = "page renderer crashed";
+    log7.error("page crashed — crawl will terminate");
+  });
+}
+function isBrowserDead(health) {
+  return health.dead;
+}
+var BROWSER_WAIT_TIMEOUT = 30 * 60 * 1000;
+function waitForBrowserClose(browser, signal) {
+  return new Promise((resolve4) => {
+    let resolved = false;
+    const done = () => {
+      if (resolved)
+        return;
+      resolved = true;
+      clearTimeout(timer);
+      resolve4();
+    };
+    const timer = setTimeout(done, BROWSER_WAIT_TIMEOUT);
+    browser.on("disconnected", done);
+    if (signal) {
+      if (signal.aborted) {
+        done();
+        return;
+      }
+      signal.addEventListener("abort", done, { once: true });
+    }
+    if (!browser.isConnected())
+      done();
+  });
+}
 function triggerReDiscovery(globalState) {
   if (globalState.authPhase === "authenticated")
     return;
@@ -128537,6 +128599,7 @@ async function explorePageWithAI(page, pageUrl, interceptor, model, globalState,
   const taskQueue = [...plan.tasks];
   const seenKeys = new Set(elements.map((e2) => `${e2.role}::${e2.label}`));
   let steps = 0;
+  let lastRevealingClick = null;
   while (taskQueue.length > 0 && steps < MAX_STEPS_PER_PAGE) {
     steps++;
     const task = taskQueue.shift();
@@ -128559,16 +128622,18 @@ async function explorePageWithAI(page, pageUrl, interceptor, model, globalState,
     if (task.type === "form") {
       await executeFormTask(task, page, elements, interceptor, semanticActionsDone, globalState, credentialId, linksToEnqueue, pageUrl, inScope, occ, nav);
     } else {
-      await executeClickTask(task, page, elements, interceptor, semanticActionsDone, globalState, credentialId, linksToEnqueue, pageUrl, inScope, occ, nav);
+      await executeClickTask(task, page, elements, interceptor, semanticActionsDone, globalState, credentialId, linksToEnqueue, pageUrl, inScope, occ, nav, lastRevealingClick);
     }
     const postActionElements = filterVisitedLinks(await collectElements(page), pageUrl, globalState.visitedPages);
     if (task.type === "click" && task.role === "combobox") {
-      const optionTasks = collectOptionTasks(postActionElements, seenKeys);
+      const optionTasks = await collectComboboxOptions(page, postActionElements, seenKeys, pageUrl, globalState.visitedPages);
       if (optionTasks.length > 0) {
         taskQueue.unshift(...optionTasks);
       }
     }
     const hasNewElements = discoverNewElements(postActionElements, seenKeys);
+    if (task.type === "click" && hasNewElements)
+      lastRevealingClick = task;
     const hasStaleTargets = queueHasStaleTargets(taskQueue, postActionElements);
     if (hasNewElements || hasStaleTargets || occ.pending.length > 0) {
       const freshElements = filterVisitedLinks(await collectElements(page), pageUrl, globalState.visitedPages);
@@ -128681,15 +128746,17 @@ async function explorePageWithAI(page, pageUrl, interceptor, model, globalState,
       if (task.type === "form") {
         await executeFormTask(task, page, elements, interceptor, semanticActionsDone, globalState, credentialId, linksToEnqueue, pageUrl, inScope, occ, nav);
       } else {
-        await executeClickTask(task, page, elements, interceptor, semanticActionsDone, globalState, credentialId, linksToEnqueue, pageUrl, inScope, occ, nav);
+        await executeClickTask(task, page, elements, interceptor, semanticActionsDone, globalState, credentialId, linksToEnqueue, pageUrl, inScope, occ, nav, lastRevealingClick);
       }
       const postActionElements = filterVisitedLinks(await collectElements(page), pageUrl, globalState.visitedPages);
       if (task.type === "click" && task.role === "combobox") {
-        const optionTasks = collectOptionTasks(postActionElements, seenKeys);
+        const optionTasks = await collectComboboxOptions(page, postActionElements, seenKeys, pageUrl, globalState.visitedPages);
         if (optionTasks.length > 0)
           additionalQueue.unshift(...optionTasks);
       }
       const hasNewElements = discoverNewElements(postActionElements, seenKeys);
+      if (task.type === "click" && hasNewElements)
+        lastRevealingClick = task;
       const hasStaleTargets = queueHasStaleTargets(additionalQueue, postActionElements);
       if (hasNewElements || hasStaleTargets || occ.pending.length > 0) {
         const freshElements = filterVisitedLinks(await collectElements(page), pageUrl, globalState.visitedPages);
@@ -128754,6 +128821,25 @@ async function recoverFromOcclusion(page, el, original, retry) {
   await page.waitForTimeout(OVERLAY_CLEAR_WAIT);
   return retry();
 }
+async function recoverFromClosedContainer(page, el, original, opener, interceptor, retry) {
+  if (original.success || !opener)
+    return original;
+  if (opener.role === el.role && opener.label === el.label)
+    return original;
+  if ((await probeClickPoint(page, el.selector)).status !== "offscreen")
+    return original;
+  const fresh = await collectElements(page);
+  const openerEl = resolveElement(fresh, opener.role, opener.label);
+  if (!openerEl)
+    return original;
+  log7.debug("target offscreen — re-opening its container via opener, retrying once", {
+    target: el.label,
+    opener: opener.label
+  });
+  await execute(page, openerEl, "click", undefined, interceptor.setPendingUI, fresh.length);
+  await page.waitForTimeout(POST_GOTO_WAIT);
+  return retry();
+}
 async function diagnoseOcclusion(page, el, occ) {
   const probe = await probeClickPoint(page, el.selector);
   if (probe.status === "occluded" && !occ.signaled.has(probe.occluder.text)) {
@@ -128779,8 +128865,7 @@ async function handleNavigation(page, parentUrl, linksToEnqueue, inScope, global
     }
   }
   await page.goto(parentUrl, { waitUntil: "domcontentloaded", timeout: 15000 }).catch(() => {});
-  await page.waitForTimeout(POST_GOTO_WAIT);
-  await page.waitForLoadState("domcontentloaded", { timeout: 5000 }).catch(() => {});
+  await stabilizeAfterGoto(page);
 }
 async function executeFormTask(task, page, elements, interceptor, semanticActionsDone, globalState, credentialId, linksToEnqueue, pageUrl, inScope, occ, nav) {
   for (const field of task.fields) {
@@ -128846,7 +128931,7 @@ async function executeFormTask(task, page, elements, interceptor, semanticAction
   if (result.navigated)
     await handleNavigation(page, pageUrl, linksToEnqueue, inScope, globalState, nav);
 }
-async function executeClickTask(task, page, elements, interceptor, semanticActionsDone, globalState, credentialId, linksToEnqueue, pageUrl, inScope, occ, nav) {
+async function executeClickTask(task, page, elements, interceptor, semanticActionsDone, globalState, credentialId, linksToEnqueue, pageUrl, inScope, occ, nav, opener) {
   const el = resolveElement(elements, task.role, task.label);
   if (!el) {
     log7.debug("click target not found", { role: task.role, label: task.label });
@@ -128866,6 +128951,7 @@ async function executeClickTask(task, page, elements, interceptor, semanticActio
   });
   let result = await execute(page, el, "click", undefined, interceptor.setPendingUI, elements.length);
   result = await recoverFromOcclusion(page, el, result, () => execute(page, el, "click", undefined, interceptor.setPendingUI, elements.length));
+  result = await recoverFromClosedContainer(page, el, result, opener, interceptor, () => execute(page, el, "click", undefined, interceptor.setPendingUI, elements.length));
   const occluded = !result.success && await diagnoseOcclusion(page, el, occ);
   interceptor.clearPendingTrigger();
   trackResult(result, interceptor, globalState, credentialId, task.triggersMutation, page);
@@ -128901,6 +128987,24 @@ function collectOptionTasks(elements, seenKeys) {
   }
   return tasks.slice(0, 1);
 }
+var COMBOBOX_PROBES = ["e", "a", "2", "0", " "];
+async function collectComboboxOptions(page, elements, seenKeys, pageUrl, visitedPages) {
+  const inline = collectOptionTasks(elements, seenKeys);
+  if (inline.length > 0)
+    return inline;
+  const search = page.locator(":focus");
+  const typeable = await search.evaluate((el) => !!el && (el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.isContentEditable)).catch(() => false);
+  if (!typeable)
+    return inline;
+  for (const probe of COMBOBOX_PROBES) {
+    await search.fill(probe).catch(() => {});
+    await page.waitForTimeout(200);
+    if (await page.locator("[role=option]:visible").count() > 0)
+      break;
+  }
+  const revealed = filterVisitedLinks(await collectElements(page), pageUrl, visitedPages);
+  return collectOptionTasks(revealed, seenKeys);
+}
 function discoverNewElements(elements, seenKeys) {
   let found = false;
   for (const el of elements) {
@@ -129190,6 +129294,12 @@ async function runMultiCredential(config3, credentials) {
     throw new Error(`AI model required: ${String(err)}`);
   }
   const browser = await connect({ cdp: config3.cdp, headless: config3.headless ?? false });
+  const health = createBrowserHealth();
+  browser.on("disconnected", () => {
+    health.dead = true;
+    health.reason = "browser process disconnected";
+    log7.error("browser disconnected — multi-credential crawl will terminate");
+  });
   let sessionId = config3.cyberstrike.sessionID ?? "";
   if (!dryRun && !sessionId) {
     const created = await initSession(serverUrl, targetUrl, undefined);
@@ -129203,14 +129313,46 @@ async function runMultiCredential(config3, credentials) {
   const captureQueues = new Map;
   const lastAuthHeaders = new Map;
   for (const [credIndex, cred] of credentials.entries()) {
-    const browserContext = await browser.newContext(contextOptions(browser.version()));
+    const browserContext = await browser.newContext(contextOptions(config3.headless ?? false));
     await browserContext.addInitScript(INIT_SCRIPT);
     if (panelOn)
       await browserContext.addInitScript(PANEL_INIT_SCRIPT);
     const page = await browserContext.newPage();
+    page.on("close", () => {
+      health.dead = true;
+      health.reason = `page closed (credential: ${cred.id})`;
+      log7.error("page closed — multi-credential crawl will terminate", { credential: cred.id });
+    });
+    page.on("crash", () => {
+      health.dead = true;
+      health.reason = `page crashed (credential: ${cred.id})`;
+      log7.error("page crashed — multi-credential crawl will terminate", { credential: cred.id });
+    });
     attachDialogAutoAccept(page);
     attachFileChooserAutoFill(page);
-    await page.goto(targetUrl, { waitUntil: "domcontentloaded", timeout: 30000 });
+    const mcInitNavErr = await page.goto(targetUrl, { waitUntil: "domcontentloaded", timeout: 30000 }).then(() => null).catch((e2) => e2);
+    if (mcInitNavErr) {
+      log7.warn("initial navigation failed", {
+        credential: cred.id,
+        url: targetUrl,
+        err: mcInitNavErr.message.split(`
+`)[0]
+      });
+      if (!config3.headless && browser.isConnected()) {
+        log7.info("browser stays open — navigate manually or close the window to finish");
+        await waitForBrowserClose(browser, config3.signal);
+      } else {
+        await browser.close().catch(() => {});
+      }
+      return {
+        sessionID: dryRun ? "" : sessionId,
+        capturedEndpoints: 0,
+        pagesExplored: 0,
+        totalSteps: 0,
+        errors: [`Initial navigation failed (credential: ${cred.id}): ${mcInitNavErr.message}`],
+        usage: usageAcc
+      };
+    }
     csEmit(page, {
       type: "init",
       target: targetUrl,
@@ -129276,6 +129418,14 @@ async function runMultiCredential(config3, credentials) {
   globalState.authPhase = "authenticated";
   let pagesExplored = 0;
   while (pageQueue.length > 0 && pagesExplored < maxPages) {
+    if (isBrowserDead(health)) {
+      log7.error("browser died, terminating multi-credential crawl", {
+        reason: health.reason,
+        pagesExplored,
+        captured: globalState.capturedEndpoints.size
+      });
+      break;
+    }
     if (config3.signal?.aborted) {
       log7.info("multi-credential crawl cancelled by signal", { pagesExplored, queued: pageQueue.length });
       break;
@@ -129292,8 +129442,7 @@ async function runMultiCredential(config3, credentials) {
     const navigateResults = await Promise.all(activeContexts.map(async (ctx) => {
       try {
         await ctx.page.goto(entry.url, { waitUntil: "domcontentloaded", timeout: 15000 });
-        await ctx.page.waitForTimeout(POST_GOTO_WAIT);
-        await ctx.page.waitForLoadState("domcontentloaded", { timeout: 5000 }).catch(() => {});
+        await stabilizeAfterGoto(ctx.page);
         return { ctx, success: true, redirected: normalizeUrl(ctx.page.url()) !== normalizeUrl(entry.url) };
       } catch (err) {
         log7.warn("navigation failed", { credential: ctx.id, url: entry.url, err: String(err) });
@@ -129364,15 +129513,31 @@ async function runMultiCredential(config3, credentials) {
       });
     }
     for (const ctx of visitableContexts) {
+      if (isBrowserDead(health))
+        break;
       log7.info("exploring", { credential: ctx.id, url: entry.url });
       const exploreInline = async (p, url3, depth) => {
+        if (isBrowserDead(health))
+          return;
         const found = await explorePageWithAI(p, url3, ctx.interceptor, model, globalState, inScope, ctx.id, maxPages, usageAcc, { explore: exploreInline, depth });
         for (const u of found)
           enqueueWithContext(u, ctx.id, pageQueue, visitedPages, inScope, pathPatternCounts);
       };
-      const discovered = await explorePageWithAI(ctx.page, entry.url, ctx.interceptor, model, globalState, inScope, ctx.id, maxPages, usageAcc, { explore: exploreInline, depth: 0 });
-      for (const url3 of discovered) {
-        enqueueWithContext(url3, ctx.id, pageQueue, visitedPages, inScope, pathPatternCounts);
+      try {
+        const discovered = await explorePageWithAI(ctx.page, entry.url, ctx.interceptor, model, globalState, inScope, ctx.id, maxPages, usageAcc, { explore: exploreInline, depth: 0 });
+        for (const url3 of discovered) {
+          enqueueWithContext(url3, ctx.id, pageQueue, visitedPages, inScope, pathPatternCounts);
+        }
+      } catch (err) {
+        if (isBrowserDead(health)) {
+          log7.error("exploration aborted — browser died mid-page", {
+            credential: ctx.id,
+            url: entry.url,
+            reason: health.reason
+          });
+          break;
+        }
+        log7.warn("exploration error", { credential: ctx.id, url: entry.url, err: String(err) });
       }
     }
     for (const ctx of visitableContexts) {
@@ -129385,36 +129550,50 @@ async function runMultiCredential(config3, credentials) {
     await drainPageCaptures(captureQueues, captureHandlers, availability, entry.url, visitedBy);
     await visitableContexts[0]?.page.waitForTimeout(300);
   }
-  log7.info("multi-credential exploration complete, draining remaining requests");
-  await contexts[0]?.page.waitForTimeout(2000);
+  const browserDied = isBrowserDead(health);
+  log7.info(browserDied ? "browser died, draining captured requests" : "multi-credential exploration complete, draining remaining requests", {
+    pagesExplored,
+    captured: globalState.capturedEndpoints.size,
+    ...browserDied ? { reason: health.reason } : {}
+  });
+  if (!browserDied)
+    await contexts[0]?.page.waitForTimeout(2000).catch(() => {});
   await drainPageCaptures(captureQueues, captureHandlers, new Map, null, null);
   log7.info("multi-credential crawl done", {
     pagesExplored,
     credentials: contexts.map((c) => c.id),
     totalSteps: globalState.totalSteps,
-    capturedEndpoints: globalState.capturedEndpoints.size
+    capturedEndpoints: globalState.capturedEndpoints.size,
+    browserDied
   });
-  const mutationCount = [...globalState.capturedEndpoints].filter((e2) => /^(POST|PUT|PATCH|DELETE)\s/.test(e2)).length;
-  const credentialIds = contexts.map((c) => c.id);
-  for (const ctx of contexts) {
-    csEmit(ctx.page, {
-      type: "crawl-done",
-      summary: {
-        pagesExplored,
-        capturedEndpoints: globalState.capturedEndpoints.size,
-        mutations: mutationCount,
-        credentials: credentialIds
-      }
-    });
+  if (!browserDied) {
+    const mutationCount = [...globalState.capturedEndpoints].filter((e2) => /^(POST|PUT|PATCH|DELETE)\s/.test(e2)).length;
+    const credentialIds = contexts.map((c) => c.id);
+    for (const ctx of contexts) {
+      csEmit(ctx.page, {
+        type: "crawl-done",
+        summary: {
+          pagesExplored,
+          capturedEndpoints: globalState.capturedEndpoints.size,
+          mutations: mutationCount,
+          credentials: credentialIds
+        }
+      });
+    }
+    await contexts[0]?.page.waitForTimeout(600).catch(() => {});
+  }
+  if (!config3.headless && browser.isConnected()) {
+    log7.info("crawl complete — browser stays open, close the window to finish");
+    await waitForBrowserClose(browser, config3.signal);
+  } else if (!browserDied) {
+    await browser.close().catch(() => {});
   }
-  await contexts[0]?.page.waitForTimeout(600).catch(() => {});
-  await browser.close();
   return {
     sessionID: dryRun ? "" : sessionId,
     capturedEndpoints: globalState.capturedEndpoints.size,
     pagesExplored,
     totalSteps: globalState.totalSteps,
-    errors: [],
+    errors: browserDied ? [`Browser died: ${health.reason}. Captured ${globalState.capturedEndpoints.size} endpoints before failure.`] : [],
     usage: usageAcc
   };
 }
@@ -129456,11 +129635,13 @@ async function run(config3) {
     sessionID = created;
   }
   const browser = await connect({ cdp: config3.cdp, headless: config3.headless ?? false });
-  const context = await browser.newContext(contextOptions(browser.version()));
+  const health = createBrowserHealth();
+  const context = await browser.newContext(contextOptions(config3.headless ?? false));
   await context.addInitScript(INIT_SCRIPT);
   if (panelOn)
     await context.addInitScript(PANEL_INIT_SCRIPT);
   const page = await context.newPage();
+  attachLifecycleHandlers(browser, page, health);
   attachDialogAutoAccept(page);
   attachFileChooserAutoFill(page);
   if (config3.auth.sessionFile) {
@@ -129485,191 +129666,258 @@ async function run(config3) {
       await handleCapture(captured);
     }
   }, 500);
-  await page.goto(targetUrl, { waitUntil: "domcontentloaded", timeout: 30000 });
-  csEmit(page, {
-    type: "init",
-    target: targetUrl,
-    credentials: [],
-    maxPages,
-    startedAt: Date.now()
-  });
-  const isAuthenticated = config3.auth.authenticated || !!config3.auth.credentials;
-  if (config3.auth.authenticated) {
-    await waitForManualLogin(page);
-    if (!dryRun && credentialId) {
-      const registeredId = await registerCredential(serverUrl, sessionID, credentialId);
-      if (registeredId) {
-        credentialId = registeredId;
-        handleCapture = createIngestHandler(serverUrl, sessionID, credentialId);
-      }
-    }
-  } else if (config3.auth.credentials) {
-    await autoLogin(page, config3.auth.credentials);
-  } else {
-    await handle2FA(page);
-  }
-  const globalState = createGlobalState({ outOfScope: config3.outOfScope });
-  if (config3.outOfScope?.length) {
-    log7.info("out-of-scope labels", { count: config3.outOfScope.length, labels: config3.outOfScope });
-  }
-  if (isAuthenticated) {
-    globalState.authPhase = "authenticated";
-  }
-  globalState.visitedPages.add(normalizeUrl(page.url()));
-  globalState.pageQueue.push(page.url());
-  page.on("response", (response) => {
-    if (globalState.authPhase === "authenticated")
-      return;
-    const req = response.request();
-    const method = req.method();
-    const status = response.status();
-    try {
-      const pathname = new URL(req.url()).pathname;
-      if (LOGIN_SUCCESS_PATTERN.test(`${method} ${pathname} [${status}]`)) {
-        log7.info("login success detected via HTTP response");
-        triggerReDiscovery(globalState);
+  try {
+    const initNavErr = await page.goto(targetUrl, { waitUntil: "domcontentloaded", timeout: 30000 }).then(() => null).catch((e2) => e2);
+    if (initNavErr) {
+      log7.warn("initial navigation failed", { url: targetUrl, err: initNavErr.message.split(`
+`)[0] });
+      if (!config3.headless && browser.isConnected()) {
+        log7.info("browser stays open — navigate manually or close the window to finish");
+        await waitForBrowserClose(browser, config3.signal);
+      } else {
+        await browser.close().catch(() => {});
       }
-    } catch {}
-  });
-  let pagesExplored = 0;
-  while (globalState.pageQueue.length > 0 && pagesExplored < maxPages) {
-    if (config3.signal?.aborted) {
-      log7.info("crawl cancelled by signal", { pagesExplored, queued: globalState.pageQueue.length });
-      break;
+      return {
+        sessionID: dryRun ? "" : sessionID,
+        capturedEndpoints: 0,
+        pagesExplored: 0,
+        totalSteps: 0,
+        errors: [`Initial navigation failed: ${initNavErr.message}`],
+        usage: usageAcc
+      };
     }
-    const nextUrl = globalState.pageQueue.shift();
-    pagesExplored++;
-    if (page.url() !== nextUrl) {
-      const navErr = await page.goto(nextUrl, { waitUntil: "domcontentloaded", timeout: 15000 }).then(() => null).catch((e2) => e2);
-      if (navErr) {
-        log7.warn("navigation failed", { url: nextUrl, err: navErr.message.split(`
-`)[0] });
-        continue;
+    csEmit(page, {
+      type: "init",
+      target: targetUrl,
+      credentials: [],
+      maxPages,
+      startedAt: Date.now()
+    });
+    const isAuthenticated = config3.auth.authenticated || !!config3.auth.credentials;
+    if (config3.auth.authenticated) {
+      await waitForManualLogin(page);
+      if (!dryRun && credentialId) {
+        const registeredId = await registerCredential(serverUrl, sessionID, credentialId);
+        if (registeredId) {
+          credentialId = registeredId;
+          handleCapture = createIngestHandler(serverUrl, sessionID, credentialId);
+        }
       }
-      await page.waitForTimeout(POST_GOTO_WAIT);
-      await page.waitForLoadState("domcontentloaded", { timeout: 5000 }).catch(() => {});
+    } else if (config3.auth.credentials) {
+      await autoLogin(page, config3.auth.credentials);
+    } else {
+      await handle2FA(page);
     }
-    if (!isInScope(page.url(), inScope)) {
-      log7.info("off-host redirect, skipping", { url: page.url() });
-      await page.goto(targetUrl, { waitUntil: "domcontentloaded", timeout: 15000 }).catch(() => {});
-      continue;
+    const globalState = createGlobalState({ outOfScope: config3.outOfScope });
+    if (config3.outOfScope?.length) {
+      log7.info("out-of-scope labels", { count: config3.outOfScope.length, labels: config3.outOfScope });
     }
-    const currentUrl = normalizeUrl(page.url());
-    if (currentUrl !== normalizeUrl(nextUrl) && globalState.visitedPages.has(currentUrl)) {
-      log7.info("redirect to already-explored page, skipping", { requested: normalizeUrl(nextUrl), landed: currentUrl });
-      continue;
+    if (isAuthenticated) {
+      globalState.authPhase = "authenticated";
     }
-    globalState.visitedPages.add(currentUrl);
-    log7.info("exploring page", { page: `${pagesExplored}/${maxPages}`, url: currentUrl });
-    log7.debug("state", {
-      phase: globalState.authPhase,
-      queueSize: globalState.pageQueue.length,
-      queue: globalState.pageQueue.slice(0, 5).map((u) => {
-        try {
-          return new URL(u).pathname + new URL(u).hash;
-        } catch {
-          return u;
+    globalState.visitedPages.add(normalizeUrl(page.url()));
+    globalState.pageQueue.push(page.url());
+    page.on("response", (response) => {
+      if (globalState.authPhase === "authenticated")
+        return;
+      const req = response.request();
+      const method = req.method();
+      const status = response.status();
+      try {
+        const pathname = new URL(req.url()).pathname;
+        if (LOGIN_SUCCESS_PATTERN.test(`${method} ${pathname} [${status}]`)) {
+          log7.info("login success detected via HTTP response");
+          triggerReDiscovery(globalState);
         }
-      }),
-      visited: globalState.visitedPages.size,
-      deferred: globalState.deferredAuthPages.map((d) => `${d.type}:${d.url.split("/").pop()}`),
-      endpoints: globalState.capturedEndpoints.size,
-      steps: globalState.totalSteps
-    });
-    await page.keyboard.press("Escape").catch(() => {});
-    await page.waitForTimeout(OVERLAY_ESCAPE_WAIT);
-    if (await isViewportCenterBlocked(page)) {
-      const dims = await page.evaluate(() => ({ w: window.innerWidth, h: window.innerHeight }));
-      await page.mouse.click(dims.w / 2, dims.h / 2).catch(() => {});
-      await page.waitForTimeout(OVERLAY_ESCAPE_WAIT);
-    }
-    await dismissCookieBanner(page);
-    await revealLazyContent(page);
-    await expandDisclosures(page);
-    const intel = getIntelligence(globalState, SINGLE_CRED);
-    const oldFingerprint = intel.pageFingerprints.get(currentUrl);
-    log7.debug("fingerprint check", { url: currentUrl, hasOld: !!oldFingerprint });
-    if (oldFingerprint !== undefined) {
-      const currentElements = await collectElements(page);
-      const newFingerprint = generateFingerprint(currentElements);
-      log7.debug("fingerprint compare", {
-        url: currentUrl,
-        match: newFingerprint === oldFingerprint,
-        oldFp: oldFingerprint.slice(0, 80),
-        newFp: newFingerprint.slice(0, 80)
-      });
-      if (newFingerprint === oldFingerprint) {
-        log7.info("page unchanged after auth, skipping exploration", { url: currentUrl });
-        const domLinks = await collectDOMLinks(page, currentUrl, inScope);
-        for (const url3 of domLinks) {
-          enqueueUrl(url3, globalState, inScope);
-        }
-        intel.pageFingerprints.set(currentUrl, newFingerprint);
-        await page.waitForTimeout(300);
+      } catch {}
+    });
+    let pagesExplored = 0;
+    while (globalState.pageQueue.length > 0 && pagesExplored < maxPages) {
+      if (isBrowserDead(health)) {
+        log7.error("browser died, terminating crawl", {
+          reason: health.reason,
+          pagesExplored,
+          captured: globalState.capturedEndpoints.size
+        });
+        break;
+      }
+      if (config3.signal?.aborted) {
+        log7.info("crawl cancelled by signal", { pagesExplored, queued: globalState.pageQueue.length });
+        break;
+      }
+      const nextUrl = globalState.pageQueue.shift();
+      pagesExplored++;
+      if (page.url() !== nextUrl) {
+        const navErr = await page.goto(nextUrl, { waitUntil: "domcontentloaded", timeout: 15000 }).then(() => null).catch((e2) => e2);
+        if (navErr) {
+          log7.warn("navigation failed", { url: nextUrl, err: navErr.message.split(`
+`)[0] });
+          continue;
+        }
+        await stabilizeAfterGoto(page);
+      }
+      if (!isInScope(page.url(), inScope)) {
+        log7.info("off-host redirect, skipping", { url: page.url() });
+        await page.goto(targetUrl, { waitUntil: "domcontentloaded", timeout: 15000 }).catch(() => {});
         continue;
       }
-      log7.info("page changed after auth, re-exploring", { url: currentUrl });
-    }
-    const exploreInline = async (p, url3, depth) => {
-      const found = await explorePageWithAI(p, url3, interceptor, model, globalState, inScope, SINGLE_CRED, maxPages, usageAcc, { explore: exploreInline, depth });
-      for (const u of found)
-        enqueueUrl(u, globalState, inScope);
-    };
-    const discovered = await explorePageWithAI(page, currentUrl, interceptor, model, globalState, inScope, SINGLE_CRED, maxPages, usageAcc, { explore: exploreInline, depth: 0 });
-    let newEnqueued = 0;
-    for (const url3 of discovered) {
-      if (enqueueUrl(url3, globalState, inScope))
-        newEnqueued++;
-    }
-    if (discovered.length > 0) {
-      log7.debug("discovered links", {
-        found: discovered.length,
-        enqueued: newEnqueued,
-        queueSize: globalState.pageQueue.length
-      });
-    }
-    flushReDiscovery(globalState);
-    await page.waitForTimeout(300);
-    if (globalState.pageQueue.length === 0 && globalState.deferredAuthPages.length > 0) {
-      log7.debug("queue empty, processing auth phase", {
+      const currentUrl = normalizeUrl(page.url());
+      if (currentUrl !== normalizeUrl(nextUrl) && globalState.visitedPages.has(currentUrl)) {
+        log7.info("redirect to already-explored page, skipping", {
+          requested: normalizeUrl(nextUrl),
+          landed: currentUrl
+        });
+        continue;
+      }
+      globalState.visitedPages.add(currentUrl);
+      log7.info("exploring page", { page: `${pagesExplored}/${maxPages}`, url: currentUrl });
+      log7.debug("state", {
         phase: globalState.authPhase,
-        deferred: globalState.deferredAuthPages.map((d) => d.type)
+        queueSize: globalState.pageQueue.length,
+        queue: globalState.pageQueue.slice(0, 5).map((u) => {
+          try {
+            return new URL(u).pathname + new URL(u).hash;
+          } catch {
+            return u;
+          }
+        }),
+        visited: globalState.visitedPages.size,
+        deferred: globalState.deferredAuthPages.map((d) => `${d.type}:${d.url.split("/").pop()}`),
+        endpoints: globalState.capturedEndpoints.size,
+        steps: globalState.totalSteps
       });
-      processAuthPhase(globalState);
+      await page.keyboard.press("Escape").catch(() => {});
+      await page.waitForTimeout(OVERLAY_ESCAPE_WAIT);
+      if (await isViewportCenterBlocked(page)) {
+        const dims = await page.evaluate(() => ({ w: window.innerWidth, h: window.innerHeight }));
+        await page.mouse.click(dims.w / 2, dims.h / 2).catch(() => {});
+        await page.waitForTimeout(OVERLAY_ESCAPE_WAIT);
+      }
+      await dismissCookieBanner(page);
+      await revealLazyContent(page);
+      await expandDisclosures(page);
+      const intel = getIntelligence(globalState, SINGLE_CRED);
+      const oldFingerprint = intel.pageFingerprints.get(currentUrl);
+      log7.debug("fingerprint check", { url: currentUrl, hasOld: !!oldFingerprint });
+      if (oldFingerprint !== undefined) {
+        const currentElements = await collectElements(page);
+        const newFingerprint = generateFingerprint(currentElements);
+        log7.debug("fingerprint compare", {
+          url: currentUrl,
+          match: newFingerprint === oldFingerprint,
+          oldFp: oldFingerprint.slice(0, 80),
+          newFp: newFingerprint.slice(0, 80)
+        });
+        if (newFingerprint === oldFingerprint) {
+          log7.info("page unchanged after auth, skipping exploration", { url: currentUrl });
+          const domLinks = await collectDOMLinks(page, currentUrl, inScope);
+          for (const url3 of domLinks) {
+            enqueueUrl(url3, globalState, inScope);
+          }
+          intel.pageFingerprints.set(currentUrl, newFingerprint);
+          await page.waitForTimeout(300);
+          continue;
+        }
+        log7.info("page changed after auth, re-exploring", { url: currentUrl });
+      }
+      const exploreInline = async (p, url3, depth) => {
+        if (isBrowserDead(health))
+          return;
+        const found = await explorePageWithAI(p, url3, interceptor, model, globalState, inScope, SINGLE_CRED, maxPages, usageAcc, { explore: exploreInline, depth });
+        for (const u of found)
+          enqueueUrl(u, globalState, inScope);
+      };
+      let discovered = [];
+      try {
+        discovered = await explorePageWithAI(page, currentUrl, interceptor, model, globalState, inScope, SINGLE_CRED, maxPages, usageAcc, { explore: exploreInline, depth: 0 });
+      } catch (err) {
+        if (isBrowserDead(health)) {
+          log7.error("exploration aborted — browser died mid-page", { url: currentUrl, reason: health.reason });
+          break;
+        }
+        log7.warn("exploration error", { url: currentUrl, err: String(err) });
+      }
+      let newEnqueued = 0;
+      for (const url3 of discovered) {
+        if (enqueueUrl(url3, globalState, inScope))
+          newEnqueued++;
+      }
+      if (discovered.length > 0) {
+        log7.debug("discovered links", {
+          found: discovered.length,
+          enqueued: newEnqueued,
+          queueSize: globalState.pageQueue.length
+        });
+      }
+      flushReDiscovery(globalState);
+      await page.waitForTimeout(300);
+      if (globalState.pageQueue.length === 0 && globalState.deferredAuthPages.length > 0) {
+        log7.debug("queue empty, processing auth phase", {
+          phase: globalState.authPhase,
+          deferred: globalState.deferredAuthPages.map((d) => d.type)
+        });
+        processAuthPhase(globalState);
+      }
     }
-  }
-  log7.info("exploration complete, draining remaining requests");
-  await page.waitForTimeout(2000);
-  clearInterval(drainInterval);
-  while (captureQueue.length > 0) {
-    const captured = captureQueue.shift();
-    await handleCapture(captured);
-  }
-  log7.info("done", {
-    pagesExplored,
-    totalSteps: globalState.totalSteps,
-    capturedEndpoints: globalState.capturedEndpoints.size,
-    sessionID: dryRun ? undefined : sessionID
-  });
-  csEmit(page, {
-    type: "crawl-done",
-    summary: {
+    const browserDied = isBrowserDead(health);
+    log7.info(browserDied ? "browser died, draining captured requests" : "exploration complete, draining remaining requests", {
+      pagesExplored,
+      captured: globalState.capturedEndpoints.size,
+      ...browserDied ? { reason: health.reason } : {}
+    });
+    if (!browserDied)
+      await page.waitForTimeout(2000).catch(() => {});
+    while (captureQueue.length > 0) {
+      const captured = captureQueue.shift();
+      await handleCapture(captured);
+    }
+    log7.info("done", {
       pagesExplored,
+      totalSteps: globalState.totalSteps,
       capturedEndpoints: globalState.capturedEndpoints.size,
-      mutations: [...globalState.capturedEndpoints].filter((e2) => /^(POST|PUT|PATCH|DELETE)\s/.test(e2)).length,
-      credentials: [SINGLE_CRED]
+      sessionID: dryRun ? undefined : sessionID,
+      browserDied
+    });
+    if (!browserDied) {
+      csEmit(page, {
+        type: "crawl-done",
+        summary: {
+          pagesExplored,
+          capturedEndpoints: globalState.capturedEndpoints.size,
+          mutations: [...globalState.capturedEndpoints].filter((e2) => /^(POST|PUT|PATCH|DELETE)\s/.test(e2)).length,
+          credentials: [SINGLE_CRED]
+        }
+      });
+      await page.waitForTimeout(600).catch(() => {});
+      while (captureQueue.length > 0) {
+        const captured = captureQueue.shift();
+        await handleCapture(captured);
+      }
+    }
+    if (!config3.headless && browser.isConnected()) {
+      log7.info("crawl complete — browser stays open, close the window to finish");
+      const postCrawlDrain = setInterval(async () => {
+        while (captureQueue.length > 0) {
+          const captured = captureQueue.shift();
+          await handleCapture(captured);
+        }
+      }, 500);
+      await waitForBrowserClose(browser, config3.signal);
+      clearInterval(postCrawlDrain);
+    } else if (!browserDied) {
+      await browser.close().catch(() => {});
     }
-  });
-  await page.waitForTimeout(600).catch(() => {});
-  await browser.close();
-  return {
-    sessionID: dryRun ? "" : sessionID,
-    capturedEndpoints: globalState.capturedEndpoints.size,
-    pagesExplored,
-    totalSteps: globalState.totalSteps,
-    errors: [],
-    usage: usageAcc
-  };
+    return {
+      sessionID: dryRun ? "" : sessionID,
+      capturedEndpoints: globalState.capturedEndpoints.size,
+      pagesExplored,
+      totalSteps: globalState.totalSteps,
+      errors: browserDied ? [`Browser died: ${health.reason}. Captured ${globalState.capturedEndpoints.size} endpoints before failure.`] : [],
+      usage: usageAcc
+    };
+  } finally {
+    clearInterval(drainInterval);
+  }
 }
 
 // ../hackbrowser/src/api.ts
@@ -129962,7 +130210,11 @@ async function main() {
       });
     }
   });
-  await new Promise((resolve4) => rl.once("close", resolve4));
+  await new Promise((resolve4) => rl.once("close", () => {
+    controller.abort();
+    resolve4();
+  }));
+  setTimeout(() => process.exit(0), 5000).unref();
 }
 async function runWorker(opts, signal) {
   const crawlOpts = buildCrawlOptions(opts, signal);