fix(browser): reattach the intended page

Author: MagMueller

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

@@ -47,6 +47,7 @@ export class Session implements Transport {
   private nextId = 1;
   private pending = new Map<number, Pending>();
   private activeSessionId: string | undefined;
+  private activeTargetId: string | undefined;
   private reattachPromise?: Promise<void>;
   private enabledDomains = new Map<string, Map<string, unknown>>();
   private eventListeners: Array<(method: string, params: unknown, sessionId?: string) => void> = [];
@@ -135,6 +136,7 @@ export class Session implements Transport {
         const previous = this.ws;
         this.ws = ws;
         this.activeSessionId = undefined;
+        this.activeTargetId = undefined;
         this.enabledDomains.clear();
         finish();
         if (previous && previous !== ws) {
@@ -148,6 +150,7 @@ export class Session implements Transport {
         if (this.ws === ws) {
           this.ws = undefined;
           this.activeSessionId = undefined;
+          this.activeTargetId = undefined;
           this.enabledDomains.clear();
         }
         finish(new Error('WS closed before open (likely 403 or port closed)'));
@@ -170,12 +173,14 @@ export class Session implements Transport {
   async use(targetId: string): Promise<string> {
     const r = await this._call('Target.attachToTarget', { targetId, flatten: true }) as { sessionId: string };
     this.activeSessionId = r.sessionId;
+    this.activeTargetId = targetId;
     return r.sessionId;
   }
 
   /** Set the active sessionId directly (e.g. one you already attached). */
   setActiveSession(sessionId: string | undefined): void {
     this.activeSessionId = sessionId;
+    this.activeTargetId = undefined;
   }
 
   getActiveSession(): string | undefined {
@@ -228,6 +233,7 @@ export class Session implements Transport {
   async _call(method: string, params: unknown = {}): Promise<unknown> {
     const browserLevel = isBrowserLevel(method);
     const sentSessionId = browserLevel ? undefined : this.activeSessionId;
+    const sentTargetId = browserLevel ? undefined : this.activeTargetId;
     try {
       return await this.send(method, params, sentSessionId);
     } catch (error) {
@@ -236,7 +242,9 @@ export class Session implements Transport {
       // Chrome explicitly rejected the command before executing it, so this is
       // safe to retry once. Socket drops are deliberately not retried: Chrome
       // may have applied a click or submission before the response was lost.
-      if (this.activeSessionId === sentSessionId) await this.reattachFirstPage(sentSessionId);
+      if (this.activeSessionId === sentSessionId) {
+        await this.reattachPage(sentSessionId, sentTargetId);
+      }
       else if (this.reattachPromise) await this.reattachPromise;
       if (!this.activeSessionId || this.activeSessionId === sentSessionId) throw error;
       return this.send(method, params, this.activeSessionId);
@@ -273,10 +281,10 @@ export class Session implements Transport {
     });
   }
 
-  private async reattachFirstPage(staleSessionId: string): Promise<void> {
+  private async reattachPage(staleSessionId: string, staleTargetId?: string): Promise<void> {
     if (this.reattachPromise) return this.reattachPromise;
 
-    const attempt = this.attachFirstPage(staleSessionId);
+    const attempt = this.attachPage(staleSessionId, staleTargetId);
     this.reattachPromise = attempt;
     try {
       await attempt;
@@ -285,11 +293,15 @@ export class Session implements Transport {
     }
   }
 
-  private async attachFirstPage(staleSessionId: string): Promise<void> {
+  private async attachPage(staleSessionId: string, staleTargetId?: string): Promise<void> {
     const domainsToRestore = [...(this.enabledDomains.get(staleSessionId)?.entries() ?? [])];
     const { targetInfos } = await this.domains.Target.getTargets({});
     const pages = targetInfos as PageTarget[];
-    const targetId = pages.find(isUsablePageTarget)?.targetId
+    const exactTarget = staleTargetId
+      ? pages.find(target => target.type === 'page' && target.targetId === staleTargetId)
+      : undefined;
+    const targetId = exactTarget?.targetId
+      ?? (!staleTargetId ? pages.find(isUsablePageTarget)?.targetId : undefined)
       ?? (await this.domains.Target.createTarget({ url: 'about:blank' })).targetId;
     const sessionId = await this.use(targetId);
     await Promise.all(

packages/bcode-browser/test/cdp-recovery.test.ts

@@ -11,6 +11,7 @@ test("a missing page session is reattached once and the rejected command is retr
   let getTargetsCount = 0
   let staleCommandCount = 0
   const commandSessions: string[] = []
+  const attachedTargets: string[] = []
   const enabledDomains: string[] = []
   const server = Bun.serve({
     port: 0,
@@ -22,6 +23,7 @@ test("a missing page session is reattached once and the rejected command is retr
         const message = JSON.parse(String(raw))
         if (message.method === "Target.attachToTarget") {
           attachCount++
+          attachedTargets.push(message.params.targetId)
           socket.send(JSON.stringify({ id: message.id, result: { sessionId: `session-${attachCount}` } }))
           return
         }
@@ -31,7 +33,10 @@ test("a missing page session is reattached once and the rejected command is retr
             socket.send(JSON.stringify({
               id: message.id,
               result: {
-                targetInfos: [{ targetId: "page-1", title: "Page", type: "page", url: "https://example.com" }],
+                targetInfos: [
+                  { targetId: "other-page", title: "Other", type: "page", url: "https://other.example" },
+                  { targetId: "page-1", title: "Page", type: "page", url: "https://example.com" },
+                ],
               },
             }))
           }, 10)
@@ -81,6 +86,7 @@ test("a missing page session is reattached once and the rejected command is retr
     expect(second.result.value).toBe("2")
     expect(third.result.value).toBe("3")
     expect(attachCount).toBe(2)
+    expect(attachedTargets).toEqual(["page-1", "page-1"])
     expect(getTargetsCount).toBe(1)
     expect(enabledDomains).toEqual(["Debugger.enable", "Debugger.enable"])
     expect(commandSessions).toEqual([
@@ -229,9 +235,10 @@ test("reattach reuses an existing about:blank target", async () => {
   }
 })
 
-test("reattach creates a blank page when only internal targets remain", async () => {
+test("reattach creates a blank page instead of switching to another live target", async () => {
   let attachCount = 0
   let createdTarget: unknown
+  const attachedTargets: string[] = []
   const server = Bun.serve({
     port: 0,
     fetch(req, bunServer) {
@@ -242,14 +249,18 @@ test("reattach creates a blank page when only internal targets remain", async ()
         const message = JSON.parse(String(raw))
         if (message.method === "Target.attachToTarget") {
           attachCount++
+          attachedTargets.push(message.params.targetId)
           socket.send(JSON.stringify({ id: message.id, result: { sessionId: `session-${attachCount}` } }))
           return
         }
         if (message.method === "Target.getTargets") {
           socket.send(JSON.stringify({
             id: message.id,
             result: {
-              targetInfos: [{ targetId: "settings", title: "Settings", type: "page", url: "chrome://settings" }],
+              targetInfos: [
+                { targetId: "other-page", title: "Other", type: "page", url: "https://other.example" },
+                { targetId: "settings", title: "Settings", type: "page", url: "chrome://settings" },
+              ],
             },
           }))
           return
@@ -287,6 +298,7 @@ test("reattach creates a blank page when only internal targets remain", async ()
     expect(result.result.value).toBe(true)
     expect(createdTarget).toEqual({ url: "about:blank" })
     expect(attachCount).toBe(2)
+    expect(attachedTargets).toEqual(["old-page", "fresh-page"])
   } finally {
     session.close()
     server.stop(true)