@vellumai/assistant 0.7.1 → 0.7.3

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

@@ -0,0 +1,378 @@
+/**
+ * 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;
+type MockClient = {
+  clientId: string;
+  capabilities: string[];
+  actorPrincipalId?: string;
+};
+let mockCapableClients: Array<MockClient> = [];
+let mockClientRegistry: Map<string, MockClient> = new Map();
+
+// Pre-existing Phase 2 routing tests use a single user identity. The same-user
+// check added in PR 3 is exercised separately in `host-file-proxy.test.ts`.
+const TEST_PRINCIPAL = "test-user";
+
+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),
+    getActorPrincipalIdForClient: (clientId: string) =>
+      mockClientRegistry.get(clientId)?.actorPrincipalId,
+  },
+}));
+
+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: MockClient = {
+      clientId,
+      capabilities: ["host_file"],
+      actorPrincipalId: TEST_PRINCIPAL,
+    };
+    mockCapableClients = [entry];
+    mockClientRegistry.set(clientId, entry);
+  }
+
+  function setupMultipleClients(clientIds: string[]) {
+    mockCapableClients = clientIds.map((id) => ({
+      clientId: id,
+      capabilities: ["host_file"],
+      actorPrincipalId: TEST_PRINCIPAL,
+    }));
+    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",
+        undefined,
+        undefined,
+        TEST_PRINCIPAL,
+      );
+
+      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",
+        undefined,
+        undefined,
+        TEST_PRINCIPAL,
+      );
+
+      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,
+        undefined,
+        TEST_PRINCIPAL,
+      );
+
+      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",
+        undefined,
+        undefined,
+        TEST_PRINCIPAL,
+      );
+      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",
+          undefined,
+          undefined,
+          TEST_PRINCIPAL,
+        );
+
+        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();
+      }
+    });
+  });
+});