@browserbasehq/browse-cli 0.3.0-alpha-e81dde715786d70e65524c8b7ce10e00a909efd9 → 0.4.0

package/README.md

@@ -173,11 +173,47 @@ browse env
 # Switch current session to Browserbase (restarts daemon if needed)
 browse env remote
 
-# Switch back to local Chrome
+# Switch back to local Chrome (auto-discovers existing Chrome, falls back to isolated)
 browse env local
 ```
 
-Behavior details:
+#### Local Browser Strategies
+
+By default, `browse env local` auto-discovers an already-running Chrome with remote
+debugging enabled. This lets agents use your existing cookies, logins, and browser state.
+If no debuggable Chrome is found, it falls back to launching an isolated browser.
+
+```bash
+# Auto-discover local Chrome, fallback to isolated (default)
+browse env local
+
+# Force a clean isolated browser (no auto-discovery)
+browse env local --isolated
+
+# Attach to a specific CDP target (port or URL)
+browse env local 9222
+browse env local ws://localhost:9222/devtools/browser/...
+```
+
+Auto-discovery checks:
+1. `DevToolsActivePort` files in well-known Chrome/Chromium/Brave user-data directories
+2. Common debugging ports (9222, 9229)
+
+To make your Chrome discoverable:
+
+1. Open `chrome://inspect/#remote-debugging`
+2. Check the box **"Allow remote debugging for this browser instance"**
+
+For more information, see the [Chrome DevTools docs](https://developer.chrome.com/blog/chrome-devtools-mcp-debug-your-browser-session).
+
+Use `browse status` to see which strategy was resolved:
+
+```bash
+browse status
+# {"running":true,"session":"default","mode":"local","localStrategy":"auto","localSource":"attached-existing","resolvedCdpUrl":"ws://..."}
+```
+
+#### General Behavior
 
 - Environment is scoped per `--session`
 - `browse env <target>` persists an override and restarts the daemon
@@ -193,7 +229,7 @@ Behavior details:
 | `--session <name>` | Session name for multiple browsers (default: "default") |
 | `--headless` | Run Chrome in headless mode |
 | `--headed` | Run Chrome with visible window (default) |
-| `--ws <url>` | Connect to existing Chrome via CDP WebSocket |
+| `--ws <url\|port>` | One-shot CDP connection (bypasses daemon) |
 | `--json` | Output as JSON |
 
 ## Environment Variables
@@ -249,11 +285,21 @@ browse --session personal open https://twitter.com
 
 Connect to an existing Chrome instance:
 
+To make your Chrome discoverable:
+
+1. Open `chrome://inspect/#remote-debugging`
+2. Check the box **"Allow remote debugging for this browser instance"**
+3. Re-run the CLI and it will auto-connect!
+
+For more information, see the [Chrome DevTools docs](https://developer.chrome.com/blog/chrome-devtools-mcp-debug-your-browser-session).
+
 ```bash
-# Start Chrome with remote debugging
-google-chrome --remote-debugging-port=9222
+# Auto-discover Chrome with remote debugging enabled
+browse env local
+browse open https://example.com
 
-# Connect via WebSocket
+# Or target a specific port / WebSocket URL
+browse env local 9222
 browse --ws ws://localhost:9222/devtools/browser/... open https://example.com
 ```
 

package/dist/index.js

@@ -34,9 +34,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// ../../node_modules/.pnpm/tsup@8.5.1_jiti@1.21.7_postcss@8.5.6_tsx@4.19.4_typescript@5.8.3_yaml@2.7.1/node_modules/tsup/assets/cjs_shims.js
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.19.4_typescript@5.8.3_yaml@2.8.3/node_modules/tsup/assets/cjs_shims.js
 var init_cjs_shims = __esm({
-  "../../node_modules/.pnpm/tsup@8.5.1_jiti@1.21.7_postcss@8.5.6_tsx@4.19.4_typescript@5.8.3_yaml@2.7.1/node_modules/tsup/assets/cjs_shims.js"() {
+  "../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.19.4_typescript@5.8.3_yaml@2.8.3/node_modules/tsup/assets/cjs_shims.js"() {
     "use strict";
   }
 });
@@ -94180,7 +94180,7 @@ var init_page2 = __esm({
           });
           try {
             if (this.apiClient) {
-              const result = await this.apiClient.goto(url2, { waitUntil: options?.waitUntil }, this.mainFrameId());
+              const result = await this.apiClient.goto(url2, { waitUntil: options?.waitUntil, timeout: options?.timeoutMs }, this.mainFrameId());
               this._currentUrl = url2;
               if (isSerializableResponse(result)) {
                 return Response2.fromSerializable(result, {
@@ -114574,7 +114574,7 @@ var OpenAICUAClient = class extends AgentClient {
     const messageList = [];
     let finalMessage = "";
     this.reasoningItems.clear();
-    let inputItems = this.createInitialInputItems(instruction);
+    let inputItems = await this.createInitialInputItems(instruction);
     let previousResponseId = void 0;
     let totalInputTokens = 0;
     let totalOutputTokens = 0;
@@ -114781,17 +114781,37 @@ var OpenAICUAClient = class extends AgentClient {
   isFunctionCallItem(item) {
     return item.type === "function_call" && "call_id" in item && "name" in item && "arguments" in item;
   }
-  createInitialInputItems(instruction) {
-    return [
-      {
+  async createInitialInputItems(instruction) {
+    const inputItems = [];
+    if (this.userProvidedInstructions) {
+      const systemMessage = {
         role: "system",
         content: this.userProvidedInstructions
-      },
-      {
-        role: "user",
-        content: instruction
-      }
+      };
+      inputItems.push(systemMessage);
+    }
+    const textInput = {
+      type: "input_text",
+      text: instruction
+    };
+    const userContent = [
+      textInput
     ];
+    const initialScreenshot = await this.captureInitialScreenshot();
+    if (initialScreenshot) {
+      const screenshotInput = {
+        type: "input_image",
+        image_url: initialScreenshot,
+        detail: "high"
+      };
+      userContent.push(screenshotInput);
+    }
+    const userMessage = {
+      role: "user",
+      content: userContent
+    };
+    inputItems.push(userMessage);
+    return inputItems;
   }
   async getAction(inputItems, previousResponseId) {
     try {
@@ -115050,6 +115070,16 @@ var OpenAICUAClient = class extends AgentClient {
     this.pendingContextNotes = [];
     return notes;
   }
+  async captureInitialScreenshot() {
+    if (!this.screenshotProvider) {
+      return void 0;
+    }
+    try {
+      return await this.captureScreenshot();
+    } catch {
+      return void 0;
+    }
+  }
   convertFunctionCallToAction(call) {
     try {
       const args = JSON.parse(call.arguments);
@@ -164590,7 +164620,29 @@ var import_child_process4 = require("child_process");
 var readline = __toESM(require("readline"));
 
 // package.json
-var version3 = "0.3.0-alpha-e81dde715786d70e65524c8b7ce10e00a909efd9";
+var version3 = "0.4.0";
+
+// src/resolve-ws.ts
+init_cjs_shims();
+async function resolveWsTarget(input) {
+  if (/^\d+$/.test(input)) {
+    const port = input;
+    const url2 = `http://127.0.0.1:${port}/json/version`;
+    try {
+      const res = await fetch(url2);
+      if (!res.ok) {
+        throw new Error(`HTTP ${res.status} from ${url2}`);
+      }
+      const json2 = await res.json();
+      if (json2.webSocketDebuggerUrl) {
+        return json2.webSocketDebuggerUrl;
+      }
+    } catch {
+    }
+    return `ws://127.0.0.1:${port}/devtools/browser`;
+  }
+  return input;
+}
 
 // src/index.ts
 var program = new import_commander.Command();
@@ -164687,6 +164739,34 @@ function getContextPath(session) {
 function getConnectPath(session) {
   return path11.join(SOCKET_DIR, `browse-${session}.connect`);
 }
+function getLocalConfigPath(session) {
+  return path11.join(SOCKET_DIR, `browse-${session}.local-config`);
+}
+function getLocalInfoPath(session) {
+  return path11.join(SOCKET_DIR, `browse-${session}.local-info`);
+}
+async function readLocalConfig(session) {
+  try {
+    const raw = await import_fs11.promises.readFile(getLocalConfigPath(session), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { strategy: "auto" };
+  }
+}
+async function writeLocalConfig(session, config3) {
+  await import_fs11.promises.writeFile(getLocalConfigPath(session), JSON.stringify(config3));
+}
+async function writeLocalInfo(session, info) {
+  await import_fs11.promises.writeFile(getLocalInfoPath(session), JSON.stringify(info));
+}
+async function readLocalInfo(session) {
+  try {
+    const raw = await import_fs11.promises.readFile(getLocalInfoPath(session), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
 function hasBrowserbaseCredentials() {
   return Boolean(process.env.BROWSERBASE_API_KEY);
 }
@@ -164718,6 +164798,165 @@ async function getDesiredMode(session) {
   }
   return hasBrowserbaseCredentials() ? "browserbase" : "local";
 }
+function getChromeUserDataDirs() {
+  const home = os3.homedir();
+  const dirs = [];
+  if (process.platform === "darwin") {
+    const base = path11.join(home, "Library", "Application Support");
+    for (const name18 of [
+      "Google/Chrome",
+      "Google/Chrome Canary",
+      "Chromium",
+      "BraveSoftware/Brave-Browser"
+    ]) {
+      dirs.push(path11.join(base, name18));
+    }
+  } else if (process.platform === "linux") {
+    const config3 = path11.join(home, ".config");
+    for (const name18 of [
+      "google-chrome",
+      "google-chrome-unstable",
+      "chromium",
+      "BraveSoftware/Brave-Browser"
+    ]) {
+      dirs.push(path11.join(config3, name18));
+    }
+  }
+  return dirs;
+}
+async function readDevToolsActivePort(userDataDir) {
+  try {
+    const content = await import_fs11.promises.readFile(
+      path11.join(userDataDir, "DevToolsActivePort"),
+      "utf-8"
+    );
+    const lines = content.trim().split("\n");
+    const port = parseInt(lines[0]?.trim(), 10);
+    if (isNaN(port) || port <= 0 || port > 65535) return null;
+    const wsPath = lines[1]?.trim() || "/devtools/browser";
+    return { port, wsPath };
+  } catch {
+    return null;
+  }
+}
+function isPortReachable(port, timeoutMs = 500) {
+  return new Promise((resolve4) => {
+    const sock = net2.createConnection({ host: "127.0.0.1", port });
+    const timer = setTimeout(() => {
+      sock.destroy();
+      resolve4(false);
+    }, timeoutMs);
+    sock.on("connect", () => {
+      clearTimeout(timer);
+      sock.destroy();
+      resolve4(true);
+    });
+    sock.on("error", () => {
+      clearTimeout(timer);
+      resolve4(false);
+    });
+  });
+}
+async function probeCdpEndpoint(port) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 2e3);
+    const res = await fetch(`http://127.0.0.1:${port}/json/version`, {
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    if (res.ok) {
+      const json2 = await res.json();
+      if (json2.webSocketDebuggerUrl) {
+        return json2.webSocketDebuggerUrl;
+      }
+    }
+  } catch {
+  }
+  const wsUrl = `ws://127.0.0.1:${port}/devtools/browser`;
+  try {
+    const verified = await verifyCdpWebSocket(wsUrl);
+    if (verified) return wsUrl;
+  } catch {
+  }
+  return null;
+}
+function verifyCdpWebSocket(wsUrl) {
+  return new Promise((resolve4) => {
+    const url2 = new URL(wsUrl);
+    const port = parseInt(url2.port) || 80;
+    const wsKey = Buffer.from(
+      Array.from({ length: 16 }, () => Math.floor(Math.random() * 256))
+    ).toString("base64");
+    const sock = net2.createConnection({ host: url2.hostname, port });
+    let response = "";
+    const timer = setTimeout(() => {
+      sock.destroy();
+      resolve4(false);
+    }, 2e3);
+    sock.on("connect", () => {
+      sock.write(
+        `GET ${url2.pathname} HTTP/1.1\r
+Host: ${url2.hostname}:${port}\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Key: ${wsKey}\r
+Sec-WebSocket-Version: 13\r
+\r
+`
+      );
+    });
+    sock.on("data", (data) => {
+      response += data.toString();
+      if (/^HTTP\/1\.[01] 101(?:\s|$)/.test(response)) {
+        clearTimeout(timer);
+        sock.destroy();
+        resolve4(true);
+      } else if (response.includes("\r\n\r\n")) {
+        clearTimeout(timer);
+        sock.destroy();
+        resolve4(false);
+      }
+    });
+    sock.on("error", () => {
+      clearTimeout(timer);
+      resolve4(false);
+    });
+  });
+}
+async function discoverLocalCdp() {
+  const candidates = [];
+  const userDataDirs = getChromeUserDataDirs();
+  for (const dir of userDataDirs) {
+    const info = await readDevToolsActivePort(dir);
+    if (!info) continue;
+    if (!await isPortReachable(info.port)) {
+      try {
+        await import_fs11.promises.unlink(path11.join(dir, "DevToolsActivePort"));
+      } catch {
+      }
+      continue;
+    }
+    const wsUrl = await probeCdpEndpoint(info.port);
+    if (wsUrl) {
+      const name18 = path11.basename(dir);
+      candidates.push({ wsUrl, source: `DevToolsActivePort (${name18})` });
+    }
+  }
+  if (candidates.length === 0) {
+    for (const port of [9222, 9229]) {
+      if (!await isPortReachable(port)) continue;
+      const wsUrl = await probeCdpEndpoint(port);
+      if (wsUrl) {
+        candidates.push({ wsUrl, source: `port ${port}` });
+      }
+    }
+  }
+  if (candidates.length > 1) {
+    return null;
+  }
+  return candidates[0] ?? null;
+}
 async function isDaemonRunning(session) {
   try {
     const pidFile = getPidPath(session);
@@ -164736,14 +164975,16 @@ var DAEMON_STATE_FILES = (session) => [
   getWsPath(session),
   getChromePidPath(session),
   getLockPath(session),
-  getModePath(session)
+  getModePath(session),
+  getLocalInfoPath(session)
 ];
 async function cleanupStaleFiles(session) {
   const files = [
     ...DAEMON_STATE_FILES(session),
     // Client-written config, only cleaned on full shutdown
     getContextPath(session),
-    getConnectPath(session)
+    getConnectPath(session),
+    getLocalConfigPath(session)
   ];
   for (const file2 of files) {
     try {
@@ -164820,6 +165061,37 @@ async function runDaemon(session, headless) {
         connectSessionId = (await import_fs11.promises.readFile(getConnectPath(session), "utf-8")).trim();
       } catch {
       }
+      let localLaunchOptions;
+      let localInfo;
+      if (!useBrowserbase) {
+        const localConfig = await readLocalConfig(session);
+        if (localConfig.strategy === "isolated") {
+          localLaunchOptions = { headless, viewport: DEFAULT_VIEWPORT2 };
+          localInfo = { localSource: "isolated" };
+        } else if (localConfig.strategy === "cdp") {
+          const cdpUrl = await resolveWsTarget(localConfig.cdpTarget);
+          localLaunchOptions = { cdpUrl };
+          localInfo = {
+            localSource: "attached-explicit",
+            resolvedCdpUrl: cdpUrl
+          };
+        } else {
+          const discovered = await discoverLocalCdp();
+          if (discovered) {
+            localLaunchOptions = { cdpUrl: discovered.wsUrl };
+            localInfo = {
+              localSource: "attached-existing",
+              resolvedCdpUrl: discovered.wsUrl
+            };
+          } else {
+            localLaunchOptions = { headless, viewport: DEFAULT_VIEWPORT2 };
+            localInfo = {
+              localSource: "isolated-fallback",
+              fallbackReason: "no debuggable local browser found"
+            };
+          }
+        }
+      }
       stagehand = new V3({
         env: useBrowserbase ? "BROWSERBASE" : "LOCAL",
         verbose: 0,
@@ -164841,13 +165113,13 @@ async function runDaemon(session, headless) {
             }
           } : {}
         } : {
-          localBrowserLaunchOptions: {
-            headless,
-            viewport: DEFAULT_VIEWPORT2
-          }
+          localBrowserLaunchOptions: localLaunchOptions
         }
       });
       await import_fs11.promises.writeFile(getModePath(session), desiredMode);
+      if (localInfo) {
+        await writeLocalInfo(session, localInfo);
+      }
       await stagehand.init();
       context = stagehand.context;
       context.conn.onTransportClosed(() => {
@@ -164905,7 +165177,7 @@ async function runDaemon(session, headless) {
       }
     } catch {
     }
-    await cleanupStaleFiles(session);
+    await cleanupDaemonStateFiles(session);
     process.exit(0);
   };
   process.on("SIGTERM", () => shutdown());
@@ -165572,7 +165844,7 @@ async function stopDaemonAndCleanup(session) {
   } catch {
   }
   await new Promise((r3) => setTimeout(r3, 500));
-  await cleanupStaleFiles(session);
+  await cleanupDaemonStateFiles(session);
 }
 async function ensureDaemon(session, headless) {
   const wantMode = await getDesiredMode(session);
@@ -165659,12 +165931,13 @@ async function runCommand(command, args) {
   const session = getSession(opts);
   const headless = isHeadless(opts);
   if (opts.ws) {
+    const cdpUrl = await resolveWsTarget(opts.ws);
     const stagehand = new V3({
       env: "LOCAL",
       verbose: 0,
       disablePino: true,
       localBrowserLaunchOptions: {
-        cdpUrl: opts.ws
+        cdpUrl
       }
     });
     await stagehand.init();
@@ -165702,8 +165975,8 @@ async function runCommand(command, args) {
   return sendCommand(session, command, args, headless);
 }
 program.name("browse").description("Browser automation CLI for AI agents").version(version3).option(
-  "--ws <url>",
-  "CDP WebSocket URL (bypasses daemon, direct connection)"
+  "--ws <url|port>",
+  "CDP WebSocket URL or port number (bypasses daemon, direct connection)"
 ).option("--headless", "Run Chrome in headless mode").option("--headed", "Run Chrome with visible window (default)").option("--json", "Output as JSON", false).option(
   "--session <name>",
   "Session name for multiple browsers (or use BROWSE_SESSION env var)"
@@ -165748,6 +166021,7 @@ program.command("status").description("Check daemon status").action(async () =>
   let wsUrl = null;
   let mode = null;
   let browserbaseSessionId = null;
+  let localDetails = {};
   if (running) {
     try {
       wsUrl = await import_fs11.promises.readFile(getWsPath(session), "utf-8");
@@ -165758,68 +166032,106 @@ program.command("status").description("Check daemon status").action(async () =>
       browserbaseSessionId = (await import_fs11.promises.readFile(getConnectPath(session), "utf-8")).trim();
     } catch {
     }
+    if (mode === "local") {
+      const localConfig = await readLocalConfig(session);
+      const localInfo = await readLocalInfo(session);
+      localDetails = {
+        localStrategy: localConfig.strategy,
+        ...localInfo ?? {}
+      };
+    }
   }
   console.log(
-    JSON.stringify({ running, session, wsUrl, mode, browserbaseSessionId })
+    JSON.stringify({
+      running,
+      session,
+      wsUrl,
+      mode,
+      browserbaseSessionId,
+      ...localDetails
+    })
   );
 });
-program.command("env [target]").description("Show or switch browser environment (local | remote)").action(async (target) => {
-  const opts = program.opts();
-  const session = getSession(opts);
-  if (!target) {
-    let mode = null;
-    const desiredMode = await getDesiredMode(session);
-    if (await isDaemonRunning(session)) {
-      mode = toModeTarget(await readCurrentMode(session) ?? desiredMode);
-    }
-    console.log(
-      JSON.stringify({
-        mode: mode ?? "not running",
-        desired: toModeTarget(desiredMode),
-        session
-      })
-    );
-    return;
-  }
-  const modeMap = {
-    local: "local",
-    remote: "browserbase"
-  };
-  const mapped = modeMap[target];
-  if (!mapped) {
-    console.error("Usage: browse env [local|remote]");
-    process.exit(1);
-  }
-  try {
-    assertModeSupported(mapped);
-  } catch (err) {
-    console.error(err instanceof Error ? err.message : String(err));
-    process.exit(1);
-  }
-  await import_fs11.promises.writeFile(getModeOverridePath(session), mapped);
-  if (await isDaemonRunning(session)) {
-    const currentMode = await readCurrentMode(session) ?? "local";
-    if (currentMode === mapped) {
+program.command("env [target] [cdpTarget]").description(
+  "Show or switch browser environment (local | remote)\n\n  browse env              Show current environment\n  browse env local        Auto-discover local Chrome, fallback to isolated\n  browse env local --isolated  Force clean isolated browser\n  browse env local <port|url>  Attach to specific CDP target\n  browse env remote       Use Browserbase (requires API key)"
+).option("--isolated", "Force isolated local browser (no auto-discovery)").action(
+  async (target, cdpTarget, cmdOpts) => {
+    const opts = program.opts();
+    const session = getSession(opts);
+    if (!target) {
+      let mode = null;
+      const desiredMode = await getDesiredMode(session);
+      const localConfig2 = await readLocalConfig(session);
+      const localInfo = await readLocalInfo(session);
+      if (await isDaemonRunning(session)) {
+        mode = toModeTarget(await readCurrentMode(session) ?? desiredMode);
+      }
       console.log(
         JSON.stringify({
-          mode: toModeTarget(mapped),
+          mode: mode ?? "not running",
+          desired: toModeTarget(desiredMode),
           session,
-          restarted: false
+          ...desiredMode === "local" ? {
+            localStrategy: localConfig2.strategy,
+            ...localInfo ?? {}
+          } : {}
         })
       );
       return;
     }
-    await stopDaemonAndCleanup(session);
+    const modeMap = {
+      local: "local",
+      remote: "browserbase"
+    };
+    const mapped = modeMap[target];
+    if (!mapped) {
+      console.error(
+        "Usage: browse env [local|remote]\n  browse env local [--isolated] [<port|url>]"
+      );
+      process.exit(1);
+    }
+    try {
+      assertModeSupported(mapped);
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+    let localConfig = { strategy: "auto" };
+    if (mapped === "local") {
+      if (cmdOpts.isolated) {
+        localConfig = { strategy: "isolated" };
+      } else if (cdpTarget) {
+        localConfig = { strategy: "cdp", cdpTarget };
+      }
+      await writeLocalConfig(session, localConfig);
+    }
+    await import_fs11.promises.writeFile(getModeOverridePath(session), mapped);
+    if (await isDaemonRunning(session)) {
+      const currentMode = await readCurrentMode(session) ?? "local";
+      const needsRestart = currentMode !== mapped || mapped === "local";
+      if (!needsRestart) {
+        console.log(
+          JSON.stringify({
+            mode: toModeTarget(mapped),
+            session,
+            restarted: false
+          })
+        );
+        return;
+      }
+      await stopDaemonAndCleanup(session);
+    }
+    await ensureDaemon(session, isHeadless(opts));
+    console.log(
+      JSON.stringify({
+        mode: toModeTarget(mapped),
+        session,
+        restarted: true,
+        ...mapped === "local" ? { localStrategy: localConfig.strategy } : {}
+      })
+    );
   }
-  await ensureDaemon(session, isHeadless(opts));
-  console.log(
-    JSON.stringify({
-      mode: toModeTarget(mapped),
-      session,
-      restarted: true
-    })
-  );
-});
+);
 program.command("refs").description("Show cached ref map from last snapshot").action(async () => {
   const opts = program.opts();
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browserbasehq/browse-cli",
-  "version": "0.3.0-alpha-e81dde715786d70e65524c8b7ce10e00a909efd9",
+  "version": "0.4.0",
   "description": "Browser automation CLI for AI agents, built on Stagehand",
   "type": "commonjs",
   "license": "MIT",
@@ -47,7 +47,7 @@
     "pino": "^9.6.0",
     "pino-pretty": "^13.0.0",
     "ws": "^8.18.0",
-    "@browserbasehq/stagehand": "3.2.1-alpha-e81dde715786d70e65524c8b7ce10e00a909efd9"
+    "@browserbasehq/stagehand": "3.2.1-alpha-be6798aefdf44d2d2d275a4b9cf3d4473609515b"
   },
   "devDependencies": {
     "@types/node": "^20.11.30",