@vellumai/assistant 0.7.1 → 0.7.3

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

@@ -2,7 +2,8 @@
  * Unit tests for the /v1/host-browser-result route handler.
  *
  * Resolution goes through HostBrowserProxy.instance (singleton). The
- * mock below controls the proxy's pending request map and resolve spy.
+ * 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";
 
@@ -19,20 +20,15 @@ interface ResolveCall {
 }
 
 const resolveSpy: ResolveCall[] = [];
-const pendingRequests = new Set<string>();
 
 mock.module("../daemon/host-browser-proxy.js", () => ({
   HostBrowserProxy: {
     get instance() {
       return {
-        hasPendingRequest(requestId: string) {
-          return pendingRequests.has(requestId);
-        },
-        resolve(
+        resolveResult(
           requestId: string,
           response: { content: string; isError: boolean },
         ) {
-          pendingRequests.delete(requestId);
           resolveSpy.push({ requestId, response });
         },
       };
@@ -40,9 +36,16 @@ mock.module("../daemon/host-browser-proxy.js", () => ({
   },
 }));
 
+// Use the real pending-interactions module for the guard check.
+const pendingInteractions = await import("../runtime/pending-interactions.js");
+
 // ── Real imports (after mocks) ───────────────────────────────────────
 
-import { BadRequestError, 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(() => {
@@ -57,13 +60,16 @@ const handleHostBrowserResult = ROUTES.find(
 
 describe("handleHostBrowserResult", () => {
   beforeEach(() => {
-    pendingRequests.clear();
+    pendingInteractions.clear();
     resolveSpy.length = 0;
   });
 
   test("happy path: resolves a pending host_browser request via singleton", async () => {
     const requestId = "browser-req-happy";
-    pendingRequests.add(requestId);
+    pendingInteractions.register(requestId, {
+      conversationId: "conv-1",
+      kind: "host_browser",
+    });
 
     const result = await handleHostBrowserResult({
       body: { requestId, content: "ok", isError: false },
@@ -73,8 +79,6 @@ describe("handleHostBrowserResult", () => {
     expect(resolveSpy).toHaveLength(1);
     expect(resolveSpy[0].requestId).toBe(requestId);
     expect(resolveSpy[0].response).toEqual({ content: "ok", isError: false });
-
-    expect(pendingRequests.has(requestId)).toBe(false);
   });
 
   test("missing body: throws BadRequestError", () => {
@@ -99,9 +103,31 @@ describe("handleHostBrowserResult", () => {
     ).toThrow(NotFoundError);
   });
 
+  test("kind mismatch: throws ConflictError when pending interaction is not host_browser", () => {
+    const requestId = "bash-req-kind-mismatch";
+    pendingInteractions.register(requestId, {
+      conversationId: "conv-1",
+      kind: "host_bash", // wrong kind
+    });
+
+    expect(() =>
+      handleHostBrowserResult({
+        body: { requestId, content: "x", isError: false },
+      }),
+    ).toThrow(ConflictError);
+
+    // Interaction must NOT have been consumed — the bash proxy can still resolve it
+    expect(pendingInteractions.get(requestId)).toBeDefined();
+    // resolveResult should never have been called
+    expect(resolveSpy).toHaveLength(0);
+  });
+
   test("defaults: missing content/isError default to '' and false", async () => {
     const requestId = "browser-req-defaults";
-    pendingRequests.add(requestId);
+    pendingInteractions.register(requestId, {
+      conversationId: "conv-1",
+      kind: "host_browser",
+    });
 
     const result = await handleHostBrowserResult({ body: { requestId } });
 

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

@@ -1,28 +1,28 @@
 import { afterEach, describe, expect, jest, mock, test } from "bun:test";
 
 const sentMessages: unknown[] = [];
-const resolvedInteractionIds: string[] = [];
 let mockHasClient = false;
+type MockClient = {
+  clientId: string;
+  capabilities: string[];
+  actorPrincipalId?: string;
+};
+let mockClients: MockClient[] = [];
 
 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,
+    getClientById: (id: string) =>
+      mockClients.find((c) => c.clientId === id) ?? undefined,
+    getActorPrincipalIdForClient: (id: string) =>
+      mockClients.find((c) => c.clientId === id)?.actorPrincipalId,
   },
 }));
 
-mock.module("../runtime/pending-interactions.js", () => ({
-  resolve: (requestId: string) => {
-    resolvedInteractionIds.push(requestId);
-    return undefined;
-  },
-  get: () => undefined,
-  getByKind: () => [],
-  getByConversation: () => [],
-  removeByConversation: () => {},
-}));
-
+// 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", () => {
@@ -30,13 +30,15 @@ describe("HostCuProxy", () => {
 
   function setup(maxSteps?: number) {
     sentMessages.length = 0;
-    resolvedInteractionIds.length = 0;
     mockHasClient = false;
+    mockClients = [];
+    pendingInteractions.clear();
     proxy = new HostCuProxy(maxSteps);
   }
 
   afterEach(() => {
     proxy?.dispose();
+    pendingInteractions.clear();
   });
 
   // -------------------------------------------------------------------------
@@ -66,9 +68,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",
       });
@@ -78,7 +80,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 () => {
@@ -94,7 +96,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]",
       });
@@ -118,7 +120,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,
@@ -142,7 +144,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" });
     });
   });
 
@@ -165,10 +167,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;
     });
   });
@@ -193,14 +195,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 () => {
@@ -296,7 +298,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);
@@ -370,7 +372,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;
@@ -384,7 +386,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
       });
@@ -402,7 +404,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;
@@ -424,7 +426,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
       });
@@ -444,7 +446,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;
@@ -458,7 +460,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
       });
@@ -478,7 +480,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;
@@ -492,7 +494,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;
@@ -507,7 +509,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]",
       });
@@ -719,11 +721,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");
     });
 
@@ -786,9 +788,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();
     });
   });
 
@@ -811,17 +813,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);
       };
@@ -847,7 +843,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.
@@ -881,7 +877,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);
@@ -889,7 +885,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"]);
@@ -927,7 +923,7 @@ describe("HostCuProxy", () => {
       controller.abort();
 
       await resultPromise;
-      expect(resolvedInteractionIds).toContain(requestId);
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
     });
 
     test("fires on dispose", async () => {
@@ -948,7 +944,7 @@ describe("HostCuProxy", () => {
       // dispose rejects pending requests — catch to avoid unhandled rejection
       await resultPromise.catch(() => {});
 
-      expect(resolvedInteractionIds).toContain(requestId);
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
     });
 
     test("does not fire on normal client-initiated resolve", async () => {
@@ -964,10 +960,10 @@ describe("HostCuProxy", () => {
       const sent = sentMessages[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
 
-      proxy.resolve(requestId, { axTree: "Button [1]" });
+      proxy.processObservation(requestId, { axTree: "Button [1]" });
 
       await resultPromise;
-      expect(resolvedInteractionIds).toEqual([]);
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
     });
   });
 
@@ -988,4 +984,204 @@ describe("HostCuProxy", () => {
       expect(proxy.isAvailable()).toBe(true);
     });
   });
+
+  // -------------------------------------------------------------------------
+  // targetClientId validation
+  //
+  // The surfaceProxyResolver layer validates first (so an invalid ID does
+  // not burn a step or pollute action history — see cu-unified-flow.test.ts
+  // for those tests). The proxy ALSO validates internally because it is
+  // exposed as a separately-callable API; these tests exercise that
+  // backstop along with the same-user enforcement.
+  // -------------------------------------------------------------------------
+
+  describe("targetClientId validation", () => {
+    test("rejects when targetClientId does not match any connected client", async () => {
+      setup();
+      mockClients = [
+        {
+          clientId: "real-client",
+          capabilities: ["host_cu"],
+          actorPrincipalId: "user-1",
+        },
+      ];
+
+      const result = await proxy.request(
+        "computer_use_click",
+        { element_id: 1 },
+        "session-1",
+        1,
+        undefined,
+        undefined,
+        "ghost-client",
+        "user-1",
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("ghost-client");
+      expect(result.content).toContain("host_cu");
+      expect(sentMessages).toHaveLength(0);
+    });
+
+    test("rejects when target client lacks host_cu capability", async () => {
+      setup();
+      mockClients = [
+        {
+          clientId: "no-cu-client",
+          capabilities: ["host_bash"],
+          actorPrincipalId: "user-1",
+        },
+      ];
+
+      const result = await proxy.request(
+        "computer_use_click",
+        { element_id: 1 },
+        "session-1",
+        1,
+        undefined,
+        undefined,
+        "no-cu-client",
+        "user-1",
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("does not support host_cu");
+      expect(sentMessages).toHaveLength(0);
+    });
+
+    test("succeeds when caller and target share the same actor principal", async () => {
+      setup();
+      mockClients = [
+        {
+          clientId: "cu-client",
+          capabilities: ["host_cu"],
+          actorPrincipalId: "user-1",
+        },
+      ];
+
+      const resultPromise = proxy.request(
+        "computer_use_click",
+        { element_id: 1 },
+        "session-1",
+        1,
+        undefined,
+        undefined,
+        "cu-client",
+        "user-1",
+      );
+
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.type).toBe("host_cu_request");
+      expect(sent.targetClientId).toBe("cu-client");
+
+      proxy.processObservation(sent.requestId as string, { axTree: "ok" });
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+    });
+
+    test("rejects cross-user targeted request", async () => {
+      setup();
+      mockClients = [
+        {
+          clientId: "cu-client",
+          capabilities: ["host_cu"],
+          actorPrincipalId: "user-2",
+        },
+      ];
+
+      const result = await proxy.request(
+        "computer_use_click",
+        { element_id: 1 },
+        "session-1",
+        1,
+        undefined,
+        undefined,
+        "cu-client",
+        "user-1",
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain(
+        "Submitting actor does not match the target client's actor",
+      );
+      expect(sentMessages).toHaveLength(0);
+    });
+
+    test("rejects when source actor principal is missing", async () => {
+      setup();
+      mockClients = [
+        {
+          clientId: "cu-client",
+          capabilities: ["host_cu"],
+          actorPrincipalId: "user-1",
+        },
+      ];
+
+      const result = await proxy.request(
+        "computer_use_click",
+        { element_id: 1 },
+        "session-1",
+        1,
+        undefined,
+        undefined,
+        "cu-client",
+        // sourceActorPrincipalId omitted
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain(
+        "Submitting actor does not match the target client's actor",
+      );
+      expect(sentMessages).toHaveLength(0);
+    });
+
+    test("rejects when target actor principal is missing", async () => {
+      setup();
+      mockClients = [
+        {
+          clientId: "cu-client",
+          capabilities: ["host_cu"],
+          // actorPrincipalId omitted
+        },
+      ];
+
+      const result = await proxy.request(
+        "computer_use_click",
+        { element_id: 1 },
+        "session-1",
+        1,
+        undefined,
+        undefined,
+        "cu-client",
+        "user-1",
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain(
+        "Submitting actor does not match the target client's actor",
+      );
+      expect(sentMessages).toHaveLength(0);
+    });
+
+    test("untargeted request bypasses same-user check", async () => {
+      setup();
+      // No targetClientId, no sourceActorPrincipalId — flow proceeds.
+      const resultPromise = proxy.request(
+        "computer_use_click",
+        { element_id: 1 },
+        "session-1",
+        1,
+      );
+
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.type).toBe("host_cu_request");
+      expect(sent.targetClientId).toBeUndefined();
+
+      proxy.processObservation(sent.requestId as string, { axTree: "ok" });
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+    });
+  });
 });