Guard Runtime.enable sender lookup in a11y context collection

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

Author: cursoragent

currentState.md

@@ -198,6 +198,7 @@ HyperAgent exposes a TypeScript SDK for browser automation with three primary pa
 - Hardened a11y runtime-context collection listener wiring:
   - `collectExecutionContexts()` now guards `session.on`/`session.off` method reads and listener attach/detach calls,
   - context collection now tolerates trap-prone runtime listener method getters while preserving sanitized diagnostics in debug mode.
+  - `collectExecutionContexts()` now also guards trap-prone `session.send` reads for `Runtime.enable`, preventing getter traps from aborting the context collection path.
 - 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.
 - Hardened Playwright session listener wrappers:

src/context-providers/a11y-dom/index.test.ts

@@ -329,4 +329,75 @@ describe("getA11yDOM error formatting", () => {
       errorSpy.mockRestore();
     }
   });
+
+  it("continues when runtime sender getter traps during context collection", async () => {
+    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+    const errorSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+    const page = {
+      evaluate: jest.fn().mockResolvedValue(undefined),
+      url: jest.fn(() => "https://example.com"),
+    } as unknown as Page;
+    let sendGetterReadCount = 0;
+    const session = {
+      id: "session-1",
+      get send() {
+        sendGetterReadCount += 1;
+        if (sendGetterReadCount === 2) {
+          throw new Error(`runtime-send\u0000\n${"x".repeat(2_000)}`);
+        }
+        return async (method: string) => {
+          if (method === "Accessibility.getFullAXTree") {
+            throw new Error("stop after context collection");
+          }
+          return {};
+        };
+      },
+      on: jest.fn(),
+      off: jest.fn(),
+    };
+    getCDPClientMock.mockResolvedValue({
+      acquireSession: jest.fn().mockResolvedValue(session),
+    });
+    getOrCreateFrameContextManagerMock.mockReturnValue({
+      setDebug: jest.fn(),
+      ensureInitialized: jest.fn().mockResolvedValue(undefined),
+      captureOOPIFs: jest.fn().mockResolvedValue(undefined),
+      setFrameFilteringEnabled: jest.fn(),
+    });
+    buildBackendIdMapsMock.mockResolvedValue({
+      frameMap: new Map([
+        [
+          1,
+          {
+            frameIndex: 1,
+            siblingPosition: 0,
+            src: "https://example.com/frame",
+            xpath: "//iframe[1]",
+            parentFrameIndex: 0,
+            frameId: "frame-1",
+          },
+        ],
+      ]),
+      backendNodeMap: {},
+      xpathMap: {},
+      frameMetadataMap: new Map(),
+      frameTree: new Map(),
+    });
+
+    try {
+      const result = await getA11yDOM(page, true);
+      expect(result.domState).toBe("Error: Could not extract accessibility tree");
+      const warning = String(
+        warnSpy.mock.calls.find((call) =>
+          String(call[0] ?? "").includes("Failed to read Runtime.enable sender")
+        )?.[0] ?? ""
+      );
+      expect(warning).toContain("[truncated");
+      expect(warning).not.toContain("\u0000");
+      expect(warning).not.toContain("\n");
+    } finally {
+      warnSpy.mockRestore();
+      errorSpy.mockRestore();
+    }
+  });
 });

src/context-providers/a11y-dom/index.ts

@@ -192,29 +192,61 @@ async function collectExecutionContexts(
     }
   };
 
-  const onMethod = readSessionMethod("on");
-  if (onMethod) {
+  const enableRuntimeDomain = async (): Promise<void> => {
+    let sendMethod: unknown;
     try {
-      onMethod.call(session, "Runtime.executionContextCreated", handler);
+      sendMethod = (session as CDPSession & { send?: unknown }).send;
     } catch (error) {
       if (debug) {
         console.warn(
-          `[A11y] Failed to attach Runtime.executionContextCreated listener: ${formatA11yDiagnostic(
+          `[A11y] Failed to read Runtime.enable sender: ${formatA11yDiagnostic(
             error
           )}`
         );
       }
+      return;
     }
-  }
-  try {
-    await session.send("Runtime.enable").catch((error) => {
+    if (typeof sendMethod !== "function") {
+      if (debug) {
+        console.warn(
+          "[A11y] Runtime.enable sender unavailable during context collection"
+        );
+      }
+      return;
+    }
+    try {
+      await (
+        sendMethod as (
+          this: CDPSession,
+          method: "Runtime.enable"
+        ) => Promise<unknown>
+      ).call(session, "Runtime.enable");
+    } catch (error) {
       if (debug) {
         console.warn(
           "[A11y] Failed to enable Runtime domain for context collection. " +
             `Execution contexts may be missing for iframe elements. ${formatA11yDiagnostic(error)}`
         );
       }
-    });
+    }
+  };
+
+  const onMethod = readSessionMethod("on");
+  if (onMethod) {
+    try {
+      onMethod.call(session, "Runtime.executionContextCreated", handler);
+    } catch (error) {
+      if (debug) {
+        console.warn(
+          `[A11y] Failed to attach Runtime.executionContextCreated listener: ${formatA11yDiagnostic(
+            error
+          )}`
+        );
+      }
+    }
+  }
+  try {
+    await enableRuntimeDomain();
     await waitPromise;
   } finally {
     const offMethod = readSessionMethod("off");