STG-1669: fix(cli): clear cached state when browser connection dies (#1887)

## Summary
- When the browse CLI daemon outlives its Chrome browser (e.g., between
Claude Code sessions), `ensureBrowserInitialized()` returns the cached
`stagehand`/`context` without checking if the browser is still alive
- This causes `"No Page found for awaitActivePage: no page available"`
errors requiring a manual `browse stop` + retry
- Fix: register an `onTransportClosed` handler on the CDP connection
that clears the cached state, so the next command triggers a full
re-initialization

## Root cause
The daemon is spawned as a detached process (`detached: true`,
`child.unref()`) and persists across CLI sessions. When Chrome dies,
`_onCdpClosed` fires and calls `stagehand.close()`, but the daemon's
closure variables `stagehand` and `context` are never cleared. The next
command hits the early return at `if (stagehand && context) { return ...
}` and tries to use dead objects.

## Test plan

**Regression test added to PR is illustrative** 

- [x] Start a `browse` session, close Chrome manually, run another
`browse open` — should auto-recover instead of erroring
- [x] Normal `browse` workflow (open, snapshot, click, stop) still works
- [x] Daemon restart across mode switches (local ↔ remote) still works
- [x] Regression test added: kills Chrome under daemon, verifies
auto-recovery (fails on main, passes with fix)

## Verified test results

**On `main` (without fix):** Test fails — after killing Chrome, the
retry returns exit code 1 with `"Error: No Page found for
awaitActivePage: no page available"`. The daemon is alive but returns
stale cached Stagehand/context objects.

**On this branch (with fix):** Test passes — after killing Chrome, the
`onTransportClosed` handler nulls the cached state, and the retry
triggers a full browser re-initialization. All 37 CLI tests pass (full
suite, 67s).

> **Note:** When building locally, use `npx tsup src/index.ts --format
cjs --out-dir dist --no-splitting` inside `packages/cli/` rather than
`pnpm run build:cli`, since turbo may serve a stale cached build that
doesn't include the fix.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: shrey150

.changeset/fix-stale-daemon.md

@@ -0,0 +1,5 @@
+---
+"@browserbasehq/browse-cli": patch
+---
+
+fix: clear cached browser state when CDP connection dies, preventing "awaitActivePage: no page available" errors when daemon outlives its browser

packages/cli/src/index.ts

@@ -372,6 +372,15 @@ async function runDaemon(session: string, headless: boolean): Promise<void> {
 
       context = stagehand.context;
 
+      // Clear cached state when the browser connection dies so the next
+      // command triggers a full re-initialization instead of reusing a
+      // dead Stagehand/context pair (fixes "awaitActivePage: no page
+      // available" when a stale daemon outlives its browser).
+      context.conn.onTransportClosed(() => {
+        stagehand = null;
+        context = null;
+      });
+
       // Try to save Chrome info for reference (best effort)
       try {
         const wsUrl = stagehand.connectURL();

packages/cli/tests/cli.test.ts

@@ -572,4 +572,74 @@ describe("Browse CLI", () => {
       expect(result.exitCode).not.toBe(0);
     });
   });
+
+  describe("Stale daemon recovery", () => {
+    const staleSession = `${TEST_SESSION}-stale`;
+
+    afterEach(async () => {
+      await browse("stop --force", { session: staleSession });
+      await cleanupSession(staleSession);
+    });
+
+    it("should recover when Chrome dies under a running daemon", async () => {
+      // Force local mode (Browserbase env vars may be set)
+      const tmpDir = os.tmpdir();
+      await fs.writeFile(
+        path.join(tmpDir, `browse-${staleSession}.mode-override`),
+        "local",
+      );
+
+      // 1. Start daemon and initialize browser by opening a page
+      const openResult = await browse("open https://example.com", {
+        session: staleSession,
+        timeout: 30000,
+      });
+      expect(openResult.exitCode).toBe(0);
+      const openData = parseJson(openResult.stdout);
+      expect(openData.url).toContain("example.com");
+
+      // 2. Kill the Chrome process tree owned by THIS session's daemon.
+      //    Read the daemon PID, then find its child processes to avoid
+      //    killing Chrome instances from other concurrent sessions.
+      const daemonPid = (
+        await fs.readFile(
+          path.join(tmpDir, `browse-${staleSession}.pid`),
+          "utf-8",
+        )
+      ).trim();
+
+      const { stdout: psOut } = await new Promise<{
+        stdout: string;
+        stderr: string;
+      }>((resolve) => {
+        exec(`pgrep -P ${daemonPid}`, (_, stdout, stderr) =>
+          resolve({ stdout: stdout?.trim() ?? "", stderr: stderr ?? "" }),
+        );
+      });
+
+      const childPids = psOut.split("\n").filter(Boolean);
+      expect(childPids.length).toBeGreaterThan(0);
+
+      // Kill the daemon's child processes (Chrome)
+      for (const pid of childPids) {
+        try {
+          process.kill(parseInt(pid), "SIGKILL");
+        } catch {}
+      }
+
+      // 3. Wait for the WebSocket close to propagate to the daemon
+      await new Promise((r) => setTimeout(r, 3000));
+
+      // 4. Daemon is still running (socket alive), but browser is dead.
+      //    Without the fix, this would fail with:
+      //    "No Page found for awaitActivePage: no page available"
+      const retryResult = await browse("open https://example.com", {
+        session: staleSession,
+        timeout: 30000,
+      });
+      expect(retryResult.exitCode).toBe(0);
+      const retryData = parseJson(retryResult.stdout);
+      expect(retryData.url).toContain("example.com");
+    }, 60000);
+  });
 });