Harden Playwright detach method access in CDP adapter

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

Author: cursoragent

currentState.md

@@ -215,6 +215,9 @@ HyperAgent exposes a TypeScript SDK for browser automation with three primary pa
 - Hardened task error-forwarder listener attach fallback:
   - `HyperAgent` now falls back to `errorEmitter.addListener` when `errorEmitter.on` is unavailable/trap-prone during task-forwarder registration.
   - Added regression coverage proving in-flight listener wiring still succeeds when `on` getter traps, plus retained warning-path coverage when both `on` and `addListener` getters trap.
+- Hardened Playwright CDP session detach method access:
+  - `PlaywrightSessionAdapter.detach()` now performs trap-safe, receiver-bound `session.detach` method reads/invocation and emits deterministic diagnostics when unavailable.
+  - Added regressions for `session.detach` getter traps and unavailable detach methods during client disposal.
 - Refreshed remaining staged-flow wording in the CDP deep dive around OOPIF discovery to describe current execution-context sync progression without stale "Need Phase 4" phrasing.
 - Hardened CDP command dispatch in Playwright session adapter:
   - `PlaywrightSessionAdapter.send()` now guards trap-prone `session.send` method reads and wraps sync send failures with sanitized/diagnostic context.

src/cdp/playwright-adapter.test.ts

@@ -74,6 +74,58 @@ describe("playwright adapter error formatting", () => {
     expect(detachWarning?.length ?? 0).toBeLessThan(700);
   });
 
+  it("surfaces sanitized diagnostics when session.detach getter traps", async () => {
+    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+    const session = {
+      send: jest.fn().mockResolvedValue({}),
+      on: jest.fn(),
+      off: jest.fn(),
+      get detach() {
+        throw new Error(`detach getter trap\u0000\n${"x".repeat(10_000)}`);
+      },
+    } as unknown as PlaywrightSession;
+    const page = {
+      context: () => ({
+        newCDPSession: jest.fn().mockResolvedValue(session),
+      }),
+      once: jest.fn(),
+    } as unknown as Page;
+
+    await getCDPClientForPage(page);
+    await disposeCDPClientForPage(page);
+
+    const detachWarning = warnSpy.mock.calls
+      .map((call) => String(call[0]))
+      .find((line) => line.includes("Failed to detach session"));
+    expect(detachWarning).toBeDefined();
+    expect(detachWarning).toContain("Failed to read session.detach");
+    expect(detachWarning).toContain("[truncated");
+    expect(detachWarning).not.toContain("\u0000");
+    expect(detachWarning).not.toContain("\n");
+  });
+
+  it("surfaces explicit diagnostics when session.detach is unavailable", async () => {
+    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+    const session = {
+      send: jest.fn().mockResolvedValue({}),
+      on: jest.fn(),
+      off: jest.fn(),
+    } as unknown as PlaywrightSession;
+    const page = {
+      context: () => ({
+        newCDPSession: jest.fn().mockResolvedValue(session),
+      }),
+      once: jest.fn(),
+    } as unknown as Page;
+
+    await getCDPClientForPage(page);
+    await disposeCDPClientForPage(page);
+
+    expect(warnSpy).toHaveBeenCalledWith(
+      "[CDP][PlaywrightAdapter] Failed to detach session: [CDP][PlaywrightAdapter] session.detach is unavailable"
+    );
+  });
+
   it("continues disposing sessions when debug-options lookup traps", async () => {
     const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
     const session = {

src/cdp/playwright-adapter.ts

@@ -167,7 +167,24 @@ class PlaywrightSessionAdapter implements CDPSession {
 
   async detach(): Promise<void> {
     try {
-      await this.session.detach();
+      let detachMethod: unknown;
+      try {
+        detachMethod = (this.session as PlaywrightSession & { detach?: unknown })
+          .detach;
+      } catch (error) {
+        throw new Error(
+          `[CDP][PlaywrightAdapter] Failed to read session.detach: ${formatPlaywrightAdapterDiagnostic(
+            error
+          )}`
+        );
+      }
+      if (typeof detachMethod !== "function") {
+        throw new Error("[CDP][PlaywrightAdapter] session.detach is unavailable");
+      }
+
+      await (
+        detachMethod as (this: PlaywrightSession) => Promise<unknown>
+      ).call(this.session);
     } catch (error) {
       console.warn(
         `[CDP][PlaywrightAdapter] Failed to detach session: ${formatPlaywrightAdapterDiagnostic(