@browserbasehq/orca 3.1.0-patch.0 → 3.1.0-patch.1

package/dist/cjs/lib/v3/tests/keep-alive.child.js

@@ -0,0 +1,92 @@
+var import_v3 = require("../v3.js");
+async function main() {
+  const encoded = process.argv.find((arg) => arg.startsWith("cfg:"));
+  if (!encoded) {
+    throw new Error("Missing child config payload.");
+  }
+  const raw = Buffer.from(encoded.slice(4), "base64").toString("utf8");
+  const cfg = JSON.parse(raw);
+  const {
+    env,
+    keepAlive,
+    disableAPI,
+    scenario,
+    apiKey,
+    projectId,
+    debug = false,
+    viewMs = 0
+  } = cfg;
+  const log = (message) => {
+    if (debug) {
+      console.log(message);
+    }
+  };
+  if (env !== "LOCAL" && env !== "BROWSERBASE") {
+    throw new Error("KEEP_ALIVE_ENV must be LOCAL or BROWSERBASE");
+  }
+  if (!scenario) {
+    throw new Error("KEEP_ALIVE_SCENARIO is required");
+  }
+  log(
+    `[keep-alive-child] env=${env} keepAlive=${keepAlive} disableAPI=${disableAPI} scenario=${scenario} apiKey=${apiKey ? "set" : "missing"} projectId=${projectId ? "set" : "missing"}`
+  );
+  const showBrowser = viewMs > 0;
+  const v3 = new import_v3.V3({
+    env,
+    keepAlive,
+    disableAPI,
+    apiKey,
+    projectId,
+    browserbaseSessionCreateParams: void 0,
+    localBrowserLaunchOptions: env === "LOCAL" ? {
+      executablePath: process.env.CHROME_PATH,
+      args: process.env.CI ? ["--no-sandbox"] : void 0,
+      headless: !showBrowser,
+      viewport: { width: 1288, height: 711 }
+    } : void 0,
+    verbose: debug ? 2 : 0,
+    disablePino: true,
+    logger: debug ? (line) => console.log(line) : void 0
+  });
+  await v3.init();
+  const info = {
+    connectURL: v3.connectURL(),
+    sessionId: v3.browserbaseSessionId ?? null
+  };
+  await new Promise((resolve, reject) => {
+    process.stdout.write(`__KEEPALIVE__${JSON.stringify(info)}
+`, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+  if (env === "LOCAL" && viewMs > 0) {
+    await new Promise((r) => setTimeout(r, viewMs));
+  }
+  if (scenario === "close") {
+    await v3.close().catch(() => {
+    });
+    process.exit(0);
+  }
+  if (scenario === "sigterm") {
+    return;
+  }
+  if (scenario === "sigint") {
+    return;
+  }
+  if (scenario === "unhandled") {
+    setTimeout(() => {
+      void Promise.reject(new Error("keepAlive unhandled rejection"));
+    }, 0);
+    return;
+  }
+  throw new Error(`Unknown scenario: ${scenario}`);
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+//# sourceMappingURL=keep-alive.child.js.map

package/dist/cjs/lib/v3/tests/keep-alive.child.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../lib/v3/tests/keep-alive.child.ts"],
+  "sourcesContent": ["import { V3 } from \"../v3.js\";\n\nasync function main(): Promise<void> {\n  const encoded = process.argv.find((arg) => arg.startsWith(\"cfg:\"));\n  if (!encoded) {\n    throw new Error(\"Missing child config payload.\");\n  }\n  const raw = Buffer.from(encoded.slice(4), \"base64\").toString(\"utf8\");\n  const cfg = JSON.parse(raw) as {\n    env: \"LOCAL\" | \"BROWSERBASE\";\n    keepAlive: boolean;\n    disableAPI: boolean;\n    scenario: string;\n    apiKey?: string;\n    projectId?: string;\n    debug?: boolean;\n    viewMs?: number;\n  };\n  const {\n    env,\n    keepAlive,\n    disableAPI,\n    scenario,\n    apiKey,\n    projectId,\n    debug = false,\n    viewMs = 0,\n  } = cfg;\n\n  const log = (message: string): void => {\n    if (debug) {\n      console.log(message);\n    }\n  };\n\n  if (env !== \"LOCAL\" && env !== \"BROWSERBASE\") {\n    throw new Error(\"KEEP_ALIVE_ENV must be LOCAL or BROWSERBASE\");\n  }\n  if (!scenario) {\n    throw new Error(\"KEEP_ALIVE_SCENARIO is required\");\n  }\n\n  log(\n    `[keep-alive-child] env=${env} keepAlive=${keepAlive} disableAPI=${disableAPI} ` +\n      `scenario=${scenario} apiKey=${apiKey ? \"set\" : \"missing\"} ` +\n      `projectId=${projectId ? \"set\" : \"missing\"}`,\n  );\n\n  const showBrowser = viewMs > 0;\n  const v3 = new V3({\n    env,\n    keepAlive,\n    disableAPI,\n    apiKey,\n    projectId,\n    browserbaseSessionCreateParams: undefined,\n    localBrowserLaunchOptions:\n      env === \"LOCAL\"\n        ? {\n            executablePath: process.env.CHROME_PATH,\n            args: process.env.CI ? [\"--no-sandbox\"] : undefined,\n            headless: !showBrowser,\n            viewport: { width: 1288, height: 711 },\n          }\n        : undefined,\n    verbose: debug ? 2 : 0,\n    disablePino: true,\n    logger: debug ? (line) => console.log(line) : undefined,\n  });\n\n  await v3.init();\n\n  const info = {\n    connectURL: v3.connectURL(),\n    sessionId: v3.browserbaseSessionId ?? null,\n  };\n  await new Promise<void>((resolve, reject) => {\n    process.stdout.write(`__KEEPALIVE__${JSON.stringify(info)}\\n`, (error) => {\n      if (error) {\n        reject(error);\n        return;\n      }\n      resolve();\n    });\n  });\n\n  if (env === \"LOCAL\" && viewMs > 0) {\n    await new Promise((r) => setTimeout(r, viewMs));\n  }\n\n  if (scenario === \"close\") {\n    await v3.close().catch(() => {});\n    process.exit(0);\n  }\n\n  if (scenario === \"sigterm\") {\n    return;\n  }\n\n  if (scenario === \"sigint\") {\n    return;\n  }\n\n  if (scenario === \"unhandled\") {\n    setTimeout(() => {\n      void Promise.reject(new Error(\"keepAlive unhandled rejection\"));\n    }, 0);\n    return;\n  }\n\n  throw new Error(`Unknown scenario: ${scenario}`);\n}\n\nmain().catch((err) => {\n  console.error(err);\n  process.exit(1);\n});\n"],
+  "mappings": "AAAA,gBAAmB;AAEnB,eAAe,OAAsB;AACnC,QAAM,UAAU,QAAQ,KAAK,KAAK,CAAC,QAAQ,IAAI,WAAW,MAAM,CAAC;AACjE,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI,MAAM,+BAA+B;AAAA,EACjD;AACA,QAAM,MAAM,OAAO,KAAK,QAAQ,MAAM,CAAC,GAAG,QAAQ,EAAE,SAAS,MAAM;AACnE,QAAM,MAAM,KAAK,MAAM,GAAG;AAU1B,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,QAAQ;AAAA,IACR,SAAS;AAAA,EACX,IAAI;AAEJ,QAAM,MAAM,CAAC,YAA0B;AACrC,QAAI,OAAO;AACT,cAAQ,IAAI,OAAO;AAAA,IACrB;AAAA,EACF;AAEA,MAAI,QAAQ,WAAW,QAAQ,eAAe;AAC5C,UAAM,IAAI,MAAM,6CAA6C;AAAA,EAC/D;AACA,MAAI,CAAC,UAAU;AACb,UAAM,IAAI,MAAM,iCAAiC;AAAA,EACnD;AAEA;AAAA,IACE,0BAA0B,GAAG,cAAc,SAAS,eAAe,UAAU,aAC/D,QAAQ,WAAW,SAAS,QAAQ,SAAS,cAC5C,YAAY,QAAQ,SAAS;AAAA,EAC9C;AAEA,QAAM,cAAc,SAAS;AAC7B,QAAM,KAAK,IAAI,aAAG;AAAA,IAChB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,gCAAgC;AAAA,IAChC,2BACE,QAAQ,UACJ;AAAA,MACE,gBAAgB,QAAQ,IAAI;AAAA,MAC5B,MAAM,QAAQ,IAAI,KAAK,CAAC,cAAc,IAAI;AAAA,MAC1C,UAAU,CAAC;AAAA,MACX,UAAU,EAAE,OAAO,MAAM,QAAQ,IAAI;AAAA,IACvC,IACA;AAAA,IACN,SAAS,QAAQ,IAAI;AAAA,IACrB,aAAa;AAAA,IACb,QAAQ,QAAQ,CAAC,SAAS,QAAQ,IAAI,IAAI,IAAI;AAAA,EAChD,CAAC;AAED,QAAM,GAAG,KAAK;AAEd,QAAM,OAAO;AAAA,IACX,YAAY,GAAG,WAAW;AAAA,IAC1B,WAAW,GAAG,wBAAwB;AAAA,EACxC;AACA,QAAM,IAAI,QAAc,CAAC,SAAS,WAAW;AAC3C,YAAQ,OAAO,MAAM,gBAAgB,KAAK,UAAU,IAAI,CAAC;AAAA,GAAM,CAAC,UAAU;AACxE,UAAI,OAAO;AACT,eAAO,KAAK;AACZ;AAAA,MACF;AACA,cAAQ;AAAA,IACV,CAAC;AAAA,EACH,CAAC;AAED,MAAI,QAAQ,WAAW,SAAS,GAAG;AACjC,UAAM,IAAI,QAAQ,CAAC,MAAM,WAAW,GAAG,MAAM,CAAC;AAAA,EAChD;AAEA,MAAI,aAAa,SAAS;AACxB,UAAM,GAAG,MAAM,EAAE,MAAM,MAAM;AAAA,IAAC,CAAC;AAC/B,YAAQ,KAAK,CAAC;AAAA,EAChB;AAEA,MAAI,aAAa,WAAW;AAC1B;AAAA,EACF;AAEA,MAAI,aAAa,UAAU;AACzB;AAAA,EACF;AAEA,MAAI,aAAa,aAAa;AAC5B,eAAW,MAAM;AACf,WAAK,QAAQ,OAAO,IAAI,MAAM,+BAA+B,CAAC;AAAA,IAChE,GAAG,CAAC;AACJ;AAAA,EACF;AAEA,QAAM,IAAI,MAAM,qBAAqB,QAAQ,EAAE;AACjD;AAEA,KAAK,EAAE,MAAM,CAAC,QAAQ;AACpB,UAAQ,MAAM,GAAG;AACjB,UAAQ,KAAK,CAAC;AAChB,CAAC;",
+  "names": []
+}

package/dist/cjs/lib/v3/tests/keep-alive.helpers.js

@@ -0,0 +1,568 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var keep_alive_helpers_exports = {};
+__export(keep_alive_helpers_exports, {
+  buildKeepAliveCases: () => buildKeepAliveCases,
+  getKeepAliveEnvConfig: () => getKeepAliveEnvConfig,
+  runKeepAliveCase: () => runKeepAliveCase
+});
+module.exports = __toCommonJS(keep_alive_helpers_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_url = require("node:url");
+var import_sdk = __toESM(require("@browserbasehq/sdk"), 1);
+var import_ws = __toESM(require("ws"), 1);
+var import_v3_dynamic_config = require("./v3.dynamic.config.js");
+const import_meta = {};
+const testsDir = import_node_path.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
+const findCoreDir = (startDir) => {
+  let current = import_node_path.default.resolve(startDir);
+  while (true) {
+    const packageJsonPath = import_node_path.default.join(current, "package.json");
+    if (import_node_fs.default.existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(import_node_fs.default.readFileSync(packageJsonPath, "utf8"));
+        if (pkg.name === "@browserbasehq/stagehand") {
+          return current;
+        }
+      } catch {
+      }
+    }
+    const parent = import_node_path.default.dirname(current);
+    if (parent === current) {
+      return import_node_path.default.resolve(startDir, "../../..");
+    }
+    current = parent;
+  }
+};
+const coreDir = findCoreDir(testsDir);
+const resolveChildRunner = () => {
+  const distJsPath = import_node_path.default.join(
+    coreDir,
+    "dist",
+    "esm",
+    "lib",
+    "v3",
+    "tests",
+    "keep-alive.child.js"
+  );
+  if (import_node_fs.default.existsSync(distJsPath)) {
+    return { command: process.execPath, args: [distJsPath] };
+  }
+  return null;
+};
+const childRunner = resolveChildRunner();
+const DEBUG = process.env.KEEP_ALIVE_DEBUG === "1";
+const VIEW_MS = Number(process.env.KEEP_ALIVE_VIEW_MS ?? "0");
+const LOCAL_TIMEOUT_MS = Number(
+  process.env.KEEP_ALIVE_LOCAL_TIMEOUT_MS ?? "8000"
+);
+const BB_TIMEOUT_MS = Number(process.env.KEEP_ALIVE_BB_TIMEOUT_MS ?? "30000");
+const STAY_OPEN_MS = Number(process.env.KEEP_ALIVE_STAY_OPEN_MS ?? "6000");
+const ACTION_EXIT_TIMEOUT_MS = Number(
+  process.env.KEEP_ALIVE_ACTION_EXIT_TIMEOUT_MS ?? "3000"
+);
+const LOCAL_INFO_TIMEOUT_MS = Number(
+  process.env.KEEP_ALIVE_LOCAL_INFO_TIMEOUT_MS ?? "15000"
+);
+const BB_INFO_TIMEOUT_MS = Number(
+  process.env.KEEP_ALIVE_BB_INFO_TIMEOUT_MS ?? (process.env.CI ? "45000" : "30000")
+);
+const getInfoTimeoutMs = (env) => env === "BROWSERBASE" ? BB_INFO_TIMEOUT_MS : LOCAL_INFO_TIMEOUT_MS;
+function debugLog(message) {
+  if (DEBUG) {
+    console.log(message);
+  }
+}
+function parseChildInfo(line) {
+  const prefix = "__KEEPALIVE__";
+  if (!line.startsWith(prefix)) return null;
+  try {
+    return JSON.parse(line.slice(prefix.length));
+  } catch {
+    return null;
+  }
+}
+async function runScenario(config) {
+  const payload = {
+    env: config.env,
+    keepAlive: config.keepAlive,
+    disableAPI: config.disableAPI,
+    scenario: config.kind,
+    apiKey: config.apiKey,
+    projectId: config.projectId,
+    debug: config.debug,
+    viewMs: config.viewMs
+  };
+  const encoded = `cfg:${Buffer.from(JSON.stringify(payload)).toString("base64")}`;
+  if (!childRunner) {
+    throw new Error(
+      "keep-alive child script not found at dist/esm/lib/v3/tests/keep-alive.child.js"
+    );
+  }
+  const child = (0, import_node_child_process.spawn)(childRunner.command, [...childRunner.args, encoded], {
+    cwd: coreDir,
+    env: { ...process.env },
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const logs = { stdout: [], stderr: [] };
+  let buffer = "";
+  let stderr = "";
+  let resolved = false;
+  const infoTimeoutMs = getInfoTimeoutMs(config.env);
+  const infoPromise = new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      child.kill("SIGKILL");
+      const stdoutDetails = logs.stdout.length > 0 ? `
+Child stdout:
+${logs.stdout.join("\n")}` : "";
+      const details = stderr.trim();
+      const suffix = details ? `
+Child stderr:
+${details}` : "\nChild did not emit keepAlive info.";
+      reject(
+        new Error(
+          `Child timed out waiting for info after ${infoTimeoutMs}ms (env=${config.env}, keepAlive=${config.keepAlive}, disableAPI=${config.disableAPI}, scenario=${config.kind}).${suffix}${stdoutDetails}`
+        )
+      );
+    }, infoTimeoutMs);
+    child.stdout.on("data", (chunk) => {
+      buffer += chunk.toString();
+      let idx = buffer.indexOf("\n");
+      while (idx !== -1) {
+        const line = buffer.slice(0, idx).trim();
+        buffer = buffer.slice(idx + 1);
+        const parsed = parseChildInfo(line);
+        if (parsed && !resolved) {
+          resolved = true;
+          clearTimeout(timeout);
+          resolve(parsed);
+        } else if (line.length > 0) {
+          logs.stdout.push(line);
+          debugLog(`[keep-alive-child] ${line}`);
+        }
+        idx = buffer.indexOf("\n");
+      }
+    });
+    child.on("exit", (code, signal) => {
+      if (resolved) return;
+      clearTimeout(timeout);
+      const stdoutDetails = logs.stdout.length > 0 ? `
+Child stdout:
+${logs.stdout.join("\n")}` : "";
+      const details = stderr.trim();
+      const suffix = details ? `
+Child stderr:
+${details}` : "\nChild exited without emitting keepAlive info.";
+      reject(
+        new Error(
+          `Child exited (code=${code ?? "null"}, signal=${signal ?? "null"}) before emitting keepAlive info (env=${config.env}, keepAlive=${config.keepAlive}, disableAPI=${config.disableAPI}, scenario=${config.kind}).${suffix}${stdoutDetails}`
+        )
+      );
+    });
+    child.on("error", (error) => {
+      if (resolved) return;
+      clearTimeout(timeout);
+      reject(error);
+    });
+  });
+  child.stderr.on("data", (chunk) => {
+    const text = chunk.toString();
+    stderr += text;
+    const trimmed = text.trim();
+    if (trimmed.length > 0) {
+      logs.stderr.push(trimmed);
+      debugLog(`[keep-alive-child] ${trimmed}`);
+    }
+  });
+  const info = await infoPromise;
+  return { info, child, logs };
+}
+async function stopChild(child) {
+  if (child.exitCode !== null) return;
+  try {
+    child.kill("SIGKILL");
+  } catch {
+    return;
+  }
+  await new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(), 2e3);
+    child.once("exit", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+}
+async function waitForChildExit(child, timeoutMs) {
+  if (child.exitCode !== null) return;
+  await new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(), timeoutMs);
+    child.once("exit", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+}
+async function checkLocalAlive(connectURL) {
+  let port = "";
+  try {
+    port = new URL(connectURL).port;
+  } catch {
+    return { alive: false, status: "INVALID_URL" };
+  }
+  if (!port) return { alive: false, status: "MISSING_PORT" };
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 1500);
+  try {
+    const resp = await fetch(`http://127.0.0.1:${port}/json/version`, {
+      signal: controller.signal
+    });
+    if (!resp.ok) {
+      return { alive: false, status: `HTTP_${resp.status}` };
+    }
+    const json = await resp.json();
+    const ws = json?.webSocketDebuggerUrl;
+    if (!ws) {
+      return { alive: false, status: "MISSING_WS" };
+    }
+    if (ws !== connectURL) {
+      return { alive: false, status: "WS_MISMATCH" };
+    }
+    return { alive: true, status: "MATCH" };
+  } catch {
+    return { alive: false, status: "FETCH_ERROR" };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function closeLocalBrowser(connectURL) {
+  await new Promise((resolve) => {
+    const ws = new import_ws.default(connectURL);
+    const timer = setTimeout(() => {
+      ws.terminate();
+      resolve();
+    }, 2e3);
+    ws.on("open", () => {
+      ws.send(JSON.stringify({ id: 1, method: "Browser.close" }));
+    });
+    ws.on("error", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+    ws.on("close", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+}
+async function checkBrowserbaseAlive(sessionId, apiKey) {
+  if (!apiKey) return { alive: false, status: "NO_API_KEY" };
+  const bb = new import_sdk.default({ apiKey });
+  try {
+    const snapshot = await bb.sessions.retrieve(sessionId);
+    if (DEBUG) {
+      const status2 = snapshot?.status ?? "<missing>";
+      debugLog(`[keep-alive] session ${sessionId} status=${status2}`);
+    }
+    const status = snapshot?.status;
+    return { alive: status === "RUNNING", status };
+  } catch (error) {
+    debugLog(
+      `[keep-alive] session ${sessionId} retrieve failed: ${String(error)}`
+    );
+    return { alive: false, status: "RETRIEVE_FAILED" };
+  }
+}
+async function endBrowserbaseSession(sessionId, apiKey, projectId) {
+  if (!apiKey || !projectId) return;
+  const bb = new import_sdk.default({ apiKey });
+  try {
+    await bb.sessions.update(sessionId, {
+      status: "REQUEST_RELEASE",
+      projectId
+    });
+  } catch {
+  }
+}
+async function assertStaysOpen(check, durationMs, intervalMs = 500) {
+  const start = Date.now();
+  const deadline = start + durationMs;
+  let lastStatus;
+  while (Date.now() < deadline) {
+    const result = await check();
+    lastStatus = result.status ?? lastStatus;
+    if (!result.alive) {
+      const elapsed = Date.now() - start;
+      const status = lastStatus ? ` (last status ${lastStatus})` : "";
+      throw new Error(
+        `Browser closed after ${elapsed}ms (expected ${durationMs}ms)${status}.`
+      );
+    }
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  return { durationMs: Date.now() - start, lastStatus };
+}
+async function waitForClosed(check, timeoutMs, intervalMs = 500) {
+  const start = Date.now();
+  let lastStatus;
+  while (Date.now() - start < timeoutMs) {
+    const result = await check();
+    lastStatus = result.status ?? lastStatus;
+    if (!result.alive) {
+      return { durationMs: Date.now() - start, lastStatus };
+    }
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  const status = lastStatus ? ` (last status ${lastStatus})` : "";
+  throw new Error(`Browser still alive after ${timeoutMs}ms${status}.`);
+}
+async function assertBrowserState(env, info, shouldStayOpen, apiKey, projectId) {
+  const expected = shouldStayOpen ? "open" : "closed";
+  if (env === "LOCAL") {
+    if (shouldStayOpen) {
+      const result3 = await assertStaysOpen(
+        () => checkLocalAlive(info.connectURL),
+        STAY_OPEN_MS
+      );
+      const outcome = {
+        expected,
+        actual: "open",
+        durationMs: result3.durationMs,
+        lastStatus: result3.lastStatus
+      };
+      await closeLocalBrowser(info.connectURL);
+      return outcome;
+    }
+    const result2 = await waitForClosed(
+      () => checkLocalAlive(info.connectURL),
+      LOCAL_TIMEOUT_MS
+    );
+    return {
+      expected,
+      actual: "closed",
+      durationMs: result2.durationMs,
+      lastStatus: result2.lastStatus
+    };
+  }
+  if (!info.sessionId) {
+    throw new Error("Browserbase sessionId missing");
+  }
+  if (shouldStayOpen) {
+    const result2 = await assertStaysOpen(
+      () => checkBrowserbaseAlive(info.sessionId, apiKey),
+      STAY_OPEN_MS,
+      1e3
+    );
+    const outcome = {
+      expected,
+      actual: "open",
+      durationMs: result2.durationMs,
+      lastStatus: result2.lastStatus
+    };
+    await endBrowserbaseSession(info.sessionId, apiKey, projectId);
+    return outcome;
+  }
+  const result = await waitForClosed(
+    () => checkBrowserbaseAlive(info.sessionId, apiKey),
+    BB_TIMEOUT_MS,
+    1e3
+  );
+  return {
+    expected,
+    actual: "closed",
+    durationMs: result.durationMs,
+    lastStatus: result.lastStatus
+  };
+}
+function dumpLogs(logs) {
+  if (logs.stdout.length > 0) {
+    console.log("[keep-alive] child stdout:");
+    for (const line of logs.stdout) {
+      console.log(`  ${line}`);
+    }
+  }
+  if (logs.stderr.length > 0) {
+    console.log("[keep-alive] child stderr:");
+    for (const line of logs.stderr) {
+      console.log(`  ${line}`);
+    }
+  }
+}
+function logCaseResult(label, envLabel, keepAlive, outcome, error) {
+  const prefix = `[keep-alive] ${envLabel} keepAlive=${keepAlive} ${label}`;
+  if (error) {
+    console.log(`${prefix} FAIL: ${error.message}`);
+    return;
+  }
+  if (!outcome) {
+    console.log(`${prefix} FAIL: missing outcome`);
+    return;
+  }
+  const status = outcome.lastStatus !== void 0 ? ` (last status ${outcome.lastStatus})` : "";
+  if (outcome.actual === "open") {
+    console.log(
+      `${prefix} PASS: stayed open for ${outcome.durationMs}ms${status}`
+    );
+  } else {
+    console.log(
+      `${prefix} PASS: closed after ${outcome.durationMs}ms${status}`
+    );
+  }
+}
+function getKeepAliveEnvConfig() {
+  const testEnv = import_v3_dynamic_config.v3DynamicTestConfig.env;
+  const apiKey = testEnv === "BROWSERBASE" ? import_v3_dynamic_config.v3DynamicTestConfig.apiKey : void 0;
+  const projectId = testEnv === "BROWSERBASE" ? import_v3_dynamic_config.v3DynamicTestConfig.projectId : void 0;
+  const hasBrowserbaseCreds = Boolean(apiKey && projectId);
+  return { testEnv, apiKey, projectId, hasBrowserbaseCreds };
+}
+function buildKeepAliveCases(testEnv) {
+  const scenarios = [
+    { kind: "unhandled", label: "unhandled rejection" },
+    { kind: "close", label: "stagehand.close()" },
+    { kind: "sigterm", label: "SIGTERM" },
+    { kind: "sigint", label: "SIGINT" }
+  ];
+  const environments = testEnv === "BROWSERBASE" ? [
+    {
+      env: "BROWSERBASE",
+      label: "bb direct ws",
+      disableAPI: true,
+      requiresBrowserbase: true
+    },
+    {
+      env: "BROWSERBASE",
+      label: "bb via api",
+      disableAPI: false,
+      requiresBrowserbase: true
+    }
+  ] : [
+    {
+      env: "LOCAL",
+      label: "local",
+      disableAPI: false,
+      requiresBrowserbase: false
+    }
+  ];
+  const cases = [];
+  for (const keepAlive of [true, false]) {
+    for (const envConfig of environments) {
+      for (const scenario of scenarios) {
+        const expectation = keepAlive ? "expect open" : "expect closed";
+        cases.push({
+          title: `${envConfig.label} keepAlive=${keepAlive} ${scenario.label} (${expectation})`,
+          env: envConfig.env,
+          envLabel: envConfig.label,
+          keepAlive,
+          disableAPI: envConfig.disableAPI,
+          kind: scenario.kind,
+          requiresBrowserbase: envConfig.requiresBrowserbase
+        });
+      }
+    }
+  }
+  return cases;
+}
+async function runKeepAliveCase(testCase, envConfig) {
+  let info;
+  let child;
+  let logs;
+  try {
+    ({ info, child, logs } = await runScenario({
+      env: testCase.env,
+      keepAlive: testCase.keepAlive,
+      disableAPI: testCase.disableAPI,
+      kind: testCase.kind,
+      debug: DEBUG,
+      viewMs: VIEW_MS,
+      apiKey: envConfig.apiKey,
+      projectId: envConfig.projectId
+    }));
+  } catch (error) {
+    logCaseResult(
+      testCase.title,
+      testCase.envLabel,
+      testCase.keepAlive,
+      void 0,
+      error
+    );
+    throw error;
+  }
+  if (testCase.kind === "sigterm") {
+    child.kill("SIGTERM");
+  } else if (testCase.kind === "sigint") {
+    child.kill("SIGINT");
+  }
+  let outcome;
+  let failure;
+  try {
+    if (testCase.kind === "close" || testCase.kind === "unhandled" || testCase.kind === "sigterm" || testCase.kind === "sigint") {
+      await waitForChildExit(child, ACTION_EXIT_TIMEOUT_MS);
+    }
+    outcome = await assertBrowserState(
+      testCase.env,
+      info,
+      testCase.keepAlive,
+      envConfig.apiKey,
+      envConfig.projectId
+    );
+  } catch (error) {
+    failure = error;
+    if (logs) {
+      dumpLogs(logs);
+    }
+    throw error;
+  } finally {
+    logCaseResult(
+      testCase.title,
+      testCase.envLabel,
+      testCase.keepAlive,
+      outcome,
+      failure
+    );
+    await stopChild(child);
+    if (testCase.env === "LOCAL" && info.connectURL) {
+      await closeLocalBrowser(info.connectURL);
+    }
+    if (testCase.env === "BROWSERBASE" && info.sessionId) {
+      await endBrowserbaseSession(
+        info.sessionId,
+        envConfig.apiKey,
+        envConfig.projectId
+      );
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildKeepAliveCases,
+  getKeepAliveEnvConfig,
+  runKeepAliveCase
+});
+//# sourceMappingURL=keep-alive.helpers.js.map