@vellumai/assistant 0.7.0 → 0.7.2

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

@@ -1,13 +1,12 @@
 /**
  * Unit tests for the /v1/host-browser-result route handler.
  *
- * Tests handleHostBrowserResult directly via RouteHandlerArgs with a
- * stub Conversation whose resolveHostBrowser method records calls.
+ * Resolution goes through HostBrowserProxy.instance (singleton). The
+ * mock below spies on resolveResult; the real pendingInteractions
+ * module provides the guard check for unknown request IDs.
  */
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { Conversation } from "../daemon/conversation.js";
-
 // ── Module mocks ─────────────────────────────────────────────────────
 
 mock.module("../config/env.js", () => ({
@@ -15,10 +14,38 @@ mock.module("../config/env.js", () => ({
   hasUngatedHttpAuthDisabled: () => false,
 }));
 
+interface ResolveCall {
+  requestId: string;
+  response: { content: string; isError: boolean };
+}
+
+const resolveSpy: ResolveCall[] = [];
+
+mock.module("../daemon/host-browser-proxy.js", () => ({
+  HostBrowserProxy: {
+    get instance() {
+      return {
+        resolveResult(
+          requestId: string,
+          response: { content: string; isError: boolean },
+        ) {
+          resolveSpy.push({ requestId, response });
+        },
+      };
+    },
+  },
+}));
+
+// Use the real pending-interactions module for the guard check.
+const pendingInteractions = await import("../runtime/pending-interactions.js");
+
 // ── Real imports (after mocks) ───────────────────────────────────────
 
-import * as pendingInteractions from "../runtime/pending-interactions.js";
-import { BadRequestError, ConflictError, NotFoundError } from "../runtime/routes/errors.js";
+import {
+  BadRequestError,
+  ConflictError,
+  NotFoundError,
+} from "../runtime/routes/errors.js";
 import { ROUTES } from "../runtime/routes/host-browser-routes.js";
 
 afterAll(() => {
@@ -29,38 +56,17 @@ const handleHostBrowserResult = ROUTES.find(
   (r) => r.endpoint === "host-browser-result",
 )!.handler;
 
-// ── Helpers ──────────────────────────────────────────────────────────
-
-interface ResolveHostBrowserCall {
-  requestId: string;
-  response: { content: string; isError: boolean };
-}
-
-function makeStubConversation(spy: ResolveHostBrowserCall[]): Conversation {
-  return {
-    resolveHostBrowser(
-      requestId: string,
-      response: { content: string; isError: boolean },
-    ) {
-      spy.push({ requestId, response });
-    },
-  } as unknown as Conversation;
-}
-
 // ── Tests ────────────────────────────────────────────────────────────
 
 describe("handleHostBrowserResult", () => {
   beforeEach(() => {
     pendingInteractions.clear();
+    resolveSpy.length = 0;
   });
 
-  test("happy path: resolves a pending host_browser interaction", async () => {
-    const spy: ResolveHostBrowserCall[] = [];
-    const conversation = makeStubConversation(spy);
+  test("happy path: resolves a pending host_browser request via singleton", async () => {
     const requestId = "browser-req-happy";
-
     pendingInteractions.register(requestId, {
-      conversation,
       conversationId: "conv-1",
       kind: "host_browser",
     });
@@ -70,12 +76,9 @@ describe("handleHostBrowserResult", () => {
     });
 
     expect(result).toEqual({ accepted: true });
-    expect(spy).toHaveLength(1);
-    expect(spy[0].requestId).toBe(requestId);
-    expect(spy[0].response).toEqual({ content: "ok", isError: false });
-
-    // Pending interaction should be consumed
-    expect(pendingInteractions.get(requestId)).toBeUndefined();
+    expect(resolveSpy).toHaveLength(1);
+    expect(resolveSpy[0].requestId).toBe(requestId);
+    expect(resolveSpy[0].response).toEqual({ content: "ok", isError: false });
   });
 
   test("missing body: throws BadRequestError", () => {
@@ -83,9 +86,9 @@ describe("handleHostBrowserResult", () => {
   });
 
   test("missing requestId: throws BadRequestError", () => {
-    expect(() =>
-      handleHostBrowserResult({ body: { content: "x" } }),
-    ).toThrow(BadRequestError);
+    expect(() => handleHostBrowserResult({ body: { content: "x" } })).toThrow(
+      BadRequestError,
+    );
   });
 
   test("unknown requestId: throws NotFoundError", () => {
@@ -100,15 +103,11 @@ describe("handleHostBrowserResult", () => {
     ).toThrow(NotFoundError);
   });
 
-  test("wrong kind: throws ConflictError with mismatch message", () => {
-    const spy: ResolveHostBrowserCall[] = [];
-    const conversation = makeStubConversation(spy);
-    const requestId = "browser-req-wrong-kind";
-
+  test("kind mismatch: throws ConflictError when pending interaction is not host_browser", () => {
+    const requestId = "bash-req-kind-mismatch";
     pendingInteractions.register(requestId, {
-      conversation,
       conversationId: "conv-1",
-      kind: "host_bash",
+      kind: "host_bash", // wrong kind
     });
 
     expect(() =>
@@ -117,18 +116,15 @@ describe("handleHostBrowserResult", () => {
       }),
     ).toThrow(ConflictError);
 
-    // Pending interaction should NOT have been consumed
+    // Interaction must NOT have been consumed — the bash proxy can still resolve it
     expect(pendingInteractions.get(requestId)).toBeDefined();
-    expect(spy).toHaveLength(0);
+    // resolveResult should never have been called
+    expect(resolveSpy).toHaveLength(0);
   });
 
   test("defaults: missing content/isError default to '' and false", async () => {
-    const spy: ResolveHostBrowserCall[] = [];
-    const conversation = makeStubConversation(spy);
     const requestId = "browser-req-defaults";
-
     pendingInteractions.register(requestId, {
-      conversation,
       conversationId: "conv-1",
       kind: "host_browser",
     });
@@ -136,8 +132,8 @@ describe("handleHostBrowserResult", () => {
     const result = await handleHostBrowserResult({ body: { requestId } });
 
     expect(result).toEqual({ accepted: true });
-    expect(spy).toHaveLength(1);
-    expect(spy[0].requestId).toBe(requestId);
-    expect(spy[0].response).toEqual({ content: "", isError: false });
+    expect(resolveSpy).toHaveLength(1);
+    expect(resolveSpy[0].requestId).toBe(requestId);
+    expect(resolveSpy[0].response).toEqual({ content: "", isError: false });
   });
 });

package/src/__tests__/host-cu-proxy.test.ts

@@ -1,26 +1,33 @@
-import { afterEach, describe, expect, jest, test } from "bun:test";
+import { afterEach, describe, expect, jest, mock, test } from "bun:test";
 
-import { HostCuProxy } from "../daemon/host-cu-proxy.js";
+const sentMessages: unknown[] = [];
+let mockHasClient = false;
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: (msg: unknown) => sentMessages.push(msg),
+  assistantEventHub: {
+    getMostRecentClientByCapability: (cap: string) =>
+      cap === "host_cu" && mockHasClient ? { id: "mock-client" } : null,
+  },
+}));
+
+// Use the REAL pending-interactions module — the proxy self-registers here.
+const pendingInteractions = await import("../runtime/pending-interactions.js");
+const { HostCuProxy } = await import("../daemon/host-cu-proxy.js");
 
 describe("HostCuProxy", () => {
   let proxy: InstanceType<typeof HostCuProxy>;
-  let sentMessages: unknown[];
-  let sendToClient: (msg: unknown) => void;
-  let resolvedRequestIds: string[];
 
   function setup(maxSteps?: number) {
-    sentMessages = [];
-    resolvedRequestIds = [];
-    sendToClient = (msg: unknown) => sentMessages.push(msg);
-    proxy = new HostCuProxy(
-      sendToClient as never,
-      (requestId: string) => resolvedRequestIds.push(requestId),
-      maxSteps,
-    );
+    sentMessages.length = 0;
+    mockHasClient = false;
+    pendingInteractions.clear();
+    proxy = new HostCuProxy(maxSteps);
   }
 
   afterEach(() => {
     proxy?.dispose();
+    pendingInteractions.clear();
   });
 
   // -------------------------------------------------------------------------
@@ -50,9 +57,9 @@ describe("HostCuProxy", () => {
       expect(typeof sent.requestId).toBe("string");
 
       const requestId = sent.requestId as string;
-      expect(proxy.hasPendingRequest(requestId)).toBe(true);
+      expect(pendingInteractions.get(requestId)).toBeDefined();
 
-      proxy.resolve(requestId, {
+      proxy.processObservation(requestId, {
         axTree: "Button [1]\nLabel [2]",
         executionResult: "Clicked element 42",
       });
@@ -62,7 +69,7 @@ describe("HostCuProxy", () => {
       expect(result.content).toContain("<ax-tree>");
       expect(result.content).toContain("CURRENT SCREEN STATE:");
       expect(result.isError).toBe(false);
-      expect(proxy.hasPendingRequest(requestId)).toBe(false);
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
     });
 
     test("formats error observation correctly", async () => {
@@ -78,7 +85,7 @@ describe("HostCuProxy", () => {
       const sent = sentMessages[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
 
-      proxy.resolve(requestId, {
+      proxy.processObservation(requestId, {
         executionError: "Element not found",
         axTree: "Window [1]",
       });
@@ -102,7 +109,7 @@ describe("HostCuProxy", () => {
       const sent = sentMessages[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
 
-      proxy.resolve(requestId, {
+      proxy.processObservation(requestId, {
         axTree: "Button [1]",
         screenshot: "base64data",
         screenshotWidthPx: 1920,
@@ -126,7 +133,7 @@ describe("HostCuProxy", () => {
     test("resolves with unknown requestId is silently ignored", () => {
       setup();
       // Should not throw
-      proxy.resolve("unknown-id", { axTree: "something" });
+      proxy.processObservation("unknown-id", { axTree: "something" });
     });
   });
 
@@ -149,10 +156,10 @@ describe("HostCuProxy", () => {
 
       const sent = sentMessages[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
-      expect(proxy.hasPendingRequest(requestId)).toBe(true);
+      expect(pendingInteractions.get(requestId)).toBeDefined();
 
       // Resolve to avoid test hanging
-      proxy.resolve(requestId, { axTree: "resolved" });
+      proxy.processObservation(requestId, { axTree: "resolved" });
       await resultPromise;
     });
   });
@@ -177,14 +184,14 @@ describe("HostCuProxy", () => {
 
       const sent = sentMessages[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
-      expect(proxy.hasPendingRequest(requestId)).toBe(true);
+      expect(pendingInteractions.get(requestId)).toBeDefined();
 
       controller.abort();
 
       const result = await resultPromise;
       expect(result.content).toContain("Aborted");
       expect(result.isError).toBe(true);
-      expect(proxy.hasPendingRequest(requestId)).toBe(false);
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
     });
 
     test("sends host_cu_cancel to client on abort", async () => {
@@ -280,7 +287,7 @@ describe("HostCuProxy", () => {
       expect(sentMessages).toHaveLength(1); // Message was sent
 
       const sent = sentMessages[0] as Record<string, unknown>;
-      proxy.resolve(sent.requestId as string, { axTree: "screen" });
+      proxy.processObservation(sent.requestId as string, { axTree: "screen" });
 
       const result = await resultPromise;
       expect(result.isError).toBe(false);
@@ -354,7 +361,7 @@ describe("HostCuProxy", () => {
       );
       proxy.recordAction("computer_use_click", { element_id: 1 });
       const sent1 = sentMessages[0] as Record<string, unknown>;
-      proxy.resolve(sent1.requestId as string, {
+      proxy.processObservation(sent1.requestId as string, {
         axTree: "Button [1]",
       });
       await p1;
@@ -368,7 +375,7 @@ describe("HostCuProxy", () => {
       );
       proxy.recordAction("computer_use_click", { element_id: 1 });
       const sent2 = sentMessages[1] as Record<string, unknown>;
-      proxy.resolve(sent2.requestId as string, {
+      proxy.processObservation(sent2.requestId as string, {
         axTree: "Button [1]",
         // No axDiff — screen unchanged
       });
@@ -386,7 +393,7 @@ describe("HostCuProxy", () => {
       );
       proxy.recordAction("computer_use_click", { element_id: 1 });
       const sent3 = sentMessages[2] as Record<string, unknown>;
-      proxy.resolve(sent3.requestId as string, {
+      proxy.processObservation(sent3.requestId as string, {
         axTree: "Button [1]",
       });
       const result3 = await p3;
@@ -408,7 +415,7 @@ describe("HostCuProxy", () => {
         1,
       );
       const sent1 = sentMessages[0] as Record<string, unknown>;
-      proxy.resolve(sent1.requestId as string, {
+      proxy.processObservation(sent1.requestId as string, {
         axTree: "Button [1]",
         // No axDiff on first observation — this is normal, not unchanged
       });
@@ -428,7 +435,7 @@ describe("HostCuProxy", () => {
       );
       proxy.recordAction("computer_use_click", { element_id: 1 });
       const sent1 = sentMessages[0] as Record<string, unknown>;
-      proxy.resolve(sent1.requestId as string, {
+      proxy.processObservation(sent1.requestId as string, {
         axTree: "Button [1]",
       });
       await p1;
@@ -442,7 +449,7 @@ describe("HostCuProxy", () => {
       );
       proxy.recordAction("computer_use_wait", { duration_ms: 2000 });
       const sent2 = sentMessages[1] as Record<string, unknown>;
-      proxy.resolve(sent2.requestId as string, {
+      proxy.processObservation(sent2.requestId as string, {
         axTree: "Button [1]",
         // No axDiff — screen unchanged, but that's expected after wait
       });
@@ -462,7 +469,7 @@ describe("HostCuProxy", () => {
       );
       proxy.recordAction("computer_use_click", { element_id: 1 });
       const sent1 = sentMessages[0] as Record<string, unknown>;
-      proxy.resolve(sent1.requestId as string, {
+      proxy.processObservation(sent1.requestId as string, {
         axTree: "Button [1]",
       });
       await p1;
@@ -476,7 +483,7 @@ describe("HostCuProxy", () => {
       );
       proxy.recordAction("computer_use_click", { element_id: 1 });
       const sent2 = sentMessages[1] as Record<string, unknown>;
-      proxy.resolve(sent2.requestId as string, {
+      proxy.processObservation(sent2.requestId as string, {
         axTree: "Button [1]",
       });
       await p2;
@@ -491,7 +498,7 @@ describe("HostCuProxy", () => {
       );
       proxy.recordAction("computer_use_click", { element_id: 2 });
       const sent3 = sentMessages[2] as Record<string, unknown>;
-      proxy.resolve(sent3.requestId as string, {
+      proxy.processObservation(sent3.requestId as string, {
         axTree: "TextField [1]",
         axDiff: "+ TextField [1]\n- Button [1]",
       });
@@ -703,11 +710,11 @@ describe("HostCuProxy", () => {
 
       const sent = sentMessages[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
-      expect(proxy.hasPendingRequest(requestId)).toBe(true);
+      expect(pendingInteractions.get(requestId)).toBeDefined();
 
       proxy.dispose();
 
-      expect(proxy.hasPendingRequest(requestId)).toBe(false);
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
       await expect(resultPromise).rejects.toThrow("Host CU proxy disposed");
     });
 
@@ -770,9 +777,9 @@ describe("HostCuProxy", () => {
       expect(result.content).toContain("Aborted");
 
       // Late resolve should be silently ignored (no throw, no double-resolve)
-      proxy.resolve(requestId, { axTree: "late response" });
+      proxy.processObservation(requestId, { axTree: "late response" });
 
-      expect(proxy.hasPendingRequest(requestId)).toBe(false);
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
     });
   });
 
@@ -795,17 +802,11 @@ describe("HostCuProxy", () => {
       const s = source as any;
       const origAdd = source.addEventListener.bind(source);
       const origRemove = source.removeEventListener.bind(source);
-      s.addEventListener = (
-        type: string,
-        ...rest: any[]
-      ) => {
+      s.addEventListener = (type: string, ...rest: any[]) => {
         addCalls.push(type);
         return (origAdd as any)(type, ...rest);
       };
-      s.removeEventListener = (
-        type: string,
-        ...rest: any[]
-      ) => {
+      s.removeEventListener = (type: string, ...rest: any[]) => {
         removeCalls.push(type);
         return (origRemove as any)(type, ...rest);
       };
@@ -831,7 +832,7 @@ describe("HostCuProxy", () => {
 
       const requestId = (sentMessages[0] as Record<string, unknown>)
         .requestId as string;
-      proxy.resolve(requestId, { axTree: "Button [1]" });
+      proxy.processObservation(requestId, { axTree: "Button [1]" });
       await resultPromise;
 
       // Listener is detached after normal completion.
@@ -865,7 +866,7 @@ describe("HostCuProxy", () => {
 
         const requestId = (sentMessages[0] as Record<string, unknown>)
           .requestId as string;
-        expect(proxy.hasPendingRequest(requestId)).toBe(true);
+        expect(pendingInteractions.get(requestId)).toBeDefined();
 
         // Advance past the 60s internal timeout.
         jest.advanceTimersByTime(61 * 1000);
@@ -873,7 +874,7 @@ describe("HostCuProxy", () => {
         const result = await resultPromise;
         expect(result.isError).toBe(true);
         expect(result.content).toContain("Host CU proxy timed out");
-        expect(proxy.hasPendingRequest(requestId)).toBe(false);
+        expect(pendingInteractions.get(requestId)).toBeUndefined();
 
         // Listener is detached after the timer fires.
         expect(spy.removeCalls).toEqual(["abort"]);
@@ -888,87 +889,54 @@ describe("HostCuProxy", () => {
   });
 
   // -------------------------------------------------------------------------
-  // sender throws synchronously
+  // pendingInteractions.resolve callback
   // -------------------------------------------------------------------------
 
-  describe("sender throws synchronously", () => {
-    test("rejects the promise, clears pending state and timer, invokes onInternalResolve", async () => {
-      sentMessages = [];
-      resolvedRequestIds = [];
-      const throwingSend = () => {
-        throw new Error("transport down");
-      };
-      proxy = new HostCuProxy(throwingSend as never, (requestId: string) =>
-        resolvedRequestIds.push(requestId),
-      );
+  describe("pendingInteractions.resolve callback", () => {
+    test("fires when abort signal fires", async () => {
+      setup();
 
-      // request() synchronously calls sendToClient inside the Promise
-      // executor. A throw there surfaces as a rejected promise.
+      const controller = new AbortController();
       const resultPromise = proxy.request(
         "computer_use_click",
         { element_id: 1 },
         "session-1",
         1,
+        undefined,
+        controller.signal,
       );
 
-      await expect(resultPromise).rejects.toThrow("transport down");
+      const sent = sentMessages[0] as Record<string, unknown>;
+      const requestId = sent.requestId as string;
 
-      // The internal resolve should fire exactly once as part of cleanup.
-      expect(resolvedRequestIds).toHaveLength(1);
+      controller.abort();
 
-      // Issue a new request on a fresh (non-throwing) sender and verify
-      // the proxy is still functional — no stale timers or bookkeeping
-      // from the failed request.
-      sentMessages = [];
-      proxy.updateSender(
-        ((msg: unknown) => sentMessages.push(msg)) as never,
-        true,
-      );
-      const okPromise = proxy.request(
-        "computer_use_click",
-        { element_id: 2 },
-        "session-1",
-        2,
-      );
-      expect(sentMessages).toHaveLength(1);
-      const okRequestId = (sentMessages[0] as Record<string, unknown>)
-        .requestId as string;
-      expect(proxy.hasPendingRequest(okRequestId)).toBe(true);
-      proxy.resolve(okRequestId, { axTree: "Button [2]" });
-      const okResult = await okPromise;
-      expect(okResult.isError).toBe(false);
-      expect(okResult.content).toContain("Button [2]");
+      await resultPromise;
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
     });
-  });
-
-  // -------------------------------------------------------------------------
-  // onInternalResolve callback
-  // -------------------------------------------------------------------------
 
-  describe("onInternalResolve", () => {
-    test("calls onInternalResolve when abort signal fires", async () => {
+    test("fires on dispose", async () => {
       setup();
 
-      const controller = new AbortController();
       const resultPromise = proxy.request(
         "computer_use_click",
         { element_id: 1 },
         "session-1",
         1,
-        undefined,
-        controller.signal,
       );
 
       const sent = sentMessages[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
 
-      controller.abort();
+      proxy.dispose();
 
-      await resultPromise;
-      expect(resolvedRequestIds).toContain(requestId);
+      // dispose rejects pending requests — catch to avoid unhandled rejection
+      await resultPromise.catch(() => {});
+
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
     });
 
-    test("calls onInternalResolve on dispose", async () => {
+    test("does not fire on normal client-initiated resolve", async () => {
       setup();
 
       const resultPromise = proxy.request(
@@ -981,12 +949,10 @@ describe("HostCuProxy", () => {
       const sent = sentMessages[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
 
-      proxy.dispose();
-
-      // dispose rejects pending requests — catch to avoid unhandled rejection
-      await resultPromise.catch(() => {});
+      proxy.processObservation(requestId, { axTree: "Button [1]" });
 
-      expect(resolvedRequestIds).toContain(requestId);
+      await resultPromise;
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
     });
   });
 
@@ -995,52 +961,20 @@ describe("HostCuProxy", () => {
   // -------------------------------------------------------------------------
 
   describe("isAvailable", () => {
-    test("returns false by default", () => {
+    test("returns false when no client with host_cu capability is connected", () => {
       setup();
+      mockHasClient = false;
       expect(proxy.isAvailable()).toBe(false);
     });
 
-    test("returns true after updateSender with clientConnected=true", () => {
+    test("returns true when a client with host_cu capability is connected", () => {
       setup();
-      proxy.updateSender(sendToClient as never, true);
+      mockHasClient = true;
       expect(proxy.isAvailable()).toBe(true);
     });
-
-    test("returns false after updateSender with clientConnected=false", () => {
-      setup();
-      proxy.updateSender(sendToClient as never, true);
-      proxy.updateSender(sendToClient as never, false);
-      expect(proxy.isAvailable()).toBe(false);
-    });
   });
 
-  // -------------------------------------------------------------------------
-  // updateSender
-  // -------------------------------------------------------------------------
-
-  describe("updateSender", () => {
-    test("uses updated sender for new requests", async () => {
-      setup();
-
-      const newMessages: unknown[] = [];
-      proxy.updateSender((msg) => newMessages.push(msg), true);
-
-      const resultPromise = proxy.request(
-        "computer_use_click",
-        { element_id: 1 },
-        "session-1",
-        1,
-      );
-
-      expect(sentMessages).toHaveLength(0); // Old sender not used
-      expect(newMessages).toHaveLength(1); // New sender used
-
-      const sent = newMessages[0] as Record<string, unknown>;
-      proxy.resolve(sent.requestId as string, {
-        axTree: "Button [1]",
-      });
-
-      await resultPromise;
-    });
-  });
+  // targetClientId validation lives at the surfaceProxyResolver layer (so an
+  // invalid ID does not burn a step or pollute action history before being
+  // rejected). See cu-unified-flow.test.ts for those tests.
 });