fix(browser): retire stale CDP attachments

Author: MagMueller

packages/bcode-browser/skills/browser-execute/SKILL.md

@@ -106,7 +106,9 @@ const page = targets.find(t => t.type === "page" && !t.url.startsWith("chrome://
 await session.use(page.targetId)
 ```
 
-If a target-scoped command throws `CdpError` code `-32001` (`Session with given id not found`), the browser connection is still usable but the target session is stale. List targets again, `session.use(...)` the intended page, and retry the rejected command once. Repeated `session.connect()` calls do not replace a stale target session.
+If a target-scoped command throws `CdpError` code `-32001` (`Session with given id not found`), the browser connection is still usable but the target session is stale. List targets again, `session.use(...)` the intended page, and retry the rejected command once. Calling `session.connect()` without arguments is a no-op while connected; it does not replace a stale target session.
+
+Every explicit reconnect or browser switch retires the previous socket and clears its active target attachment. Re-list targets, call `session.use(...)`, and rediscover DOM nodes and Runtime objects before continuing.
 
 ## Driving a page
 Domain methods follow `session.<Domain>.<method>(params)` and return Promises. 

packages/bcode-browser/src/cdp/session.ts

@@ -123,6 +123,14 @@ export class Session implements Transport {
     if (this.invalidatedError) return Promise.reject(this.invalidatedError);
     return new Promise<void>((res, rej) => {
       const ws = new WebSocket(wsUrl);
+      const previousWs = this.ws;
+      this.ws = ws;
+      this.activeSessionId = undefined;
+      if (previousWs) {
+        for (const [, p] of this.pending) p.reject(new Error('CDP connection replaced'));
+        this.pending.clear();
+        try { previousWs.close(); } catch { /* ignore */ }
+      }
       let done = false;
       const finish = (err?: Error) => {
         if (done) return;
@@ -132,15 +140,28 @@ export class Session implements Transport {
         else res();
       };
       const timer = setTimeout(() => finish(new Error(`timed out after ${timeoutMs}ms`)), timeoutMs);
-      ws.addEventListener('open', () => finish(this.invalidatedError));
+      ws.addEventListener('open', () => {
+        if (this.ws !== ws) {
+          finish(new Error('CDP connection superseded'));
+          return;
+        }
+        finish(this.invalidatedError);
+      });
       ws.addEventListener('error', (e) => finish(new Error(`WS error: ${(e as any)?.message ?? 'connect failed (likely 403, permission not granted, or port closed)'}`)));
-      ws.addEventListener('message', (e) => this.onMessage(String(e.data)));
+      ws.addEventListener('message', (e) => {
+        if (this.ws === ws) this.onMessage(String(e.data));
+      });
       ws.addEventListener('close', () => {
+        if (this.ws !== ws) {
+          finish(new Error('CDP connection superseded'));
+          return;
+        }
+        this.ws = undefined;
+        this.activeSessionId = undefined;
         for (const [, p] of this.pending) p.reject(this.invalidatedError ?? new Error('CDP socket closed'));
         this.pending.clear();
         finish(this.invalidatedError ?? new Error('WS closed before open (likely 403 or port closed)'));
       });
-      this.ws = ws;
     });
   }
 

packages/bcode-browser/test/browser-auto-connect.test.ts

@@ -7,6 +7,7 @@ import { BrowserExecute } from "../src/browser-execute";
 import { SessionStore } from "../src/session-store";
 
 let connections = 0;
+let closedConnections = 0;
 let attachedCalls = 0;
 let pageCallsWithSession = 0;
 let latestSocket: { close(): void } | undefined;
@@ -57,7 +58,9 @@ const server = Bun.serve({
       })();
       ws.send(JSON.stringify({ id: request.id, result }));
     },
-    close() {},
+    close() {
+      closedConnections++;
+    },
   },
 });
 
@@ -198,6 +201,7 @@ test("parallel first calls share one connection attempt", async () => {
 
 test("a dropped socket is surfaced instead of reconnecting the run-start browser", async () => {
   connections = 0;
+  closedConnections = 0;
   attachedCalls = 0;
   await withEnv(
     { V4_RUN_ID: "run-dropped", BU_CDP_WS: wsUrl, BU_CDP_URL: undefined },
@@ -222,11 +226,56 @@ test("a dropped socket is surfaced instead of reconnecting the run-start browser
         );
 
         expect(connections).toBe(1);
+        expect(closedConnections).toBe(1);
         expect(attachedCalls).toBe(1);
       }),
   );
 });
 
+test("an explicit browser switch retires the old socket and target attachment", async () => {
+  connections = 0;
+  closedConnections = 0;
+  attachedCalls = 0;
+  pageCallsWithSession = 0;
+  await withEnv(
+    { V4_RUN_ID: "run-switch", BU_CDP_WS: wsUrl, BU_CDP_URL: undefined },
+    () =>
+      withBrowserExecute("switch", async (impl, sessionID, workspaceDir) => {
+        const run = (code: string) =>
+          Effect.runPromise(
+            impl.execute(
+              { description: "Switch provisioned browsers", code },
+              { sessionID, workspaceDir },
+            ),
+          );
+
+        await run(
+          "return await session.Page.navigate({ url: 'https://sap.com' })",
+        );
+        const switched = await run(`
+          await session.connect({ wsUrl: ${JSON.stringify(wsUrl)} })
+          await session.Page.navigate({ url: "https://example.com" })
+          return { activeSession: session.getActiveSession() ?? null }
+        `);
+        expect(JSON.parse(switched.result)).toEqual({ activeSession: null });
+
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(connections).toBe(2);
+        expect(closedConnections).toBe(1);
+        expect(attachedCalls).toBe(1);
+        expect(pageCallsWithSession).toBe(1);
+
+        await run(`
+          const page = (await session.Target.getTargets({})).targetInfos[0]
+          await session.use(page.targetId)
+          return await session.Page.navigate({ url: "https://example.com" })
+        `);
+        expect(attachedCalls).toBe(2);
+        expect(pageCallsWithSession).toBe(2);
+      }),
+  );
+});
+
 test("a timeout replacement does not auto-attach the run-start browser again", async () => {
   connections = 0;
   await withEnv(