@flrande/browserctl 0.5.0-dev.22.1 → 0.6.0

package/apps/browserd/src/tool-matrix.test.ts

@@ -1,887 +0,0 @@
-import { PassThrough } from "node:stream";
-
-import { describe, expect, it } from "vitest";
-
-import { bootstrapBrowserd } from "./bootstrap";
-import { reserveLoopbackPort } from "./test-port";
-
-function waitForNextJsonLine(stream: PassThrough): Promise<Record<string, unknown>> {
-  return new Promise((resolve, reject) => {
-    let buffer = "";
-    const timeout = setTimeout(() => {
-      stream.off("data", onData);
-      reject(new Error("Timed out waiting for JSON line response."));
-    }, 1000);
-
-    const onData = (chunk: string | Buffer) => {
-      buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
-      const newlineIndex = buffer.indexOf("\n");
-      if (newlineIndex < 0) {
-        return;
-      }
-
-      clearTimeout(timeout);
-      stream.off("data", onData);
-      const line = buffer.slice(0, newlineIndex);
-
-      resolve(JSON.parse(line) as Record<string, unknown>);
-    };
-
-    stream.on("data", onData);
-  });
-}
-
-function sendToolRequest(
-  input: PassThrough,
-  output: PassThrough,
-  request: Record<string, unknown>
-): Promise<Record<string, unknown>> {
-  const responsePromise = waitForNextJsonLine(output);
-  input.write(`${JSON.stringify(request)}\n`);
-  return responsePromise;
-}
-
-async function createManagedLegacyRuntime(
-  overrides: Record<string, string | undefined> = {}
-) {
-  const relayPort = await reserveLoopbackPort();
-
-  const input = new PassThrough();
-  const output = new PassThrough();
-  const runtime = bootstrapBrowserd({
-    env: {
-      BROWSERD_DEFAULT_DRIVER: "managed",
-      BROWSERD_CHROME_RELAY_URL: `http://127.0.0.1:${relayPort}`,
-      ...overrides
-    },
-    input,
-    output,
-    stdioProtocol: "legacy"
-  });
-
-  return {
-    input,
-    output,
-    runtime
-  };
-}
-
-describe("browserd tool matrix", () => {
-  it("returns E_INVALID_ARG for missing required arguments on routed tools", async () => {
-    const { input, output, runtime } = await createManagedLegacyRuntime();
-
-    try {
-      const toolNames = [
-        "browser.profile.use",
-        "browser.tab.focus",
-        "browser.tab.close",
-        "browser.snapshot",
-        "browser.dom.query",
-        "browser.dom.queryAll",
-        "browser.element.screenshot",
-        "browser.a11y.snapshot",
-        "browser.wait.element",
-        "browser.wait.text",
-        "browser.wait.url",
-        "browser.cookie.get",
-        "browser.cookie.set",
-        "browser.cookie.clear",
-        "browser.storage.get",
-        "browser.storage.set",
-        "browser.frame.list",
-        "browser.frame.snapshot",
-        "browser.act",
-        "browser.dialog.arm",
-        "browser.download.trigger",
-        "browser.network.list",
-        "browser.network.harExport",
-        "browser.network.waitFor",
-        "browser.console.list",
-        "browser.session.drop"
-      ] as const;
-
-      for (const [index, toolName] of toolNames.entries()) {
-        const response = await sendToolRequest(input, output, {
-          id: `request-missing-arg-${index}`,
-          name: toolName,
-          traceId: `trace:missing-arg:${index}`,
-          arguments: {
-            sessionId: "session:missing-arg"
-          }
-        });
-
-        expect(response.ok).toBe(false);
-        expect(response.error).toMatchObject({
-          code: "E_INVALID_ARG"
-        });
-      }
-    } finally {
-      runtime.close();
-      input.end();
-      output.end();
-    }
-  });
-
-  it("routes browser.memory tools with validation and deterministic state", async () => {
-    const { input, output, runtime } = await createManagedLegacyRuntime();
-
-    try {
-      const statusResponse = await sendToolRequest(input, output, {
-        id: "request-memory-status",
-        name: "browser.memory.status",
-        traceId: "trace:memory:status",
-        arguments: {
-          sessionId: "session:memory"
-        }
-      });
-      expect(statusResponse.ok).toBe(true);
-      const statusPayload = statusResponse.data as {
-        path?: unknown;
-        mode?: unknown;
-        ttlDays?: unknown;
-        totalEntries?: unknown;
-      };
-      expect(typeof statusPayload.path).toBe("string");
-      expect((statusPayload.path as string).length).toBeGreaterThan(0);
-      expect(statusPayload.mode).toBe("ask");
-      expect(typeof statusPayload.ttlDays).toBe("number");
-      expect(typeof statusPayload.totalEntries).toBe("number");
-
-      const resolveMissingArgResponse = await sendToolRequest(input, output, {
-        id: "request-memory-resolve-missing",
-        name: "browser.memory.resolve",
-        traceId: "trace:memory:resolve:missing",
-        arguments: {
-          sessionId: "session:memory"
-        }
-      });
-      expect(resolveMissingArgResponse.ok).toBe(false);
-      expect(resolveMissingArgResponse.error).toMatchObject({
-        code: "E_INVALID_ARG"
-      });
-
-      const upsertMissingArgResponse = await sendToolRequest(input, output, {
-        id: "request-memory-upsert-missing",
-        name: "browser.memory.upsert",
-        traceId: "trace:memory:upsert:missing",
-        arguments: {
-          sessionId: "session:memory"
-        }
-      });
-      expect(upsertMissingArgResponse.ok).toBe(false);
-      expect(upsertMissingArgResponse.error).toMatchObject({
-        code: "E_INVALID_ARG"
-      });
-
-      const upsertFreeTextSignalResponse = await sendToolRequest(input, output, {
-        id: "request-memory-upsert-free-text-signal",
-        name: "browser.memory.upsert",
-        traceId: "trace:memory:upsert:free-text-signal",
-        arguments: {
-          sessionId: "session:memory",
-          domain: "example.com",
-          profileId: "managed",
-          intentKey: "checkout",
-          signals: [
-            {
-              kind: "urlPattern",
-              value: "this is copied page body text that should never be stored"
-            }
-          ],
-          confirmed: true
-        }
-      });
-      expect(upsertFreeTextSignalResponse.ok).toBe(false);
-      expect(upsertFreeTextSignalResponse.error).toMatchObject({
-        code: "E_INVALID_ARG"
-      });
-
-      const upsertResponse = await sendToolRequest(input, output, {
-        id: "request-memory-upsert",
-        name: "browser.memory.upsert",
-        traceId: "trace:memory:upsert",
-        arguments: {
-          sessionId: "session:memory",
-          domain: "example.com",
-          profileId: "managed",
-          intentKey: "checkout",
-          signals: [
-            {
-              kind: "urlPattern",
-              value: "/checkout"
-            }
-          ],
-          confidence: 0.8,
-          confirmed: true
-        }
-      });
-      expect(upsertResponse.ok).toBe(true);
-      const upsertPayload = upsertResponse.data as {
-        created?: unknown;
-        entry?: {
-          id?: unknown;
-          domain?: unknown;
-          profileId?: unknown;
-          intentKey?: unknown;
-          confidence?: unknown;
-          hitCount?: unknown;
-        };
-      };
-      expect(upsertPayload.created).toBe(true);
-      expect(upsertPayload.entry?.domain).toBe("example.com");
-      expect(upsertPayload.entry?.profileId).toBe("managed");
-      expect(upsertPayload.entry?.intentKey).toBe("checkout");
-      expect(upsertPayload.entry?.confidence).toBe(0.8);
-      expect(upsertPayload.entry?.hitCount).toBe(0);
-      expect(typeof upsertPayload.entry?.id).toBe("string");
-      expect((upsertPayload.entry?.id as string).length).toBeGreaterThan(0);
-
-      const memoryId = upsertPayload.entry?.id as string;
-
-      const listResponse = await sendToolRequest(input, output, {
-        id: "request-memory-list",
-        name: "browser.memory.list",
-        traceId: "trace:memory:list",
-        arguments: {
-          sessionId: "session:memory"
-        }
-      });
-      expect(listResponse.ok).toBe(true);
-      expect(listResponse.data).toMatchObject({
-        entries: [{ id: memoryId }]
-      });
-
-      const inspectResponse = await sendToolRequest(input, output, {
-        id: "request-memory-inspect",
-        name: "browser.memory.inspect",
-        traceId: "trace:memory:inspect",
-        arguments: {
-          sessionId: "session:memory",
-          id: memoryId
-        }
-      });
-      expect(inspectResponse.ok).toBe(true);
-      expect(inspectResponse.data).toMatchObject({
-        entry: {
-          id: memoryId
-        }
-      });
-
-      const resolveResponse = await sendToolRequest(input, output, {
-        id: "request-memory-resolve",
-        name: "browser.memory.resolve",
-        traceId: "trace:memory:resolve",
-        arguments: {
-          sessionId: "session:memory",
-          domain: "example.com",
-          profileId: "managed",
-          intentKey: "checkout"
-        }
-      });
-      expect(resolveResponse.ok).toBe(true);
-      expect(resolveResponse.data).toMatchObject({
-        hit: true,
-        entry: {
-          id: memoryId,
-          hitCount: 1
-        }
-      });
-
-      const deleteResponse = await sendToolRequest(input, output, {
-        id: "request-memory-delete",
-        name: "browser.memory.delete",
-        traceId: "trace:memory:delete",
-        arguments: {
-          sessionId: "session:memory",
-          id: memoryId
-        }
-      });
-      expect(deleteResponse.ok).toBe(true);
-      expect(deleteResponse.data).toMatchObject({
-        deleted: true
-      });
-
-      const purgeResponse = await sendToolRequest(input, output, {
-        id: "request-memory-purge",
-        name: "browser.memory.purge",
-        traceId: "trace:memory:purge",
-        arguments: {
-          sessionId: "session:memory"
-        }
-      });
-      expect(purgeResponse.ok).toBe(true);
-      expect(purgeResponse.data).toMatchObject({
-        purged: 0
-      });
-
-      const modeSetResponse = await sendToolRequest(input, output, {
-        id: "request-memory-mode-set",
-        name: "browser.memory.mode.set",
-        traceId: "trace:memory:mode:set",
-        arguments: {
-          sessionId: "session:memory",
-          mode: "ask"
-        }
-      });
-      expect(modeSetResponse.ok).toBe(true);
-      expect(modeSetResponse.data).toMatchObject({
-        mode: "ask"
-      });
-
-      const modeOffResponse = await sendToolRequest(input, output, {
-        id: "request-memory-mode-set-off",
-        name: "browser.memory.mode.set",
-        traceId: "trace:memory:mode:set:off",
-        arguments: {
-          sessionId: "session:memory",
-          mode: "off"
-        }
-      });
-      expect(modeOffResponse.ok).toBe(true);
-      expect(modeOffResponse.data).toMatchObject({
-        mode: "off"
-      });
-
-      const policyRejectResponse = await sendToolRequest(input, output, {
-        id: "request-memory-upsert-policy-reject",
-        name: "browser.memory.upsert",
-        traceId: "trace:memory:upsert:policy:reject",
-        arguments: {
-          sessionId: "session:memory",
-          domain: "example.com",
-          profileId: "managed",
-          intentKey: "checkout",
-          signals: [
-            {
-              kind: "urlPattern",
-              value: "/checkout"
-            }
-          ],
-          confidence: 0.6
-        }
-      });
-      expect(policyRejectResponse.ok).toBe(false);
-      expect(policyRejectResponse.error).toMatchObject({
-        code: "E_PERMISSION"
-      });
-
-      const ttlSetResponse = await sendToolRequest(input, output, {
-        id: "request-memory-ttl-set",
-        name: "browser.memory.ttl.set",
-        traceId: "trace:memory:ttl:set",
-        arguments: {
-          sessionId: "session:memory",
-          ttlDays: 7
-        }
-      });
-      expect(ttlSetResponse.ok).toBe(true);
-      expect(ttlSetResponse.data).toMatchObject({
-        ttlDays: 7
-      });
-    } finally {
-      runtime.close();
-      input.end();
-      output.end();
-    }
-  });
-
-  it("records memory-hit marker in browser.trace.get after browser.memory.resolve", async () => {
-    const { input, output, runtime } = await createManagedLegacyRuntime();
-
-    try {
-      const upsertResponse = await sendToolRequest(input, output, {
-        id: "request-memory-hit-upsert",
-        name: "browser.memory.upsert",
-        traceId: "trace:memory:hit:upsert",
-        arguments: {
-          sessionId: "session:memory-hit",
-          domain: "example.com",
-          profileId: "managed",
-          intentKey: "checkout",
-          signals: [
-            {
-              kind: "urlPattern",
-              value: "/checkout"
-            }
-          ],
-          confidence: 0.9,
-          confirmed: true
-        }
-      });
-      expect(upsertResponse.ok).toBe(true);
-
-      const resolveResponse = await sendToolRequest(input, output, {
-        id: "request-memory-hit-resolve",
-        name: "browser.memory.resolve",
-        traceId: "trace:memory:hit:resolve",
-        arguments: {
-          sessionId: "session:memory-hit",
-          domain: "example.com",
-          profileId: "managed",
-          intentKey: "checkout"
-        }
-      });
-      expect(resolveResponse.ok).toBe(true);
-      expect(resolveResponse.data).toMatchObject({
-        hit: true
-      });
-
-      const traceGetResponse = await sendToolRequest(input, output, {
-        id: "request-memory-hit-trace-get",
-        name: "browser.trace.get",
-        traceId: "trace:memory:hit:trace-get",
-        arguments: {
-          sessionId: "session:memory-hit",
-          limit: 20
-        }
-      });
-      expect(traceGetResponse.ok).toBe(true);
-      const tracePayload = traceGetResponse.data as {
-        keyResponses?: Array<{
-          kind?: string;
-          data?: {
-            memoryHit?: boolean;
-          };
-        }>;
-      };
-      expect(tracePayload.keyResponses?.some((response) =>
-        response.kind === "memory.resolve" && response.data?.memoryHit === true
-      )).toBe(true);
-    } finally {
-      runtime.close();
-      input.end();
-      output.end();
-    }
-  });
-
-  it("keeps browser.memory disabled when BROWSERD_MEMORY_ENABLED is false", async () => {
-    const { input, output, runtime } = await createManagedLegacyRuntime({
-      BROWSERD_MEMORY_ENABLED: "false"
-    });
-
-    try {
-      const statusResponse = await sendToolRequest(input, output, {
-        id: "request-memory-disabled-status",
-        name: "browser.memory.status",
-        traceId: "trace:memory:disabled:status",
-        arguments: {
-          sessionId: "session:memory:disabled"
-        }
-      });
-
-      expect(statusResponse.ok).toBe(true);
-      expect(statusResponse.data).toMatchObject({
-        mode: "off"
-      });
-
-      const modeSetResponse = await sendToolRequest(input, output, {
-        id: "request-memory-disabled-mode-set",
-        name: "browser.memory.mode.set",
-        traceId: "trace:memory:disabled:mode:set",
-        arguments: {
-          sessionId: "session:memory:disabled",
-          mode: "auto"
-        }
-      });
-
-      expect(modeSetResponse.ok).toBe(false);
-      expect(modeSetResponse.error).toMatchObject({
-        code: "E_PERMISSION"
-      });
-
-      const statusAfterResponse = await sendToolRequest(input, output, {
-        id: "request-memory-disabled-status-after",
-        name: "browser.memory.status",
-        traceId: "trace:memory:disabled:status:after",
-        arguments: {
-          sessionId: "session:memory:disabled"
-        }
-      });
-      expect(statusAfterResponse.ok).toBe(true);
-      expect(statusAfterResponse.data).toMatchObject({
-        mode: "off"
-      });
-    } finally {
-      runtime.close();
-      input.end();
-      output.end();
-    }
-  });
-
-  it("returns E_DRIVER_UNAVAILABLE for structured action tools on managed driver", async () => {
-    const { input, output, runtime } = await createManagedLegacyRuntime();
-
-    try {
-      const openResponse = await sendToolRequest(input, output, {
-        id: "request-unavailable-open",
-        name: "browser.tab.open",
-        traceId: "trace:unavailable:open",
-        arguments: {
-          sessionId: "session:unavailable",
-          url: "https://example.com/unavailable"
-        }
-      });
-      const targetId = (openResponse.data as { targetId: string }).targetId;
-
-      const cases: Array<{ name: string; arguments: Record<string, unknown> }> = [
-        {
-          name: "browser.dom.query",
-          arguments: {
-            sessionId: "session:unavailable",
-            targetId,
-            selector: "#root"
-          }
-        },
-        {
-          name: "browser.dom.queryAll",
-          arguments: {
-            sessionId: "session:unavailable",
-            targetId,
-            selector: ".item"
-          }
-        },
-        {
-          name: "browser.element.screenshot",
-          arguments: {
-            sessionId: "session:unavailable",
-            targetId,
-            selector: "#hero"
-          }
-        },
-        {
-          name: "browser.a11y.snapshot",
-          arguments: {
-            sessionId: "session:unavailable",
-            targetId
-          }
-        },
-        {
-          name: "browser.wait.element",
-          arguments: {
-            sessionId: "session:unavailable",
-            targetId,
-            selector: "#ready",
-            timeoutMs: 5,
-            pollMs: 1
-          }
-        },
-        {
-          name: "browser.wait.text",
-          arguments: {
-            sessionId: "session:unavailable",
-            targetId,
-            text: "ready",
-            selector: "#status",
-            timeoutMs: 5,
-            pollMs: 1
-          }
-        },
-        {
-          name: "browser.cookie.get",
-          arguments: {
-            sessionId: "session:unavailable",
-            targetId
-          }
-        },
-        {
-          name: "browser.cookie.set",
-          arguments: {
-            sessionId: "session:unavailable",
-            targetId,
-            name: "sid",
-            value: "abc"
-          }
-        },
-        {
-          name: "browser.cookie.clear",
-          arguments: {
-            sessionId: "session:unavailable",
-            targetId
-          }
-        },
-        {
-          name: "browser.storage.get",
-          arguments: {
-            sessionId: "session:unavailable",
-            targetId,
-            scope: "local",
-            key: "theme"
-          }
-        },
-        {
-          name: "browser.storage.set",
-          arguments: {
-            sessionId: "session:unavailable",
-            targetId,
-            scope: "local",
-            key: "theme",
-            value: "dark"
-          }
-        },
-        {
-          name: "browser.frame.list",
-          arguments: {
-            sessionId: "session:unavailable",
-            targetId
-          }
-        },
-        {
-          name: "browser.frame.snapshot",
-          arguments: {
-            sessionId: "session:unavailable",
-            targetId,
-            frameId: "frame:0"
-          }
-        }
-      ];
-
-      for (const [index, testCase] of cases.entries()) {
-        const response = await sendToolRequest(input, output, {
-          id: `request-driver-unavailable-${index}`,
-          name: testCase.name,
-          traceId: `trace:driver-unavailable:${index}`,
-          arguments: testCase.arguments
-        });
-
-        expect(response.ok).toBe(false);
-        expect(response.error).toMatchObject({
-          code: "E_DRIVER_UNAVAILABLE"
-        });
-      }
-    } finally {
-      runtime.close();
-      input.end();
-      output.end();
-    }
-  });
-
-  it("routes managed-driver tools including profile.use, act, focus/close, and waitFor timeout", async () => {
-    const { input, output, runtime } = await createManagedLegacyRuntime();
-
-    try {
-      const profileUseResponse = await sendToolRequest(input, output, {
-        id: "request-profile-use",
-        name: "browser.profile.use",
-        traceId: "trace:matrix:profile-use",
-        arguments: {
-          sessionId: "session:profile-use",
-          profile: "managed"
-        }
-      });
-      expect(profileUseResponse.ok).toBe(true);
-      expect(profileUseResponse.data).toEqual({
-        profile: "managed"
-      });
-
-      const openResponse = await sendToolRequest(input, output, {
-        id: "request-flow-open",
-        name: "browser.tab.open",
-        traceId: "trace:matrix:open",
-        arguments: {
-          sessionId: "session:flow",
-          url: "https://example.com/flow"
-        }
-      });
-      const targetId = (openResponse.data as { targetId: string }).targetId;
-
-      const snapshotResponse = await sendToolRequest(input, output, {
-        id: "request-flow-snapshot",
-        name: "browser.snapshot",
-        traceId: "trace:matrix:snapshot",
-        arguments: {
-          sessionId: "session:flow",
-          targetId
-        }
-      });
-      expect(snapshotResponse.ok).toBe(true);
-      expect(snapshotResponse.data).toMatchObject({
-        driver: "managed",
-        targetId
-      });
-
-      const focusResponse = await sendToolRequest(input, output, {
-        id: "request-flow-focus",
-        name: "browser.tab.focus",
-        traceId: "trace:matrix:focus",
-        arguments: {
-          sessionId: "session:flow",
-          targetId
-        }
-      });
-      expect(focusResponse.ok).toBe(true);
-      expect(focusResponse.data).toMatchObject({
-        driver: "managed",
-        targetId,
-        focused: true
-      });
-
-      const actResponse = await sendToolRequest(input, output, {
-        id: "request-flow-act",
-        name: "browser.act",
-        traceId: "trace:matrix:act",
-        arguments: {
-          sessionId: "session:flow",
-          targetId,
-          action: {
-            type: "click",
-            payload: {
-              selector: "#go"
-            }
-          }
-        }
-      });
-      expect(actResponse.ok).toBe(true);
-      expect(actResponse.data).toMatchObject({
-        driver: "managed",
-        targetId,
-        result: {
-          actionType: "click",
-          targetId,
-          targetKnown: true,
-          ok: true
-        }
-      });
-
-      const dialogResponse = await sendToolRequest(input, output, {
-        id: "request-flow-dialog",
-        name: "browser.dialog.arm",
-        traceId: "trace:matrix:dialog",
-        arguments: {
-          sessionId: "session:flow",
-          targetId
-        }
-      });
-      expect(dialogResponse.ok).toBe(true);
-      expect(dialogResponse.data).toMatchObject({
-        driver: "managed",
-        targetId,
-        armed: true
-      });
-
-      const triggerResponse = await sendToolRequest(input, output, {
-        id: "request-flow-trigger",
-        name: "browser.download.trigger",
-        traceId: "trace:matrix:trigger",
-        arguments: {
-          sessionId: "session:flow",
-          targetId
-        }
-      });
-      expect(triggerResponse.ok).toBe(true);
-      expect(triggerResponse.data).toMatchObject({
-        driver: "managed",
-        targetId,
-        triggered: true
-      });
-
-      const waitForResponse = await sendToolRequest(input, output, {
-        id: "request-flow-waitfor",
-        name: "browser.network.waitFor",
-        traceId: "trace:matrix:waitfor",
-        arguments: {
-          sessionId: "session:flow",
-          targetId,
-          urlPattern: "/never-match",
-          timeoutMs: 5,
-          pollMs: 1
-        }
-      });
-      expect(waitForResponse.ok).toBe(false);
-      expect(waitForResponse.error).toMatchObject({
-        code: "E_TIMEOUT"
-      });
-
-      const networkListResponse = await sendToolRequest(input, output, {
-        id: "request-flow-network-list",
-        name: "browser.network.list",
-        traceId: "trace:matrix:network-list",
-        arguments: {
-          sessionId: "session:flow",
-          targetId
-        }
-      });
-      expect(networkListResponse.ok).toBe(true);
-      expect(networkListResponse.data).toMatchObject({
-        driver: "managed",
-        targetId,
-        requests: []
-      });
-
-      const harExportResponse = await sendToolRequest(input, output, {
-        id: "request-flow-har-export",
-        name: "browser.network.harExport",
-        traceId: "trace:matrix:har-export",
-        arguments: {
-          sessionId: "session:flow",
-          targetId
-        }
-      });
-      expect(harExportResponse.ok).toBe(true);
-      expect(harExportResponse.data).toMatchObject({
-        driver: "managed",
-        targetId,
-        har: {
-          log: {
-            entries: []
-          }
-        }
-      });
-
-      const traceGetResponse = await sendToolRequest(input, output, {
-        id: "request-flow-trace-get",
-        name: "browser.trace.get",
-        traceId: "trace:matrix:trace-get",
-        arguments: {
-          sessionId: "session:flow",
-          limit: 20
-        }
-      });
-      expect(traceGetResponse.ok).toBe(true);
-      expect(traceGetResponse.data).toMatchObject({
-        sessionId: "session:flow"
-      });
-      const tracePayload = traceGetResponse.data as {
-        steps?: Array<{ tool?: string }>;
-      };
-      expect(Array.isArray(tracePayload.steps)).toBe(true);
-      expect(tracePayload.steps?.some((step) => step.tool === "browser.tab.open")).toBe(true);
-
-      const waitUrlResponse = await sendToolRequest(input, output, {
-        id: "request-flow-waiturl",
-        name: "browser.wait.url",
-        traceId: "trace:matrix:waiturl",
-        arguments: {
-          sessionId: "session:flow",
-          targetId,
-          urlPattern: "/never-match",
-          timeoutMs: 5,
-          pollMs: 1
-        }
-      });
-      expect(waitUrlResponse.ok).toBe(false);
-      expect(waitUrlResponse.error).toMatchObject({
-        code: "E_TIMEOUT"
-      });
-
-      const closeResponse = await sendToolRequest(input, output, {
-        id: "request-flow-close",
-        name: "browser.tab.close",
-        traceId: "trace:matrix:close",
-        arguments: {
-          sessionId: "session:flow",
-          targetId
-        }
-      });
-      expect(closeResponse.ok).toBe(true);
-      expect(closeResponse.data).toMatchObject({
-        driver: "managed",
-        targetId,
-        closed: true
-      });
-    } finally {
-      runtime.close();
-      input.end();
-      output.end();
-    }
-  });
-});