Harden Playwright CDP client initialization flow

Co-authored-by: Shri Sukhani <shrisukhani@users.noreply.github.com>

Author: cursoragent

currentState.md

@@ -153,6 +153,9 @@ HyperAgent exposes a TypeScript SDK for browser automation with three primary pa
 - Expanded settle trace regressions with cleaner log-capture coverage to ensure recording-video trace diagnostics remain validated without noisy test output.
 - Hardened settle debug-option lookup against trap-prone `getDebugOptions()` reads, with deterministic fallback trace defaults and sanitized warning diagnostics.
 - Refined settle context probing to avoid noisy warnings when `page.context` is unavailable while still surfacing sanitized diagnostics for trap-prone context method/getter failures.
+- Hardened Playwright CDP session initialization flow:
+  - `createSession` now guards context acquisition, `newCDPSession` method reads, and session creation with bounded/sanitized diagnostics.
+  - `getCDPClientForPage` now always clears pending init promises (including failed init paths) and tolerates trap-prone `page.once` close-listener attachment with sanitized warnings.
 - Hardened A11y DOM option ingestion (`useCache`, `onFrameChunk`, `filterAdTrackingFrames`) with trap-safe reads, so malformed option objects no longer break extraction setup.
 - Hardened A11y DOM debug-option lookup (`getDebugOptions`) with trap-safe fallback defaults and sanitized warning diagnostics.
 - Hardened OpenAI/Anthropic structured-schema debug-option reads so trap-prone debug-option access no longer interrupts structured invocation paths.

src/cdp/playwright-adapter.test.ts

@@ -109,4 +109,81 @@ describe("playwright adapter error formatting", () => {
       warnSpy.mockRestore();
     }
   });
+
+  it("surfaces sanitized diagnostics when page context traps during init", async () => {
+    const page = {
+      context: () => {
+        throw new Error(`context\u0000\n${"x".repeat(2_000)}`);
+      },
+      once: jest.fn(),
+    } as unknown as Page;
+
+    await expect(getCDPClientForPage(page)).rejects.toThrow(
+      "[CDP][PlaywrightAdapter] Failed to create CDP session"
+    );
+
+    await expect(getCDPClientForPage(page)).rejects.toThrow("[truncated");
+  });
+
+  it("clears pending init promise after context-init failure", async () => {
+    const session = {
+      send: jest.fn().mockResolvedValue({}),
+      on: jest.fn(),
+      off: jest.fn(),
+      detach: jest.fn().mockResolvedValue(undefined),
+    } as unknown as PlaywrightSession;
+
+    const context = jest
+      .fn<unknown, []>()
+      .mockImplementationOnce(() => {
+        throw new Error("first init failure");
+      })
+      .mockImplementation(() => ({
+        newCDPSession: jest.fn().mockResolvedValue(session),
+      }));
+
+    const page = {
+      context,
+      once: jest.fn(),
+    } as unknown as Page;
+
+    await expect(getCDPClientForPage(page)).rejects.toThrow(
+      "first init failure"
+    );
+    await expect(getCDPClientForPage(page)).resolves.toBeDefined();
+    expect(context).toHaveBeenCalledTimes(2);
+  });
+
+  it("warns and continues when close-listener attachment traps", async () => {
+    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+    const session = {
+      send: jest.fn().mockResolvedValue({}),
+      on: jest.fn(),
+      off: jest.fn(),
+      detach: jest.fn().mockResolvedValue(undefined),
+    } as unknown as PlaywrightSession;
+
+    const page = {
+      context: () => ({
+        newCDPSession: jest.fn().mockResolvedValue(session),
+      }),
+      get once() {
+        throw new Error(`close-listener\u0000\n${"x".repeat(2_000)}`);
+      },
+    } as unknown as Page;
+
+    try {
+      await expect(getCDPClientForPage(page)).resolves.toBeDefined();
+      const warning = String(
+        warnSpy.mock.calls.find((call) =>
+          String(call[0] ?? "").includes("Failed to attach page close listener")
+        )?.[0] ?? ""
+      );
+      expect(warning).toContain("[truncated");
+      expect(warning).not.toContain("\u0000");
+      expect(warning).not.toContain("\n");
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
 });

src/cdp/playwright-adapter.ts

@@ -161,7 +161,52 @@ class PlaywrightCDPClient implements CDPClient {
 
   async createSession(descriptor?: CDPTargetDescriptor): Promise<CDPSession> {
     const target = this.resolveTarget(descriptor);
-    const session = await this.page.context().newCDPSession(target);
+    let pageContext: unknown;
+    try {
+      pageContext = this.page.context();
+    } catch (error) {
+      throw new Error(
+        `[CDP][PlaywrightAdapter] Failed to create CDP session: ${formatPlaywrightAdapterDiagnostic(
+          error
+        )}`
+      );
+    }
+    if (!pageContext || typeof pageContext !== "object") {
+      throw new Error(
+        "[CDP][PlaywrightAdapter] Failed to create CDP session: page context unavailable"
+      );
+    }
+
+    let newCDPSessionMethod: unknown;
+    try {
+      newCDPSessionMethod = (
+        pageContext as { newCDPSession?: unknown }
+      ).newCDPSession;
+    } catch (error) {
+      throw new Error(
+        `[CDP][PlaywrightAdapter] Failed to create CDP session: ${formatPlaywrightAdapterDiagnostic(
+          error
+        )}`
+      );
+    }
+    if (typeof newCDPSessionMethod !== "function") {
+      throw new Error(
+        "[CDP][PlaywrightAdapter] Failed to create CDP session: newCDPSession() unavailable"
+      );
+    }
+
+    let session: PlaywrightSession;
+    try {
+      session = (await (
+        newCDPSessionMethod as (targetArg: Page | Frame) => Promise<PlaywrightSession>
+      )(target)) as PlaywrightSession;
+    } catch (error) {
+      throw new Error(
+        `[CDP][PlaywrightAdapter] Failed to create CDP session: ${formatPlaywrightAdapterDiagnostic(
+          error
+        )}`
+      );
+    }
     const wrapped = new PlaywrightSessionAdapter(session, (adapter) =>
       this.trackedSessions.delete(adapter)
     );
@@ -298,12 +343,30 @@ export async function getCDPClientForPage(page: Page): Promise<CDPClient> {
     const client = new PlaywrightCDPClient(page);
     await client.init();
     clientCache.set(page, client);
-    pendingClients.delete(page);
-    page.once("close", () => {
-      disposeCDPClientForPage(page).catch(() => {});
-    });
+    try {
+      const once = (page as Page & { once?: unknown }).once;
+      if (typeof once === "function") {
+        (
+          once as (
+            this: Page,
+            event: "close",
+            listener: () => void
+          ) => void
+        ).call(page, "close", () => {
+          disposeCDPClientForPage(page).catch(() => {});
+        });
+      }
+    } catch (error) {
+      console.warn(
+        `[CDP][PlaywrightAdapter] Failed to attach page close listener: ${formatPlaywrightAdapterDiagnostic(
+          error
+        )}`
+      );
+    }
     return client;
-  })();
+  })().finally(() => {
+    pendingClients.delete(page);
+  });
 
   pendingClients.set(page, initPromise);
   return initPromise;