@vellumai/assistant 0.7.1 → 0.7.2

package/src/__tests__/host-file-proxy-targeted.test.ts

@@ -0,0 +1,339 @@
+/**
+ * Tests for HostFileProxy Phase 2 targetClientId behaviour.
+ *
+ * Covers:
+ *  - Explicit targetClientId validation (valid, unknown, incapable)
+ *  - Auto-resolve when exactly one host_file-capable client is connected
+ *  - Untargeted broadcast when multiple capable clients are connected
+ *  - targetClientId propagated into cancel messages (abort + dispose)
+ *  - Timeout message includes clientId when resolvedTargetClientId is set
+ */
+import { afterEach, describe, expect, jest, mock, test } from "bun:test";
+
+const sentMessages: unknown[] = [];
+const sentMessageOptions: unknown[] = [];
+const resolvedInteractionIds: string[] = [];
+let mockHasClient = false;
+let mockCapableClients: Array<{ clientId: string; capabilities: string[] }> = [];
+let mockClientRegistry: Map<string, { clientId: string; capabilities: string[] }> = new Map();
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: (msg: unknown, _conversationId?: string, options?: unknown) => {
+    sentMessages.push(msg);
+    sentMessageOptions.push(options);
+  },
+  assistantEventHub: {
+    getMostRecentClientByCapability: (cap: string) =>
+      cap === "host_file" && mockHasClient ? { id: "mock-client" } : null,
+    listClientsByCapability: (_cap: string) => mockCapableClients,
+    getClientById: (clientId: string) => mockClientRegistry.get(clientId),
+  },
+}));
+
+const pendingInteractionMap = new Map<string, Record<string, unknown>>();
+mock.module("../runtime/pending-interactions.js", () => ({
+  register: (requestId: string, interaction: Record<string, unknown>) => {
+    pendingInteractionMap.set(requestId, interaction);
+  },
+  resolve: (requestId: string) => {
+    const interaction = pendingInteractionMap.get(requestId);
+    pendingInteractionMap.delete(requestId);
+    resolvedInteractionIds.push(requestId);
+    return interaction;
+  },
+  get: (requestId: string) => pendingInteractionMap.get(requestId),
+  getByKind: (_kind: string) => Array.from(pendingInteractionMap.entries())
+    .filter(([, v]) => v.kind === _kind)
+    .map(([requestId, v]) => ({ requestId, ...v })),
+  getByConversation: () => [],
+  removeByConversation: () => {},
+}));
+
+const { HostFileProxy } = await import("../daemon/host-file-proxy.js");
+
+describe("HostFileProxy — targetClientId (Phase 2)", () => {
+  let proxy: InstanceType<typeof HostFileProxy>;
+
+  function setup() {
+    sentMessages.length = 0;
+    sentMessageOptions.length = 0;
+    resolvedInteractionIds.length = 0;
+    pendingInteractionMap.clear();
+    mockHasClient = false;
+    mockCapableClients = [];
+    mockClientRegistry = new Map();
+    proxy = new (HostFileProxy as any)();
+  }
+
+  function setupSingleClient(clientId = "client-1") {
+    const entry = { clientId, capabilities: ["host_file"] };
+    mockCapableClients = [entry];
+    mockClientRegistry.set(clientId, entry);
+  }
+
+  function setupMultipleClients(clientIds: string[]) {
+    mockCapableClients = clientIds.map((id) => ({
+      clientId: id,
+      capabilities: ["host_file"],
+    }));
+    for (const entry of mockCapableClients) {
+      mockClientRegistry.set(entry.clientId, entry);
+    }
+  }
+
+  afterEach(() => {
+    proxy?.dispose();
+    HostFileProxy.reset();
+  });
+
+  // ── Explicit targetClientId — valid ──────────────────────────────────
+
+  describe("explicit targetClientId — valid client with host_file", () => {
+    test("resolves to that client and broadcasts with targetClientId option", async () => {
+      setup();
+      setupSingleClient("client-mac");
+      // Also add a second client so explicit targeting is meaningful
+      const entry2 = { clientId: "client-linux", capabilities: ["host_file"] };
+      mockCapableClients.push(entry2);
+      mockClientRegistry.set("client-linux", entry2);
+
+      const resultPromise = proxy.request(
+        {
+          operation: "read",
+          path: "/home/user/notes.txt",
+          targetClientId: "client-mac",
+        },
+        "session-1",
+      );
+
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.type).toBe("host_file_request");
+      expect(sent.targetClientId).toBe("client-mac");
+
+      const opts = sentMessageOptions[0] as Record<string, unknown> | undefined;
+      expect(opts?.targetClientId).toBe("client-mac");
+
+      const requestId = sent.requestId as string;
+      proxy.resolve(requestId, { content: "file contents", isError: false });
+
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+    });
+  });
+
+  // ── Explicit targetClientId — unknown client ─────────────────────────
+
+  describe("explicit targetClientId — unknown client", () => {
+    test("returns error result immediately without broadcasting", async () => {
+      setup();
+      setupSingleClient("client-mac");
+
+      const result = await proxy.request(
+        {
+          operation: "read",
+          path: "/tmp/file.txt",
+          targetClientId: "client-unknown",
+        },
+        "session-1",
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("client-unknown");
+      expect(result.content).toContain("assistant clients list --capability host_file");
+      // No pending entry should have been created
+      expect(sentMessages).toHaveLength(0);
+    });
+
+    test("does not create a pending entry for unknown client", async () => {
+      setup();
+
+      const result = await proxy.request(
+        {
+          operation: "write",
+          path: "/tmp/out.txt",
+          content: "data",
+          targetClientId: "client-ghost",
+        },
+        "session-1",
+      );
+
+      expect(result.isError).toBe(true);
+      expect(sentMessages).toHaveLength(0);
+    });
+  });
+
+  // ── Explicit targetClientId — incapable client ───────────────────────
+
+  describe("explicit targetClientId — connected but lacks host_file", () => {
+    test("returns error result immediately without broadcasting", async () => {
+      setup();
+      // Register a client that exists but does not have host_file
+      mockClientRegistry.set("client-no-file", {
+        clientId: "client-no-file",
+        capabilities: ["host_bash"],
+      });
+
+      const result = await proxy.request(
+        {
+          operation: "read",
+          path: "/tmp/test.txt",
+          targetClientId: "client-no-file",
+        },
+        "session-1",
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("client-no-file");
+      expect(result.content).toContain("does not support host_file");
+      expect(sentMessages).toHaveLength(0);
+    });
+  });
+
+  // ── Auto-resolve single capable client ───────────────────────────────
+
+  describe("auto-resolve single capable client", () => {
+    test("resolves target when exactly one host_file-capable client is connected", async () => {
+      setup();
+      setupSingleClient("client-solo");
+
+      const resultPromise = proxy.request(
+        { operation: "read", path: "/tmp/file.txt" },
+        "session-1",
+      );
+
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.targetClientId).toBe("client-solo");
+
+      const opts = sentMessageOptions[0] as Record<string, unknown> | undefined;
+      expect(opts?.targetClientId).toBe("client-solo");
+
+      const requestId = sent.requestId as string;
+      proxy.resolve(requestId, { content: "ok", isError: false });
+
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+    });
+  });
+
+  // ── No target — multiple capable clients ─────────────────────────────
+
+  describe("no explicit target — multiple capable clients", () => {
+    test("broadcasts without targetClientId (untargeted)", async () => {
+      setup();
+      setupMultipleClients(["client-1", "client-2"]);
+
+      const resultPromise = proxy.request(
+        { operation: "read", path: "/tmp/file.txt" },
+        "session-1",
+      );
+
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.type).toBe("host_file_request");
+      expect(sent.targetClientId).toBeUndefined();
+
+      const opts = sentMessageOptions[0] as Record<string, unknown> | undefined;
+      expect(opts?.targetClientId).toBeUndefined();
+
+      const requestId = sent.requestId as string;
+      proxy.resolve(requestId, { content: "ok", isError: false });
+
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+    });
+  });
+
+  // ── targetClientId in cancel (abort signal) ──────────────────────────
+
+  describe("targetClientId in cancel — abort signal", () => {
+    test("cancel broadcast includes targetClientId when request was targeted", async () => {
+      setup();
+      setupSingleClient("client-abc");
+
+      const controller = new AbortController();
+      const resultPromise = proxy.request(
+        { operation: "read", path: "/tmp/file.txt" },
+        "session-1",
+        controller.signal,
+      );
+
+      const sent = sentMessages[0] as Record<string, unknown>;
+      const requestId = sent.requestId as string;
+      expect(sent.targetClientId).toBe("client-abc");
+
+      controller.abort();
+      await resultPromise;
+
+      // Second message is the cancel
+      expect(sentMessages).toHaveLength(2);
+      const cancelMsg = sentMessages[1] as Record<string, unknown>;
+      expect(cancelMsg.type).toBe("host_file_cancel");
+      expect(cancelMsg.requestId).toBe(requestId);
+      expect(cancelMsg.targetClientId).toBe("client-abc");
+
+      const cancelOpts = sentMessageOptions[1] as Record<string, unknown> | undefined;
+      expect(cancelOpts?.targetClientId).toBe("client-abc");
+    });
+  });
+
+  // ── targetClientId in cancel (dispose) ───────────────────────────────
+
+  describe("targetClientId in cancel — dispose", () => {
+    test("dispose cancel broadcast includes targetClientId for targeted request", () => {
+      setup();
+      setupSingleClient("client-xyz");
+
+      const p = proxy.request(
+        { operation: "read", path: "/tmp/file.txt" },
+        "session-1",
+      );
+      p.catch(() => {}); // expected rejection on dispose
+
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.targetClientId).toBe("client-xyz");
+      const requestId = sent.requestId as string;
+
+      proxy.dispose();
+
+      const cancelMessages = sentMessages
+        .slice(1)
+        .filter(
+          (m) => (m as Record<string, unknown>).type === "host_file_cancel",
+        ) as Array<Record<string, unknown>>;
+      expect(cancelMessages).toHaveLength(1);
+      expect(cancelMessages[0].requestId).toBe(requestId);
+      expect(cancelMessages[0].targetClientId).toBe("client-xyz");
+    });
+  });
+
+  // ── Timeout message includes clientId ────────────────────────────────
+
+  describe("timeout message includes clientId", () => {
+    test("timeout resolve message mentions resolvedTargetClientId", async () => {
+      setup();
+      setupSingleClient("client-mac");
+
+      jest.useFakeTimers();
+      try {
+        const resultPromise = proxy.request(
+          { operation: "read", path: "/tmp/slow.txt" },
+          "session-1",
+        );
+
+        const sent = sentMessages[0] as Record<string, unknown>;
+        expect(sent.targetClientId).toBe("client-mac");
+
+        // Advance past the 30s internal timeout
+        jest.advanceTimersByTime(31 * 1000);
+
+        const result = await resultPromise;
+        expect(result.isError).toBe(true);
+        expect(result.content).toContain("client-mac");
+      } finally {
+        jest.useRealTimers();
+      }
+    });
+  });
+});

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

@@ -1,7 +1,6 @@
 import { afterEach, describe, expect, jest, mock, test } from "bun:test";
 
 const sentMessages: unknown[] = [];
-const resolvedInteractionIds: string[] = [];
 let mockHasClient = false;
 
 mock.module("../runtime/assistant-event-hub.js", () => ({
@@ -9,20 +8,16 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   assistantEventHub: {
     getMostRecentClientByCapability: (cap: string) =>
       cap === "host_file" && mockHasClient ? { id: "mock-client" } : null,
+    listClientsByCapability: (cap: string) =>
+      cap === "host_file" && mockHasClient
+        ? [{ clientId: "mock-client", capabilities: ["host_file"] }]
+        : [],
+    getClientById: (_id: string) => undefined,
   },
 }));
 
-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 { HostFileProxy } = await import("../daemon/host-file-proxy.js");
 
 // Minimal PNG header
@@ -36,14 +31,15 @@ describe("HostFileProxy", () => {
 
   function setup() {
     sentMessages.length = 0;
-    resolvedInteractionIds.length = 0;
     mockHasClient = false;
+    pendingInteractions.clear();
     proxy = new (HostFileProxy as any)();
   }
 
   afterEach(() => {
     proxy?.dispose();
     HostFileProxy.reset();
+    pendingInteractions.clear();
   });
 
   describe("request/resolve lifecycle (happy path)", () => {
@@ -68,7 +64,7 @@ describe("HostFileProxy", () => {
       expect(typeof sent.requestId).toBe("string");
 
       const requestId = sent.requestId as string;
-      expect(proxy.hasPendingRequest(requestId)).toBe(true);
+      expect(pendingInteractions.get(requestId)).toBeDefined();
 
       // Simulate client response
       proxy.resolve(requestId, {
@@ -79,7 +75,7 @@ describe("HostFileProxy", () => {
       const result = await resultPromise;
       expect(result.content).toBe("file contents here");
       expect(result.isError).toBe(false);
-      expect(proxy.hasPendingRequest(requestId)).toBe(false);
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
     });
 
     test("resolves error responses correctly", async () => {
@@ -208,7 +204,7 @@ describe("HostFileProxy", () => {
 
       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 (actual 30s timeout too long for test)
       proxy.resolve(requestId, {
@@ -236,14 +232,14 @@ describe("HostFileProxy", () => {
 
       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).toBe("Aborted");
       expect(result.isError).toBe(true);
-      expect(proxy.hasPendingRequest(requestId)).toBe(false);
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
     });
 
     test("sends host_file_cancel to client on abort", async () => {
@@ -321,11 +317,11 @@ describe("HostFileProxy", () => {
 
       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();
       expect(resultPromise).rejects.toThrow("Host file proxy disposed");
     });
 
@@ -389,7 +385,7 @@ describe("HostFileProxy", () => {
         isError: false,
       });
 
-      expect(proxy.hasPendingRequest(requestId)).toBe(false);
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
     });
   });
 
@@ -457,7 +453,10 @@ describe("HostFileProxy", () => {
 
       const requestId = (sentMessages[0] as Record<string, unknown>)
         .requestId as string;
-      proxy.resolve(requestId, { content: "file contents", isError: false });
+      proxy.resolve(requestId, {
+        content: "file contents",
+        isError: false,
+      });
       await resultPromise;
 
       // Listener is detached after normal completion.
@@ -488,7 +487,7 @@ describe("HostFileProxy", () => {
 
         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 30s internal timeout.
         jest.advanceTimersByTime(31 * 1000);
@@ -496,7 +495,7 @@ describe("HostFileProxy", () => {
         const result = await resultPromise;
         expect(result.isError).toBe(true);
         expect(result.content).toContain("Host file 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"]);
@@ -510,8 +509,8 @@ describe("HostFileProxy", () => {
     });
   });
 
-  describe("pendingInteractions.resolve callback", () => {
-    test("fires on abort", async () => {
+  describe("pendingInteractions cleanup", () => {
+    test("cleans up on abort", async () => {
       setup();
 
       const controller = new AbortController();
@@ -526,29 +525,23 @@ describe("HostFileProxy", () => {
 
       const sent = sentMessages[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
+      expect(pendingInteractions.get(requestId)).toBeDefined();
 
       controller.abort();
       await resultPromise;
 
-      expect(resolvedInteractionIds).toContain(requestId);
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
     });
 
-    test("fires for each pending request on dispose", () => {
+    test("cleans up for each pending request on dispose", () => {
       setup();
 
-      // Create two pending requests and catch rejections from dispose
       const p1 = proxy.request(
-        {
-          operation: "read",
-          path: "/tmp/a.txt",
-        },
+        { operation: "read", path: "/tmp/a.txt" },
         "session-1",
       );
       const p2 = proxy.request(
-        {
-          operation: "read",
-          path: "/tmp/b.txt",
-        },
+        { operation: "read", path: "/tmp/b.txt" },
         "session-1",
       );
       p1.catch(() => {}); // Expected rejection on dispose
@@ -558,15 +551,16 @@ describe("HostFileProxy", () => {
         (m) => m.requestId as string,
       );
       expect(ids).toHaveLength(2);
+      expect(pendingInteractions.get(ids[0])).toBeDefined();
+      expect(pendingInteractions.get(ids[1])).toBeDefined();
 
       proxy.dispose();
 
-      expect(resolvedInteractionIds).toHaveLength(2);
-      expect(resolvedInteractionIds).toContain(ids[0]);
-      expect(resolvedInteractionIds).toContain(ids[1]);
+      expect(pendingInteractions.get(ids[0])).toBeUndefined();
+      expect(pendingInteractions.get(ids[1])).toBeUndefined();
     });
 
-    test("does not fire on normal client-initiated resolve", async () => {
+    test("cleans up on normal client-initiated resolveResult", async () => {
       setup();
 
       const resultPromise = proxy.request(
@@ -579,15 +573,15 @@ describe("HostFileProxy", () => {
 
       const sent = sentMessages[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
+      expect(pendingInteractions.get(requestId)).toBeDefined();
 
-      // Normal resolve from client — should NOT trigger pendingInteractions.resolve
       proxy.resolve(requestId, {
         content: "file contents",
         isError: false,
       });
 
       await resultPromise;
-      expect(resolvedInteractionIds).toEqual([]);
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
     });
   });
 });

package/src/__tests__/host-file-read-tool.test.ts

@@ -304,4 +304,21 @@ describe("host_file_read image support", () => {
     expect(result.content).toContain("2  second line");
     expect((result as any).contentBlocks).toBeUndefined();
   });
+
+  test("passes target_client_id to HostFileProxy.instance.request", async () => {
+    const capturedInputs: HostFileInput[] = [];
+    mockFileProxyAvailable = true;
+    mockFileProxyRequestFn = async (input) => {
+      capturedInputs.push(input);
+      return { content: "proxied", isError: false };
+    };
+
+    await hostFileReadTool.execute(
+      { path: "/host/notes.txt", target_client_id: "client-x" },
+      makeContext(),
+    );
+
+    expect(capturedInputs).toHaveLength(1);
+    expect(capturedInputs[0].targetClientId).toBe("client-x");
+  });
 });