@vellumai/assistant 0.7.2 → 0.7.3

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

@@ -47,11 +47,24 @@ mock.module("../daemon/host-transfer-proxy.js", () => ({
         getTargetClientIdForTransfer(_transferId: string) {
           return stubTargetClientId;
         },
+        getTargetActorPrincipalIdForTransfer(_transferId: string) {
+          return stubTargetClientId
+            ? clientActors.get(stubTargetClientId)
+            : undefined;
+        },
         getTransferContent(transferId: string) {
           getTransferContentCalls.push(transferId);
-          return { buffer: Buffer.from("data"), sizeBytes: 4, sha256: "abc123" };
+          return {
+            buffer: Buffer.from("data"),
+            sizeBytes: 4,
+            sha256: "abc123",
+          };
         },
-        async receiveTransferContent(transferId: string, _data: Buffer, _sha256: string) {
+        async receiveTransferContent(
+          transferId: string,
+          _data: Buffer,
+          _sha256: string,
+        ) {
           receiveTransferContentCalls.push(transferId);
           return { accepted: true };
         },
@@ -63,12 +76,20 @@ mock.module("../daemon/host-transfer-proxy.js", () => ({
   },
 }));
 
+// Stub event hub so tests control what actorPrincipalId is associated with
+// each connected client.
+const clientActors = new Map<string, string>();
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  assistantEventHub: {
+    getActorPrincipalIdForClient: (clientId: string) =>
+      clientActors.get(clientId),
+  },
+}));
+
 // ── Real imports (after mocks) ──────────────────────────────────────────────
 
-import {
-  BadRequestError,
-  ForbiddenError,
-} from "../runtime/routes/errors.js";
+import { BadRequestError, ForbiddenError } from "../runtime/routes/errors.js";
 import { ROUTES } from "../runtime/routes/host-transfer-routes.js";
 
 afterAll(() => {
@@ -93,10 +114,19 @@ const TEST_TRANSFER_ID = "transfer-abc";
 const TEST_REQUEST_ID = "req-1";
 
 function registerPending(overrides: Partial<PendingInteraction> = {}): void {
+  // Mirror the production proxy: capture the target's actor principal at
+  // registration time so the result-route check compares against a stable
+  // value rather than the live hub.
+  const targetActorPrincipalId =
+    overrides.targetActorPrincipalId ??
+    (overrides.targetClientId
+      ? clientActors.get(overrides.targetClientId)
+      : undefined);
   pendingStore.set(TEST_REQUEST_ID, {
     conversationId: "conv-1",
     kind: "host_transfer",
     ...overrides,
+    targetActorPrincipalId,
   });
 }
 
@@ -107,6 +137,7 @@ describe("handleTransferContentGet — Phase 3 targetClientId guard", () => {
     pendingStore.clear();
     stubTargetClientId = null;
     getTransferContentCalls.length = 0;
+    clientActors.clear();
   });
 
   // ── 1. Targeted + correct header → success ────────────────────────────────
@@ -114,9 +145,13 @@ describe("handleTransferContentGet — Phase 3 targetClientId guard", () => {
   describe("targeted + correct x-vellum-client-id header", () => {
     test("returns Uint8Array and calls getTransferContent", async () => {
       stubTargetClientId = "client-A";
+      clientActors.set("client-A", "actor-1");
       const result = await handleTransferContentGet({
         pathParams: { transferId: TEST_TRANSFER_ID },
-        headers: { "x-vellum-client-id": "client-A" },
+        headers: {
+          "x-vellum-client-id": "client-A",
+          "x-vellum-actor-principal-id": "actor-1",
+        },
       });
 
       expect(result).toBeInstanceOf(Uint8Array);
@@ -125,9 +160,13 @@ describe("handleTransferContentGet — Phase 3 targetClientId guard", () => {
 
     test("trims whitespace from header before comparing", async () => {
       stubTargetClientId = "client-A";
+      clientActors.set("client-A", "actor-1");
       const result = await handleTransferContentGet({
         pathParams: { transferId: TEST_TRANSFER_ID },
-        headers: { "x-vellum-client-id": "  client-A  " },
+        headers: {
+          "x-vellum-client-id": "  client-A  ",
+          "x-vellum-actor-principal-id": "  actor-1  ",
+        },
       });
 
       expect(result).toBeInstanceOf(Uint8Array);
@@ -199,6 +238,52 @@ describe("handleTransferContentGet — Phase 3 targetClientId guard", () => {
       expect(getTransferContentCalls).toContain(TEST_TRANSFER_ID);
     });
   });
+
+  // ── 5. Same-user actor binding (defense-in-depth) ─────────────────────────
+
+  describe("targeted + actor principal binding", () => {
+    test("throws ForbiddenError when submitting actor does not match target client's actor", () => {
+      stubTargetClientId = "client-A";
+      clientActors.set("client-A", "actor-victim");
+      expect(() =>
+        handleTransferContentGet({
+          pathParams: { transferId: TEST_TRANSFER_ID },
+          headers: {
+            "x-vellum-client-id": "client-A",
+            "x-vellum-actor-principal-id": "actor-attacker",
+          },
+        }),
+      ).toThrow(ForbiddenError);
+      expect(getTransferContentCalls).toHaveLength(0);
+    });
+
+    test("throws ForbiddenError when actor principal header is missing", () => {
+      stubTargetClientId = "client-A";
+      clientActors.set("client-A", "actor-victim");
+      expect(() =>
+        handleTransferContentGet({
+          pathParams: { transferId: TEST_TRANSFER_ID },
+          headers: { "x-vellum-client-id": "client-A" },
+        }),
+      ).toThrow(ForbiddenError);
+      expect(getTransferContentCalls).toHaveLength(0);
+    });
+
+    test("throws ForbiddenError when target client has no stored actor", () => {
+      stubTargetClientId = "client-A";
+      // No entry in clientActors for "client-A"
+      expect(() =>
+        handleTransferContentGet({
+          pathParams: { transferId: TEST_TRANSFER_ID },
+          headers: {
+            "x-vellum-client-id": "client-A",
+            "x-vellum-actor-principal-id": "actor-1",
+          },
+        }),
+      ).toThrow(ForbiddenError);
+      expect(getTransferContentCalls).toHaveLength(0);
+    });
+  });
 });
 
 describe("handleTransferContentPut — Phase 3 targetClientId guard", () => {
@@ -206,6 +291,7 @@ describe("handleTransferContentPut — Phase 3 targetClientId guard", () => {
     pendingStore.clear();
     stubTargetClientId = null;
     receiveTransferContentCalls.length = 0;
+    clientActors.clear();
   });
 
   // ── 1. Targeted + correct header → success ────────────────────────────────
@@ -213,9 +299,14 @@ describe("handleTransferContentPut — Phase 3 targetClientId guard", () => {
   describe("targeted + correct x-vellum-client-id header", () => {
     test("returns { accepted: true } and calls receiveTransferContent", async () => {
       stubTargetClientId = "client-A";
+      clientActors.set("client-A", "actor-1");
       const result = await handleTransferContentPut({
         pathParams: { transferId: TEST_TRANSFER_ID },
-        headers: { "x-vellum-client-id": "client-A", "x-transfer-sha256": "abc" },
+        headers: {
+          "x-vellum-client-id": "client-A",
+          "x-vellum-actor-principal-id": "actor-1",
+          "x-transfer-sha256": "abc",
+        },
         rawBody: new Uint8Array(Buffer.from("data")),
       });
 
@@ -225,9 +316,14 @@ describe("handleTransferContentPut — Phase 3 targetClientId guard", () => {
 
     test("trims whitespace from header before comparing", async () => {
       stubTargetClientId = "client-A";
+      clientActors.set("client-A", "actor-1");
       const result = await handleTransferContentPut({
         pathParams: { transferId: TEST_TRANSFER_ID },
-        headers: { "x-vellum-client-id": "  client-A  ", "x-transfer-sha256": "abc" },
+        headers: {
+          "x-vellum-client-id": "  client-A  ",
+          "x-vellum-actor-principal-id": "  actor-1  ",
+          "x-transfer-sha256": "abc",
+        },
         rawBody: new Uint8Array(Buffer.from("data")),
       });
 
@@ -272,7 +368,10 @@ describe("handleTransferContentPut — Phase 3 targetClientId guard", () => {
       await expect(
         handleTransferContentPut({
           pathParams: { transferId: TEST_TRANSFER_ID },
-          headers: { "x-vellum-client-id": "client-B", "x-transfer-sha256": "abc" },
+          headers: {
+            "x-vellum-client-id": "client-B",
+            "x-transfer-sha256": "abc",
+          },
           rawBody: new Uint8Array(Buffer.from("data")),
         }),
       ).rejects.toBeInstanceOf(ForbiddenError);
@@ -283,7 +382,10 @@ describe("handleTransferContentPut — Phase 3 targetClientId guard", () => {
       try {
         await handleTransferContentPut({
           pathParams: { transferId: TEST_TRANSFER_ID },
-          headers: { "x-vellum-client-id": "client-B", "x-transfer-sha256": "abc" },
+          headers: {
+            "x-vellum-client-id": "client-B",
+            "x-transfer-sha256": "abc",
+          },
           rawBody: new Uint8Array(Buffer.from("data")),
         });
       } catch {
@@ -308,6 +410,60 @@ describe("handleTransferContentPut — Phase 3 targetClientId guard", () => {
       expect(receiveTransferContentCalls).toContain(TEST_TRANSFER_ID);
     });
   });
+
+  // ── 5. Same-user actor binding (defense-in-depth) ─────────────────────────
+
+  describe("targeted + actor principal binding", () => {
+    test("rejects when submitting actor does not match target client's actor", async () => {
+      stubTargetClientId = "client-A";
+      clientActors.set("client-A", "actor-victim");
+      await expect(
+        handleTransferContentPut({
+          pathParams: { transferId: TEST_TRANSFER_ID },
+          headers: {
+            "x-vellum-client-id": "client-A",
+            "x-vellum-actor-principal-id": "actor-attacker",
+            "x-transfer-sha256": "abc",
+          },
+          rawBody: new Uint8Array(Buffer.from("data")),
+        }),
+      ).rejects.toBeInstanceOf(ForbiddenError);
+      expect(receiveTransferContentCalls).toHaveLength(0);
+    });
+
+    test("rejects when actor principal header is missing", async () => {
+      stubTargetClientId = "client-A";
+      clientActors.set("client-A", "actor-victim");
+      await expect(
+        handleTransferContentPut({
+          pathParams: { transferId: TEST_TRANSFER_ID },
+          headers: {
+            "x-vellum-client-id": "client-A",
+            "x-transfer-sha256": "abc",
+          },
+          rawBody: new Uint8Array(Buffer.from("data")),
+        }),
+      ).rejects.toBeInstanceOf(ForbiddenError);
+      expect(receiveTransferContentCalls).toHaveLength(0);
+    });
+
+    test("rejects when target client has no stored actor", async () => {
+      stubTargetClientId = "client-A";
+      // No entry in clientActors for "client-A"
+      await expect(
+        handleTransferContentPut({
+          pathParams: { transferId: TEST_TRANSFER_ID },
+          headers: {
+            "x-vellum-client-id": "client-A",
+            "x-vellum-actor-principal-id": "actor-1",
+            "x-transfer-sha256": "abc",
+          },
+          rawBody: new Uint8Array(Buffer.from("data")),
+        }),
+      ).rejects.toBeInstanceOf(ForbiddenError);
+      expect(receiveTransferContentCalls).toHaveLength(0);
+    });
+  });
 });
 
 describe("handleTransferResult — Phase 3 targetClientId guard", () => {
@@ -315,6 +471,7 @@ describe("handleTransferResult — Phase 3 targetClientId guard", () => {
     pendingStore.clear();
     stubTargetClientId = null;
     resolveTransferResultCalls.length = 0;
+    clientActors.clear();
   });
 
   function registerHostTransferPending(targetClientId?: string): void {
@@ -329,10 +486,14 @@ describe("handleTransferResult — Phase 3 targetClientId guard", () => {
 
   describe("targeted + correct x-vellum-client-id header", () => {
     test("returns { accepted: true } and calls resolveTransferResult", async () => {
+      clientActors.set("client-A", "actor-1");
       registerHostTransferPending("client-A");
       const result = await handleTransferResult({
         body: resultBody(),
-        headers: { "x-vellum-client-id": "client-A" },
+        headers: {
+          "x-vellum-client-id": "client-A",
+          "x-vellum-actor-principal-id": "actor-1",
+        },
       });
 
       expect(result).toEqual({ accepted: true });
@@ -340,10 +501,14 @@ describe("handleTransferResult — Phase 3 targetClientId guard", () => {
     });
 
     test("trims whitespace from header before comparing", async () => {
+      clientActors.set("client-A", "actor-1");
       registerHostTransferPending("client-A");
       const result = await handleTransferResult({
         body: resultBody(),
-        headers: { "x-vellum-client-id": "  client-A  " },
+        headers: {
+          "x-vellum-client-id": "  client-A  ",
+          "x-vellum-actor-principal-id": "  actor-1  ",
+        },
       });
 
       expect(result).toEqual({ accepted: true });
@@ -355,9 +520,9 @@ describe("handleTransferResult — Phase 3 targetClientId guard", () => {
   describe("targeted + missing x-vellum-client-id header", () => {
     test("throws BadRequestError when header is absent", () => {
       registerHostTransferPending("client-A");
-      expect(() =>
-        handleTransferResult({ body: resultBody() }),
-      ).toThrow(BadRequestError);
+      expect(() => handleTransferResult({ body: resultBody() })).toThrow(
+        BadRequestError,
+      );
     });
 
     test("resolveTransferResult NOT called on 400", () => {
@@ -444,4 +609,54 @@ describe("handleTransferResult — Phase 3 targetClientId guard", () => {
       expect(result).toEqual({ accepted: true });
     });
   });
+
+  // ── 5. Same-user actor binding (defense-in-depth) ─────────────────────────
+
+  describe("targeted + actor principal binding", () => {
+    test("throws ForbiddenError when submitting actor does not match target client's actor", () => {
+      registerHostTransferPending("client-A");
+      clientActors.set("client-A", "actor-victim");
+      expect(() =>
+        handleTransferResult({
+          body: resultBody(),
+          headers: {
+            "x-vellum-client-id": "client-A",
+            "x-vellum-actor-principal-id": "actor-attacker",
+          },
+        }),
+      ).toThrow(ForbiddenError);
+      expect(resolveTransferResultCalls).toHaveLength(0);
+      // Pending interaction should still be present (not consumed on 403).
+      expect(pendingStore.has(TEST_REQUEST_ID)).toBe(true);
+    });
+
+    test("throws ForbiddenError when actor principal header is missing", () => {
+      registerHostTransferPending("client-A");
+      clientActors.set("client-A", "actor-victim");
+      expect(() =>
+        handleTransferResult({
+          body: resultBody(),
+          headers: { "x-vellum-client-id": "client-A" },
+        }),
+      ).toThrow(ForbiddenError);
+      expect(resolveTransferResultCalls).toHaveLength(0);
+      expect(pendingStore.has(TEST_REQUEST_ID)).toBe(true);
+    });
+
+    test("throws ForbiddenError when target client has no stored actor", () => {
+      registerHostTransferPending("client-A");
+      // No entry in clientActors for "client-A"
+      expect(() =>
+        handleTransferResult({
+          body: resultBody(),
+          headers: {
+            "x-vellum-client-id": "client-A",
+            "x-vellum-actor-principal-id": "actor-1",
+          },
+        }),
+      ).toThrow(ForbiddenError);
+      expect(resolveTransferResultCalls).toHaveLength(0);
+      expect(pendingStore.has(TEST_REQUEST_ID)).toBe(true);
+    });
+  });
 });

package/src/__tests__/http-user-message-parity.test.ts

@@ -252,12 +252,24 @@ async function sendMessage(
   content: string,
   conversationObj: import("../daemon/conversation.js").Conversation,
   extra: Record<string, unknown> = {},
+  options: {
+    onGetOrCreateConversation?: (
+      conversationId: string,
+      opts?: Record<string, unknown>,
+    ) => void;
+  } = {},
 ) {
   return callHandler(
     (args) =>
       handleSendMessage(args, {
         sendMessageDeps: {
-          getOrCreateConversation: async () => conversationObj,
+          getOrCreateConversation: async (conversationId, opts) => {
+            options.onGetOrCreateConversation?.(
+              conversationId,
+              opts as Record<string, unknown> | undefined,
+            );
+            return conversationObj;
+          },
           assistantEventHub: { publish: async () => {} } as any,
           resolveAttachments: () => [],
         },
@@ -326,3 +338,97 @@ describe("HTTP POST /v1/messages does not intercept recording intents (by design
     expect(runAgentLoop).toHaveBeenCalledTimes(1);
   });
 });
+
+// ============================================================================
+// CLIENT TIMEZONE — optional HTTP metadata
+// ============================================================================
+describe("HTTP POST /v1/messages clientTimezone transport metadata", () => {
+  beforeEach(() => {
+    routeGuardianReplyMock.mockClear();
+    listPendingByDestinationMock.mockClear();
+    listCanonicalMock.mockClear();
+    addMessageMock.mockClear();
+  });
+
+  test("passes canonical clientTimezone through host-proxy transport", async () => {
+    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const runAgentLoop = mock(async () => undefined);
+    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
+    let capturedOptions: Record<string, unknown> | undefined;
+
+    const res = await sendMessage(
+      "hello",
+      conversation,
+      { clientTimezone: "america/new_york" },
+      {
+        onGetOrCreateConversation: (_conversationId, opts) => {
+          capturedOptions = opts;
+        },
+      },
+    );
+
+    expect(res.status).toBe(202);
+    expect(capturedOptions).toEqual({
+      transport: {
+        channelId: "vellum",
+        interfaceId: "macos",
+        clientTimezone: "America/New_York",
+      },
+    });
+  });
+
+  test("passes canonical clientTimezone through non-host-proxy transport", async () => {
+    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const runAgentLoop = mock(async () => undefined);
+    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
+    let capturedOptions: Record<string, unknown> | undefined;
+
+    const res = await sendMessage(
+      "hello",
+      conversation,
+      { interface: "ios", clientTimezone: "europe/london" },
+      {
+        onGetOrCreateConversation: (_conversationId, opts) => {
+          capturedOptions = opts;
+        },
+      },
+    );
+
+    expect(res.status).toBe(202);
+    expect(capturedOptions).toEqual({
+      transport: {
+        channelId: "vellum",
+        interfaceId: "ios",
+        clientTimezone: "Europe/London",
+      },
+    });
+  });
+
+  test("drops invalid clientTimezone without rejecting the message", async () => {
+    const persistUserMessage = mock(async () => "persisted-msg-id");
+    const runAgentLoop = mock(async () => undefined);
+    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
+    let capturedOptions: Record<string, unknown> | undefined;
+
+    const res = await sendMessage(
+      "hello",
+      conversation,
+      { clientTimezone: "not-a-timezone" },
+      {
+        onGetOrCreateConversation: (_conversationId, opts) => {
+          capturedOptions = opts;
+        },
+      },
+    );
+
+    expect(res.status).toBe(202);
+    expect(capturedOptions).toEqual({
+      transport: {
+        channelId: "vellum",
+        interfaceId: "macos",
+      },
+    });
+    expect(persistUserMessage).toHaveBeenCalledTimes(1);
+    expect(runAgentLoop).toHaveBeenCalledTimes(1);
+  });
+});

package/src/__tests__/injector-chain.test.ts

@@ -4,10 +4,11 @@
  *
  * Covers:
  *
- * 1. The nine default injectors registered by `defaultInjectorsPlugin` come
- *    back from `getInjectors()` in the documented order (workspace-context →
- *    unified-turn-context → pkb-context → pkb-reminder → memory-v2-static →
- *    now-md → subagent-status → slack-messages → thread-focus).
+ * 1. The ten default injectors registered by `defaultInjectorsPlugin` come
+ *    back from `getInjectors()` in the documented order
+ *    (disk-pressure-warning → workspace-context → unified-turn-context →
+ *    pkb-context → pkb-reminder → memory-v2-static → now-md →
+ *    subagent-status → slack-messages → thread-focus).
  * 2. A third-party-registered injector at `order: 25` slots between
  *    `unified-turn-context` (order 20) and `pkb` (order 30), proving the
  *    extensibility contract.
@@ -25,6 +26,7 @@
 
 import { beforeEach, describe, expect, test } from "bun:test";
 
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import {
   applyRuntimeInjections,
   composeInjectorChain,
@@ -33,6 +35,11 @@ import {
   DEFAULT_INJECTOR_ORDER,
   defaultInjectorsPlugin,
 } from "../plugins/defaults/injectors.js";
+
+// This test exercises v1 PKB injection. The `memory-v2-enabled` flag
+// (registry default `true`) makes the PKB injector go silent — disable it
+// here so the v1 injection chain assertions stay meaningful.
+_setOverridesForTesting({ "memory-v2-enabled": false });
 import {
   getInjectors,
   registerPlugin,
@@ -76,11 +83,12 @@ describe("injector chain", () => {
     resetPluginRegistryForTests();
   });
 
-  test("defaultInjectorsPlugin registers the nine defaults in the documented order", () => {
+  test("defaultInjectorsPlugin registers the ten defaults in the documented order", () => {
     registerPlugin(defaultInjectorsPlugin);
 
     const names = getInjectors().map((i) => i.name);
     expect(names).toEqual([
+      "disk-pressure-warning",
       "workspace-context",
       "unified-turn-context",
       "pkb-context",
@@ -97,6 +105,9 @@ describe("injector chain", () => {
     registerPlugin(defaultInjectorsPlugin);
 
     const byName = new Map(getInjectors().map((i) => [i.name, i.order]));
+    expect(byName.get("disk-pressure-warning")).toBe(
+      DEFAULT_INJECTOR_ORDER.diskPressureWarning,
+    );
     expect(byName.get("workspace-context")).toBe(
       DEFAULT_INJECTOR_ORDER.workspaceContext,
     );
@@ -132,6 +143,7 @@ describe("injector chain", () => {
 
     const names = getInjectors().map((i) => i.name);
     expect(names).toEqual([
+      "disk-pressure-warning", // 5
       "workspace-context", // 10
       "unified-turn-context", // 20
       "plugin-25", // 25 — slots in
@@ -146,7 +158,7 @@ describe("injector chain", () => {
   });
 
   test("composeInjectorChain returns empty string when every injector opts out", async () => {
-    // The default chain is the golden-path: all nine defaults return `null`
+    // The default chain is the golden-path: all ten defaults return `null`
     // on an empty turn context, so the composed block is an empty string.
     registerPlugin(defaultInjectorsPlugin);