@vellumai/assistant 0.7.1 → 0.7.2

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

@@ -0,0 +1,262 @@
+/**
+ * Tests for the host-file-result route 403 guard introduced in Phase 2.
+ *
+ * Covers:
+ *  1. Targeted + correct x-vellum-client-id header → 200 accepted
+ *  2. Targeted + missing header → 400 BadRequestError
+ *  3. Targeted + wrong header → 403 ForbiddenError, interaction NOT consumed
+ *  4. Untargeted (no targetClientId, no header) → 200 accepted (regression)
+ */
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Module mocks ────────────────────────────────────────────────────────────
+
+mock.module("../config/env.js", () => ({
+  isHttpAuthDisabled: () => true,
+  hasUngatedHttpAuthDisabled: () => false,
+}));
+
+import type { PendingInteraction } from "../runtime/pending-interactions.js";
+
+const pendingStore = new Map<string, PendingInteraction>();
+const resolvedIds: string[] = [];
+
+mock.module("../runtime/pending-interactions.js", () => ({
+  get: (requestId: string) => pendingStore.get(requestId),
+  resolve: (requestId: string) => {
+    const entry = pendingStore.get(requestId);
+    if (entry) {
+      pendingStore.delete(requestId);
+      resolvedIds.push(requestId);
+    }
+    return entry;
+  },
+}));
+
+interface FileResolveCall {
+  requestId: string;
+  result: { content: string; isError: boolean; imageData?: string };
+}
+
+const resolveSpy: FileResolveCall[] = [];
+
+mock.module("../daemon/host-file-proxy.js", () => ({
+  HostFileProxy: {
+    get instance() {
+      return {
+        resolve(
+          requestId: string,
+          result: { content: string; isError: boolean; imageData?: string },
+        ) {
+          // Simulate the real resolve: consume the pending interaction
+          const entry = pendingStore.get(requestId);
+          if (entry) {
+            pendingStore.delete(requestId);
+            resolvedIds.push(requestId);
+          }
+          resolveSpy.push({ requestId, result });
+        },
+      };
+    },
+  },
+}));
+
+// ── Real imports (after mocks) ──────────────────────────────────────────────
+
+import {
+  BadRequestError,
+  ForbiddenError,
+} from "../runtime/routes/errors.js";
+import { ROUTES } from "../runtime/routes/host-file-routes.js";
+
+afterAll(() => {
+  mock.restore();
+});
+
+const handleHostFileResult = ROUTES.find(
+  (r) => r.endpoint === "host-file-result",
+)!.handler;
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function registerPending(
+  requestId: string,
+  overrides: Partial<PendingInteraction> = {},
+): void {
+  pendingStore.set(requestId, {
+    conversationId: "conv-1",
+    kind: "host_file",
+    ...overrides,
+  });
+}
+
+function fileBody(requestId: string): Record<string, unknown> {
+  return {
+    requestId,
+    content: "file content",
+    isError: false,
+  };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe("handleHostFileResult — Phase 2 targetClientId guard", () => {
+  beforeEach(() => {
+    pendingStore.clear();
+    resolvedIds.length = 0;
+    resolveSpy.length = 0;
+  });
+
+  // ── 1. Targeted + correct header → 200 ────────────────────────────────────
+
+  describe("targeted + correct x-vellum-client-id header", () => {
+    test("returns { accepted: true } and resolves the interaction", async () => {
+      const requestId = "req-file-targeted-match";
+      registerPending(requestId, { targetClientId: "client-A" });
+
+      const result = await handleHostFileResult({
+        body: fileBody(requestId),
+        headers: { "x-vellum-client-id": "client-A" },
+      });
+
+      expect(result).toEqual({ accepted: true });
+      expect(resolveSpy).toHaveLength(1);
+      expect(resolveSpy[0].requestId).toBe(requestId);
+      expect(resolvedIds).toContain(requestId);
+    });
+
+    test("trims whitespace from header before comparing", async () => {
+      const requestId = "req-file-targeted-trim";
+      registerPending(requestId, { targetClientId: "client-A" });
+
+      const result = await handleHostFileResult({
+        body: fileBody(requestId),
+        headers: { "x-vellum-client-id": "  client-A  " },
+      });
+
+      expect(result).toEqual({ accepted: true });
+    });
+  });
+
+  // ── 2. Targeted + missing header → 400 ────────────────────────────────────
+
+  describe("targeted + missing x-vellum-client-id header", () => {
+    test("throws BadRequestError (400) when header is absent", () => {
+      const requestId = "req-file-targeted-no-header";
+      registerPending(requestId, { targetClientId: "client-A" });
+
+      expect(() =>
+        handleHostFileResult({ body: fileBody(requestId) }),
+      ).toThrow(BadRequestError);
+    });
+
+    test("throws BadRequestError (400) when header is empty string", () => {
+      const requestId = "req-file-targeted-empty-header";
+      registerPending(requestId, { targetClientId: "client-A" });
+
+      expect(() =>
+        handleHostFileResult({
+          body: fileBody(requestId),
+          headers: { "x-vellum-client-id": "   " },
+        }),
+      ).toThrow(BadRequestError);
+    });
+
+    test("interaction is NOT resolved on 400 (still pending)", () => {
+      const requestId = "req-file-targeted-no-header-stays";
+      registerPending(requestId, { targetClientId: "client-A" });
+
+      try {
+        handleHostFileResult({ body: fileBody(requestId) });
+      } catch {
+        // expected
+      }
+
+      expect(resolvedIds).not.toContain(requestId);
+      expect(pendingStore.has(requestId)).toBe(true);
+    });
+  });
+
+  // ── 3. Targeted + wrong header → 403 ──────────────────────────────────────
+
+  describe("targeted + wrong x-vellum-client-id header", () => {
+    test("throws ForbiddenError (403) when client ID does not match", () => {
+      const requestId = "req-file-targeted-mismatch";
+      registerPending(requestId, { targetClientId: "client-A" });
+
+      expect(() =>
+        handleHostFileResult({
+          body: fileBody(requestId),
+          headers: { "x-vellum-client-id": "client-B" },
+        }),
+      ).toThrow(ForbiddenError);
+    });
+
+    test("ForbiddenError message names both submitting and expected client", () => {
+      const requestId = "req-file-targeted-mismatch-msg";
+      registerPending(requestId, { targetClientId: "client-A" });
+
+      let caught: unknown;
+      try {
+        handleHostFileResult({
+          body: fileBody(requestId),
+          headers: { "x-vellum-client-id": "client-B" },
+        });
+      } catch (e) {
+        caught = e;
+      }
+
+      expect(caught).toBeInstanceOf(ForbiddenError);
+      const msg = (caught as ForbiddenError).message;
+      expect(msg).toContain("client-B");
+      expect(msg).toContain("client-A");
+    });
+
+    test("interaction is NOT consumed on 403 (pendingInteractions.get still returns it)", () => {
+      const requestId = "req-file-targeted-mismatch-stays";
+      registerPending(requestId, { targetClientId: "client-A" });
+
+      try {
+        handleHostFileResult({
+          body: fileBody(requestId),
+          headers: { "x-vellum-client-id": "client-B" },
+        });
+      } catch {
+        // expected
+      }
+
+      expect(resolvedIds).not.toContain(requestId);
+      expect(pendingStore.has(requestId)).toBe(true);
+    });
+  });
+
+  // ── 4. Untargeted — regression ────────────────────────────────────────────
+
+  describe("untargeted request (no targetClientId)", () => {
+    test("accepts when no header is provided", async () => {
+      const requestId = "req-file-untargeted-no-header";
+      registerPending(requestId);
+
+      const result = await handleHostFileResult({
+        body: fileBody(requestId),
+      });
+
+      expect(result).toEqual({ accepted: true });
+      expect(resolveSpy).toHaveLength(1);
+      expect(resolvedIds).toContain(requestId);
+    });
+
+    test("accepts when header is present (header ignored for untargeted)", async () => {
+      const requestId = "req-file-untargeted-with-header";
+      registerPending(requestId);
+
+      const result = await handleHostFileResult({
+        body: fileBody(requestId),
+        headers: { "x-vellum-client-id": "client-whatever" },
+      });
+
+      expect(result).toEqual({ accepted: true });
+      expect(resolveSpy).toHaveLength(1);
+    });
+  });
+});

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

@@ -1,7 +1,29 @@
 import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterEach, describe, expect, test } from "bun:test";
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+import type { HostFileInput } from "../daemon/host-file-proxy.js";
+import type { ToolExecutionResult } from "../tools/types.js";
+
+// Mock HostFileProxy singleton so proxy delegation tests can control it.
+let mockFileProxyAvailable = false;
+let mockFileProxyRequestFn: (
+  input: HostFileInput,
+  conversationId: string,
+  signal?: AbortSignal,
+) => Promise<ToolExecutionResult> = () => Promise.resolve({ content: "", isError: false });
+
+mock.module("../daemon/host-file-proxy.js", () => ({
+  HostFileProxy: {
+    get instance() {
+      return {
+        isAvailable: () => mockFileProxyAvailable,
+        request: mockFileProxyRequestFn,
+      };
+    },
+  },
+}));
 
 import { hostFileWriteTool } from "../tools/host-filesystem/write.js";
 import type { ToolContext } from "../tools/types.js";
@@ -20,6 +42,8 @@ afterEach(() => {
   for (const dir of testDirs.splice(0)) {
     rmSync(dir, { recursive: true, force: true });
   }
+  mockFileProxyAvailable = false;
+  mockFileProxyRequestFn = () => Promise.resolve({ content: "", isError: false });
 });
 
 describe("host_file_write tool", () => {
@@ -168,4 +192,21 @@ describe("host_file_write tool", () => {
     expect(existsSync(filePath)).toBe(true);
     expect(readFileSync(filePath, "utf-8")).toBe("deep");
   });
+
+  test("passes target_client_id to HostFileProxy.instance.request", async () => {
+    const capturedInputs: HostFileInput[] = [];
+    mockFileProxyAvailable = true;
+    mockFileProxyRequestFn = async (input) => {
+      capturedInputs.push(input);
+      return { content: "proxied write", isError: false };
+    };
+
+    await hostFileWriteTool.execute(
+      { path: "/host/output.txt", content: "hello", target_client_id: "client-x" },
+      makeContext(),
+    );
+
+    expect(capturedInputs).toHaveLength(1);
+    expect(capturedInputs[0].targetClientId).toBe("client-x");
+  });
 });

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

@@ -0,0 +1,312 @@
+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", () => ({
+  broadcastMessage: (msg: unknown) => sentMessages.push(msg),
+  assistantEventHub: {
+    getMostRecentClientByCapability: (cap: string) =>
+      cap === "host_cu" && mockHasClient ? { id: "mock-client" } : null,
+  },
+}));
+
+mock.module("../runtime/pending-interactions.js", () => ({
+  register: () => undefined,
+  resolve: (requestId: string) => {
+    resolvedInteractionIds.push(requestId);
+    return undefined;
+  },
+  get: () => undefined,
+  getByKind: () => [],
+  getByConversation: () => [],
+  removeByConversation: () => {},
+}));
+
+const { HostProxyBase, HostProxyRequestError } =
+  await import("../daemon/host-proxy-base.js");
+
+interface TestRequest {
+  payload: string;
+}
+
+interface TestResultPayload {
+  result: string;
+}
+
+class TestProxy extends HostProxyBase<TestRequest, TestResultPayload> {
+  constructor(timeoutMs?: number) {
+    super({
+      capabilityName: "host_cu",
+      requestEventName: "test_request",
+      cancelEventName: "test_cancel",
+      resultPendingKind: "host_cu",
+      timeoutMs,
+      disposedMessage: "Test proxy disposed",
+    });
+  }
+
+  // Re-expose the protected `dispatchRequest` so the tests can drive it directly.
+  send(
+    toolName: string,
+    input: TestRequest,
+    conversationId: string,
+    signal?: AbortSignal,
+    extraFields?: Record<string, unknown>,
+  ): Promise<TestResultPayload> {
+    return this.dispatchRequest(
+      toolName,
+      input,
+      conversationId,
+      signal,
+      extraFields,
+    );
+  }
+}
+
+describe("HostProxyBase", () => {
+  let proxy: TestProxy;
+
+  function setup(timeoutMs?: number) {
+    sentMessages.length = 0;
+    resolvedInteractionIds.length = 0;
+    mockHasClient = false;
+    proxy = new TestProxy(timeoutMs);
+  }
+
+  afterEach(() => {
+    proxy?.dispose();
+  });
+
+  describe("request lifecycle", () => {
+    test("broadcasts the configured envelope and resolves on resolve()", async () => {
+      setup();
+
+      const promise = proxy.send("tool-1", { payload: "hello" }, "conv-1");
+
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.type).toBe("test_request");
+      expect(sent.conversationId).toBe("conv-1");
+      expect(sent.toolName).toBe("tool-1");
+      expect(sent.input).toEqual({ payload: "hello" });
+      expect(typeof sent.requestId).toBe("string");
+
+      const requestId = sent.requestId as string;
+      expect(proxy.hasPendingRequest(requestId)).toBe(true);
+
+      proxy.resolve(requestId, { result: "ok" });
+
+      await expect(promise).resolves.toEqual({ result: "ok" });
+      expect(proxy.hasPendingRequest(requestId)).toBe(false);
+    });
+
+    test("merges extraFields into the broadcast envelope", async () => {
+      setup();
+
+      const promise = proxy.send(
+        "tool-1",
+        { payload: "hi" },
+        "conv-1",
+        undefined,
+        { stepNumber: 7, reasoning: "because" },
+      );
+
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.stepNumber).toBe(7);
+      expect(sent.reasoning).toBe("because");
+      expect(sent.input).toEqual({ payload: "hi" }); // input not nested under extras
+
+      // Resolve so afterEach.dispose() doesn't see an orphan pending request.
+      proxy.resolve(sent.requestId as string, { result: "ok" });
+      await promise;
+    });
+
+    test("resolve with unknown requestId is silently ignored", () => {
+      setup();
+      // Should not throw
+      proxy.resolve("unknown-id", { result: "late" });
+    });
+  });
+
+  describe("timeout", () => {
+    test("rejects with HostProxyRequestError(reason='timeout') after timeoutMs", async () => {
+      setup();
+
+      jest.useFakeTimers();
+      try {
+        const promise = proxy.send("tool-1", { payload: "x" }, "conv-1");
+        const requestId = (sentMessages[0] as Record<string, unknown>)
+          .requestId as string;
+        expect(proxy.hasPendingRequest(requestId)).toBe(true);
+
+        // Default timeout is 60s.
+        jest.advanceTimersByTime(61 * 1000);
+
+        await expect(promise).rejects.toBeInstanceOf(HostProxyRequestError);
+        await expect(promise).rejects.toMatchObject({ reason: "timeout" });
+        expect(proxy.hasPendingRequest(requestId)).toBe(false);
+        expect(resolvedInteractionIds).toContain(requestId);
+      } finally {
+        jest.useRealTimers();
+      }
+    });
+
+    test("respects custom timeoutMs", async () => {
+      setup(10);
+
+      jest.useFakeTimers();
+      try {
+        const promise = proxy.send("tool-1", { payload: "x" }, "conv-1");
+        jest.advanceTimersByTime(11);
+
+        await expect(promise).rejects.toMatchObject({ reason: "timeout" });
+      } finally {
+        jest.useRealTimers();
+      }
+    });
+  });
+
+  describe("abort signal", () => {
+    test("broadcasts cancel envelope and rejects with reason='aborted'", async () => {
+      setup();
+
+      const controller = new AbortController();
+      const promise = proxy.send(
+        "tool-1",
+        { payload: "x" },
+        "conv-1",
+        controller.signal,
+      );
+
+      const requestId = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+
+      controller.abort();
+
+      await expect(promise).rejects.toMatchObject({ reason: "aborted" });
+
+      // Second message should be the cancel envelope.
+      expect(sentMessages).toHaveLength(2);
+      const cancel = sentMessages[1] as Record<string, unknown>;
+      expect(cancel.type).toBe("test_cancel");
+      expect(cancel.requestId).toBe(requestId);
+      expect(cancel.conversationId).toBe("conv-1");
+
+      expect(proxy.hasPendingRequest(requestId)).toBe(false);
+      expect(resolvedInteractionIds).toContain(requestId);
+    });
+
+    test("removes abort listener after normal resolve", async () => {
+      setup();
+
+      const controller = new AbortController();
+      const removeCalls: string[] = [];
+      const origRemove = controller.signal.removeEventListener.bind(
+        controller.signal,
+      );
+      (controller.signal as any).removeEventListener = (
+        type: string,
+        ...rest: any[]
+      ) => {
+        removeCalls.push(type);
+        return (origRemove as any)(type, ...rest);
+      };
+
+      const promise = proxy.send(
+        "tool-1",
+        { payload: "x" },
+        "conv-1",
+        controller.signal,
+      );
+
+      const requestId = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+      proxy.resolve(requestId, { result: "ok" });
+      await promise;
+
+      expect(removeCalls).toEqual(["abort"]);
+
+      // Late aborts must be no-ops with no extra envelopes emitted.
+      controller.abort();
+      expect(sentMessages).toHaveLength(1);
+    });
+  });
+
+  describe("dispose", () => {
+    test("rejects all pending requests with reason='disposed'", async () => {
+      setup();
+
+      const p1 = proxy.send("t1", { payload: "1" }, "conv-1");
+      const p2 = proxy.send("t2", { payload: "2" }, "conv-1");
+
+      // Suppress unhandled rejection noise — we assert below.
+      p1.catch(() => {});
+      p2.catch(() => {});
+
+      const beforeIds = (sentMessages as Array<Record<string, unknown>>).map(
+        (m) => m.requestId as string,
+      );
+      expect(beforeIds).toHaveLength(2);
+
+      proxy.dispose();
+
+      await expect(p1).rejects.toBeInstanceOf(HostProxyRequestError);
+      await expect(p1).rejects.toMatchObject({
+        reason: "disposed",
+        message: "Test proxy disposed",
+      });
+      await expect(p2).rejects.toMatchObject({ reason: "disposed" });
+
+      // Cancel envelopes broadcast for each pending request.
+      const cancelMessages = sentMessages
+        .slice(2)
+        .filter(
+          (m) => (m as Record<string, unknown>).type === "test_cancel",
+        ) as Array<Record<string, unknown>>;
+      expect(cancelMessages).toHaveLength(2);
+      const cancelIds = cancelMessages.map((m) => m.requestId as string);
+      expect(cancelIds).toEqual(expect.arrayContaining(beforeIds));
+
+      // pendingInteractions notified for each pending request.
+      for (const id of beforeIds) {
+        expect(resolvedInteractionIds).toContain(id);
+      }
+    });
+
+    test("clears all timers on dispose", async () => {
+      setup();
+
+      jest.useFakeTimers();
+      try {
+        const p = proxy.send("t1", { payload: "1" }, "conv-1");
+        p.catch(() => {});
+
+        proxy.dispose();
+
+        // Advance well past the default timeout — no extra rejection or log
+        // should fire because the timer was cleared.
+        jest.advanceTimersByTime(120 * 1000);
+
+        await expect(p).rejects.toMatchObject({ reason: "disposed" });
+      } finally {
+        jest.useRealTimers();
+      }
+    });
+  });
+
+  describe("isAvailable", () => {
+    test("returns false when no client with the configured capability is connected", () => {
+      setup();
+      mockHasClient = false;
+      expect(proxy.isAvailable()).toBe(false);
+    });
+
+    test("returns true when a client with the configured capability is connected", () => {
+      setup();
+      mockHasClient = true;
+      expect(proxy.isAvailable()).toBe(true);
+    });
+  });
+});

package/src/__tests__/host-shell-tool.test.ts

@@ -40,7 +40,6 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
   loadConfig: () => mockConfig,
   invalidateConfigCache: () => {},
-  saveConfig: () => {},
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
   getNestedValue: () => undefined,
@@ -57,10 +56,11 @@ mock.module("../util/logger.js", () => ({
 // Mock the host-bash-proxy singleton so proxy delegation tests can control it.
 let mockProxyAvailable = false;
 let mockProxyRequestFn: (
-  input: { command: string; working_dir?: string; timeout_seconds?: number; env?: Record<string, string> },
+  input: { command: string; working_dir?: string; timeout_seconds?: number; env?: Record<string, string>; targetClientId?: string },
   conversationId: string,
   signal?: AbortSignal,
-) => Promise<ToolExecutionResult> = () => Promise.resolve({ content: "", isError: false });
+) => Promise<ToolExecutionResult> = () =>
+  Promise.resolve({ content: "", isError: false });
 
 mock.module("../daemon/host-bash-proxy.js", () => ({
   HostBashProxy: {
@@ -276,12 +276,13 @@ describe("host_bash — regression: no proxied-mode additions", () => {
     expect(schemaProps).not.toHaveProperty("credential_ids");
   });
 
-  test("schema only contains the expected properties (command, working_dir, timeout_seconds, activity, background)", () => {
+  test("schema only contains the expected properties (command, working_dir, timeout_seconds, activity, background, target_client_id)", () => {
     const propertyNames = Object.keys(schemaProps).sort();
     expect(propertyNames).toEqual([
       "activity",
       "background",
       "command",
+      "target_client_id",
       "timeout_seconds",
       "working_dir",
     ]);
@@ -727,6 +728,7 @@ describe("host_bash — proxy delegation", () => {
         working_dir?: string;
         timeout_seconds?: number;
         env?: Record<string, string>;
+        targetClientId?: string;
       };
       conversationId: string;
     }> = [];
@@ -828,6 +830,22 @@ describe("host_bash — proxy delegation", () => {
     expect(spawnCalls.length).toBe(1);
   });
 
+  test("returns error when explicit targetClientId is set but proxy is unavailable (client disconnected)", async () => {
+    // mockProxyAvailable defaults to false — simulates client disconnecting
+    // after tool definitions were built (targetClientId already resolved).
+    spawnCalls.length = 0;
+    const result = await hostShellTool.execute(
+      { command: "echo should-not-run", target_client_id: "client-mac-abc123" },
+      { ...makeContext(), transportInterface: "web" },
+    );
+
+    // Must error, NOT fall through to local spawn
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("client-mac-abc123");
+    expect(result.content).toContain("no longer connected");
+    expect(spawnCalls.length).toBe(0);
+  });
+
   test("falls back to local execution when no proxy is set", async () => {
     const dir = mkdtempSync(join(tmpdir(), "host-shell-no-proxy-"));
     testDirs.push(dir);