@vellumai/assistant 0.6.2 → 0.6.3

package/src/__tests__/host-browser-event-routes.test.ts

@@ -0,0 +1,350 @@
+/**
+ * Unit tests for the PR10 client-message envelopes:
+ *   - `host_browser_event`
+ *   - `host_browser_session_invalidated`
+ *
+ * The resolvers exported from `host-browser-routes.ts` are the single
+ * entry point for both the WS and any future HTTP transport. These
+ * tests drive them directly (bypassing the WS upgrade + frame parse
+ * machinery) so we can assert:
+ *
+ *   1. A well-formed `host_browser_event` frame fans out to the
+ *      browser-session event bus — a listener subscribed via
+ *      `onCdpEvent` observes the forwarded event with method + params
+ *      + sessionId preserved.
+ *
+ *   2. A well-formed `host_browser_session_invalidated` frame marks
+ *      the target as invalidated in the runtime-side registry. The
+ *      next `BrowserSessionManager.send()` against a session with
+ *      that targetId evicts the session and throws, forcing the
+ *      owning tool to create a fresh one (which, on the extension
+ *      side, triggers a reattach).
+ *
+ *   3. Malformed frames return a well-typed `BAD_REQUEST` resolution
+ *      so the WS dispatcher in `http-server.ts` can log them without
+ *      tearing down the socket.
+ *
+ * The invalidated-target set is consumed on first lookup (see
+ * `consumeInvalidatedTargetId`), so every test that touches it calls
+ * `__resetBrowserSessionEventsForTests()` in `beforeEach` to start
+ * from a clean slate.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  __resetBrowserSessionEventsForTests,
+  type BrowserBackend,
+  BrowserSessionManager,
+  consumeInvalidatedTargetId,
+  createExtensionBackend,
+  type ForwardedCdpEvent,
+  isTargetInvalidated,
+  onCdpEvent,
+} from "../browser-session/index.js";
+import {
+  resolveHostBrowserEvent,
+  resolveHostBrowserSessionInvalidated,
+} from "../runtime/routes/host-browser-routes.js";
+
+// ---------------------------------------------------------------------------
+// Shared fixtures
+// ---------------------------------------------------------------------------
+
+function makeBackend(): BrowserBackend {
+  return createExtensionBackend({
+    isAvailable: () => true,
+    sendCdp: async () => ({ result: { ok: true } }),
+    dispose: () => {},
+  });
+}
+
+describe("resolveHostBrowserEvent", () => {
+  beforeEach(() => {
+    __resetBrowserSessionEventsForTests();
+  });
+
+  test("publishes well-formed frames to subscribers", () => {
+    const observed: ForwardedCdpEvent[] = [];
+    const unsubscribe = onCdpEvent((event) => observed.push(event));
+
+    const resolution = resolveHostBrowserEvent({
+      method: "Page.frameNavigated",
+      params: { frame: { id: "frame-1", url: "https://example.com" } },
+      cdpSessionId: "target-abc",
+    });
+
+    expect(resolution.ok).toBe(true);
+    expect(observed).toHaveLength(1);
+    expect(observed[0].method).toBe("Page.frameNavigated");
+    expect(observed[0].params).toEqual({
+      frame: { id: "frame-1", url: "https://example.com" },
+    });
+    expect(observed[0].cdpSessionId).toBe("target-abc");
+
+    unsubscribe();
+  });
+
+  test("tolerates missing params — publishes with params undefined", () => {
+    const observed: ForwardedCdpEvent[] = [];
+    const unsubscribe = onCdpEvent((event) => observed.push(event));
+
+    const resolution = resolveHostBrowserEvent({
+      method: "Target.targetDestroyed",
+    });
+
+    expect(resolution.ok).toBe(true);
+    expect(observed).toHaveLength(1);
+    expect(observed[0].method).toBe("Target.targetDestroyed");
+    expect(observed[0].params).toBeUndefined();
+    expect(observed[0].cdpSessionId).toBeUndefined();
+
+    unsubscribe();
+  });
+
+  test("treats empty-string cdpSessionId as absent", () => {
+    const observed: ForwardedCdpEvent[] = [];
+    const unsubscribe = onCdpEvent((event) => observed.push(event));
+
+    resolveHostBrowserEvent({
+      method: "Runtime.consoleAPICalled",
+      cdpSessionId: "",
+    });
+
+    expect(observed[0].cdpSessionId).toBeUndefined();
+    unsubscribe();
+  });
+
+  test("rejects frames missing a method", () => {
+    const observed: ForwardedCdpEvent[] = [];
+    const unsubscribe = onCdpEvent((event) => observed.push(event));
+
+    const resolution = resolveHostBrowserEvent({});
+
+    expect(resolution.ok).toBe(false);
+    expect(observed).toHaveLength(0);
+
+    unsubscribe();
+  });
+
+  test("rejects frames with a non-string method", () => {
+    const resolution = resolveHostBrowserEvent({ method: 42 });
+    expect(resolution.ok).toBe(false);
+    if (!resolution.ok) {
+      expect(resolution.code).toBe("BAD_REQUEST");
+      expect(resolution.status).toBe(400);
+    }
+  });
+
+  test("multiple subscribers all receive the event", () => {
+    const a: ForwardedCdpEvent[] = [];
+    const b: ForwardedCdpEvent[] = [];
+    const unsubA = onCdpEvent((event) => a.push(event));
+    const unsubB = onCdpEvent((event) => b.push(event));
+
+    resolveHostBrowserEvent({
+      method: "Network.responseReceived",
+      params: { requestId: "r1" },
+    });
+
+    expect(a).toHaveLength(1);
+    expect(b).toHaveLength(1);
+    expect(a[0].method).toBe("Network.responseReceived");
+    expect(b[0].method).toBe("Network.responseReceived");
+
+    unsubA();
+    unsubB();
+  });
+
+  test("unsubscribe stops delivery", () => {
+    const observed: ForwardedCdpEvent[] = [];
+    const unsubscribe = onCdpEvent((event) => observed.push(event));
+
+    resolveHostBrowserEvent({ method: "Page.loadEventFired" });
+    expect(observed).toHaveLength(1);
+
+    unsubscribe();
+    resolveHostBrowserEvent({ method: "Page.loadEventFired" });
+    expect(observed).toHaveLength(1);
+  });
+
+  test("a throwing listener does not block subsequent listeners", () => {
+    const observed: ForwardedCdpEvent[] = [];
+    const unsubA = onCdpEvent(() => {
+      throw new Error("listener exploded");
+    });
+    const unsubB = onCdpEvent((event) => observed.push(event));
+
+    // Must not throw
+    const resolution = resolveHostBrowserEvent({
+      method: "Page.frameNavigated",
+    });
+
+    expect(resolution.ok).toBe(true);
+    expect(observed).toHaveLength(1);
+
+    unsubA();
+    unsubB();
+  });
+});
+
+describe("resolveHostBrowserSessionInvalidated", () => {
+  beforeEach(() => {
+    __resetBrowserSessionEventsForTests();
+  });
+
+  test("marks the target as invalidated in the registry", () => {
+    const resolution = resolveHostBrowserSessionInvalidated({
+      targetId: "tab-42",
+      reason: "target_closed",
+    });
+
+    expect(resolution.ok).toBe(true);
+    expect(isTargetInvalidated("tab-42")).toBe(true);
+  });
+
+  test("tolerates frames with no targetId (advisory only)", () => {
+    const resolution = resolveHostBrowserSessionInvalidated({
+      reason: "canceled_by_user",
+    });
+
+    expect(resolution.ok).toBe(true);
+  });
+
+  test("rejects frames whose targetId is not a string", () => {
+    const resolution = resolveHostBrowserSessionInvalidated({
+      targetId: 42 as unknown as string,
+    });
+
+    expect(resolution.ok).toBe(false);
+    if (!resolution.ok) {
+      expect(resolution.code).toBe("BAD_REQUEST");
+    }
+  });
+
+  test("BrowserSessionManager evicts a session whose targetId was invalidated and next send forces reattach", async () => {
+    // Track every CDP command the backend sees so we can assert that
+    // the first send (post-invalidation) never reached the backend
+    // while the second send (after reattach) did.
+    const sent: Array<{ method: string }> = [];
+    const backend = createExtensionBackend({
+      isAvailable: () => true,
+      sendCdp: async (command) => {
+        sent.push({ method: command.method });
+        return { result: { ok: true } };
+      },
+      dispose: () => {},
+    });
+
+    const manager = new BrowserSessionManager({ backends: [backend] });
+    const session = manager.createSession();
+    // Tag the session with a targetId — this is how a real tool
+    // invocation would bind its runtime-side session to the
+    // extension's debuggee target.
+    session.targetId = "tab-42";
+
+    // Fire the invalidation envelope as if the extension just
+    // forwarded a detach over the relay WebSocket.
+    const resolution = resolveHostBrowserSessionInvalidated({
+      targetId: "tab-42",
+      reason: "target_closed",
+    });
+    expect(resolution.ok).toBe(true);
+
+    // The next send against the invalidated session MUST throw —
+    // the manager consumes the invalidation flag, evicts the
+    // session, and rejects the command so the caller can create a
+    // fresh session (which triggers a reattach on the extension
+    // side).
+    await expect(
+      manager.send(session.id, { method: "Page.navigate" }),
+    ).rejects.toThrow(/invalidated/);
+
+    // Sanity: the backend never saw the doomed command.
+    expect(sent).toHaveLength(0);
+
+    // The evicted session is gone — sending again throws
+    // "Unknown browser session".
+    await expect(
+      manager.send(session.id, { method: "Page.navigate" }),
+    ).rejects.toThrow(/Unknown browser session/);
+
+    // Creating a fresh session proves the reattach path works: the
+    // caller bounces through `createSession` and a subsequent send
+    // dispatches normally through the backend.
+    const fresh = manager.createSession();
+    const result = await manager.send(fresh.id, { method: "Page.navigate" });
+    expect(result.result).toEqual({ ok: true });
+    expect(sent).toEqual([{ method: "Page.navigate" }]);
+  });
+
+  test("invalidation is consumed on first lookup (set never grows unbounded)", async () => {
+    // Registering the invalidation once should affect only the next
+    // send against that target. A second send against a brand-new
+    // session with the same targetId must NOT be evicted — the entry
+    // was already consumed by the first eviction.
+    const sent: Array<{ method: string }> = [];
+    const backend = createExtensionBackend({
+      isAvailable: () => true,
+      sendCdp: async (command) => {
+        sent.push({ method: command.method });
+        return { result: { ok: true } };
+      },
+      dispose: () => {},
+    });
+    const manager = new BrowserSessionManager({ backends: [backend] });
+
+    resolveHostBrowserSessionInvalidated({ targetId: "tab-99" });
+
+    const first = manager.createSession();
+    first.targetId = "tab-99";
+    await expect(
+      manager.send(first.id, { method: "Page.navigate" }),
+    ).rejects.toThrow(/invalidated/);
+
+    // Second session bound to the same targetId — should dispatch
+    // normally because the registry entry was consumed.
+    const second = manager.createSession();
+    second.targetId = "tab-99";
+    const result = await manager.send(second.id, {
+      method: "Page.navigate",
+    });
+    expect(result.result).toEqual({ ok: true });
+    expect(sent).toHaveLength(1);
+  });
+
+  test("consumeInvalidatedTargetId drains the entry", () => {
+    resolveHostBrowserSessionInvalidated({ targetId: "tab-1" });
+    expect(consumeInvalidatedTargetId("tab-1")).toBe(true);
+    // Second consume is a no-op — the entry was already drained.
+    expect(consumeInvalidatedTargetId("tab-1")).toBe(false);
+  });
+
+  test("invalidateSession on BrowserSessionManager evicts by id", () => {
+    const manager = new BrowserSessionManager({ backends: [makeBackend()] });
+    const session = manager.createSession();
+    expect(manager.getSession(session.id)).toBeDefined();
+    expect(manager.invalidateSession(session.id)).toBe(true);
+    expect(manager.getSession(session.id)).toBeUndefined();
+    // Second invalidate returns false — nothing to remove.
+    expect(manager.invalidateSession(session.id)).toBe(false);
+  });
+
+  test("invalidateByTargetId evicts every session matching the target", () => {
+    const manager = new BrowserSessionManager({ backends: [makeBackend()] });
+    const a = manager.createSession();
+    a.targetId = "tab-7";
+    const b = manager.createSession();
+    b.targetId = "tab-7";
+    const c = manager.createSession();
+    c.targetId = "tab-8";
+
+    expect(manager.invalidateByTargetId("tab-7")).toBe(2);
+    expect(manager.getSession(a.id)).toBeUndefined();
+    expect(manager.getSession(b.id)).toBeUndefined();
+    expect(manager.getSession(c.id)).toBeDefined();
+
+    // Second invalidate returns 0 — both matching sessions are gone.
+    expect(manager.invalidateByTargetId("tab-7")).toBe(0);
+  });
+});