@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/__tests__/events-dev-bypass-actor.test.ts

@@ -16,13 +16,17 @@
  * principalId at registration time so both sides agree. This keeps targeted
  * host proxy execution working on Docker / platform-managed deployments.
  */
-import { afterAll, describe, expect, mock, test } from "bun:test";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ── Module mocks (must be set up before importing the route) ──────────────
 
 let fakeHttpAuthDisabled = false;
 let fakeGuardianPrincipalId: string | undefined = undefined;
 
+// Manually-resolvable async resolutions, in call order, so tests control
+// exactly when the SSE self-heal lookup completes.
+const pendingAsyncResolutions: Array<(value: string | undefined) => void> = [];
+
 mock.module("../config/env.js", () => ({
   isHttpAuthDisabled: () => fakeHttpAuthDisabled,
   hasUngatedHttpAuthDisabled: () => false,
@@ -38,8 +42,21 @@ mock.module("../runtime/local-actor-identity.js", () => ({
     }
     return fakeGuardianPrincipalId;
   },
+  resolveActorPrincipalIdForLocalGuardian: (rawHeader: string | undefined) => {
+    if (rawHeader !== "dev-bypass" || !fakeHttpAuthDisabled) {
+      return Promise.resolve(rawHeader);
+    }
+    return new Promise<string | undefined>((resolve) => {
+      pendingAsyncResolutions.push(resolve);
+    });
+  },
 }));
 
+/** Let the fire-and-forget heal promise chain settle. */
+async function flushMicrotasks(): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, 0));
+}
+
 // ── Real imports (after mocks) ────────────────────────────────────────────
 
 import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
@@ -50,6 +67,10 @@ afterAll(() => {
 });
 
 describe("events SSE registration — dev-bypass actor translation", () => {
+  beforeEach(() => {
+    pendingAsyncResolutions.length = 0;
+  });
+
   test("translates 'dev-bypass' to the real guardian principalId when auth is disabled", () => {
     fakeHttpAuthDisabled = true;
     fakeGuardianPrincipalId = "guardian-real-id";
@@ -104,6 +125,167 @@ describe("events SSE registration — dev-bypass actor translation", () => {
     ac.abort();
   });
 
+  test("self-heals a cold-cache registration once the async guardian lookup resolves", async () => {
+    fakeHttpAuthDisabled = true;
+    fakeGuardianPrincipalId = undefined; // cold cache: sync resolution misses
+
+    const ac = new AbortController();
+    const hub = new AssistantEventHub();
+
+    handleSubscribeAssistantEvents(
+      {
+        headers: {
+          "x-vellum-client-id": "heal-client-001",
+          "x-vellum-interface-id": "chrome-extension",
+          "x-vellum-actor-principal-id": "dev-bypass",
+        },
+        abortSignal: ac.signal,
+      },
+      { hub },
+    );
+
+    // Registered without a principal, heal lookup in flight.
+    expect(hub.getActorPrincipalIdForClient("heal-client-001")).toBeUndefined();
+    expect(pendingAsyncResolutions).toHaveLength(1);
+
+    pendingAsyncResolutions.shift()!("guardian-real-id");
+    await flushMicrotasks();
+
+    // Hub record patched: a host-proxy request registered now snapshots the
+    // real principal, so the result-route same-actor check passes.
+    expect(hub.getActorPrincipalIdForClient("heal-client-001")).toBe(
+      "guardian-real-id",
+    );
+
+    ac.abort();
+  });
+
+  test("does not start the heal lookup when the sync resolution already succeeded", () => {
+    fakeHttpAuthDisabled = true;
+    fakeGuardianPrincipalId = "guardian-real-id"; // warm cache
+
+    const ac = new AbortController();
+    const hub = new AssistantEventHub();
+
+    handleSubscribeAssistantEvents(
+      {
+        headers: {
+          "x-vellum-client-id": "warm-client-001",
+          "x-vellum-interface-id": "macos",
+          "x-vellum-actor-principal-id": "dev-bypass",
+        },
+        abortSignal: ac.signal,
+      },
+      { hub },
+    );
+
+    expect(pendingAsyncResolutions).toHaveLength(0);
+
+    ac.abort();
+  });
+
+  test("does not start the heal lookup for connections without a dev-bypass principal", () => {
+    fakeHttpAuthDisabled = true;
+    fakeGuardianPrincipalId = undefined;
+
+    const ac = new AbortController();
+    const hub = new AssistantEventHub();
+
+    // Legacy connection with no actor-principal header at all: it registers
+    // without a principal and must stay that way (no dev-bypass translation).
+    handleSubscribeAssistantEvents(
+      {
+        headers: {
+          "x-vellum-client-id": "legacy-client-001",
+          "x-vellum-interface-id": "macos",
+        },
+        abortSignal: ac.signal,
+      },
+      { hub },
+    );
+
+    expect(pendingAsyncResolutions).toHaveLength(0);
+    expect(
+      hub.getActorPrincipalIdForClient("legacy-client-001"),
+    ).toBeUndefined();
+
+    ac.abort();
+  });
+
+  test("a stale heal cannot patch the subscription that replaced it (reconnect race)", async () => {
+    fakeHttpAuthDisabled = true;
+    fakeGuardianPrincipalId = undefined; // cold cache for the first connect
+
+    const ac1 = new AbortController();
+    const hub = new AssistantEventHub();
+
+    handleSubscribeAssistantEvents(
+      {
+        headers: {
+          "x-vellum-client-id": "race-client-001",
+          "x-vellum-interface-id": "macos",
+          "x-vellum-actor-principal-id": "dev-bypass",
+        },
+        abortSignal: ac1.signal,
+      },
+      { hub },
+    );
+    expect(pendingAsyncResolutions).toHaveLength(1);
+    const staleHeal = pendingAsyncResolutions.shift()!;
+
+    // Client reconnects before the first heal resolves; cache is warm now.
+    fakeGuardianPrincipalId = "guardian-current";
+    const ac2 = new AbortController();
+    handleSubscribeAssistantEvents(
+      {
+        headers: {
+          "x-vellum-client-id": "race-client-001",
+          "x-vellum-interface-id": "macos",
+          "x-vellum-actor-principal-id": "dev-bypass",
+        },
+        abortSignal: ac2.signal,
+      },
+      { hub },
+    );
+
+    // The stale heal resolves late with a different value; it is keyed to
+    // the disposed connection, so the live record must be untouched.
+    staleHeal("guardian-stale");
+    await flushMicrotasks();
+
+    expect(hub.getActorPrincipalIdForClient("race-client-001")).toBe(
+      "guardian-current",
+    );
+
+    ac1.abort();
+    ac2.abort();
+  });
+
+  test("fillClientActorPrincipalId never overwrites a present principal", () => {
+    const hub = new AssistantEventHub();
+    const sub = hub.subscribe({
+      type: "client",
+      clientId: "direct-client-001",
+      interfaceId: "macos",
+      capabilities: [],
+      actorPrincipalId: "existing-principal",
+      callback: () => {},
+    });
+
+    hub.fillClientActorPrincipalId(sub.connectionId, "other-principal");
+    expect(hub.getActorPrincipalIdForClient("direct-client-001")).toBe(
+      "existing-principal",
+    );
+
+    // Unknown connection id is a no-op.
+    hub.fillClientActorPrincipalId("conn-does-not-exist", "other-principal");
+    expect(hub.getActorPrincipalIdForClient("direct-client-001")).toBe(
+      "existing-principal",
+    );
+
+    sub.dispose();
+  });
+
   test("does NOT translate when auth is enabled (production mode)", () => {
     // Defense in depth: make sure we never silently rewrite a real
     // principalId that legitimately happens to be the literal "dev-bypass"

package/src/__tests__/evict-conversations-for-reload.test.ts

@@ -0,0 +1,90 @@
+/**
+ * `evictConversationsForReload` drops in-memory conversations after a
+ * config/prompt/skills reload so the next turn rebuilds them against the new
+ * config. Queued messages live only on the instance being disposed, so the
+ * same "not idle while a queue is pending" rule the periodic evictor applies
+ * has to hold here: `isProcessing()` reads false in the window between a turn
+ * releasing and its queued successor being dispatched.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../subagent/index.js", () => ({
+  getSubagentManager: () => ({
+    abortAllForParent: () => {},
+    getChildrenOf: () => [],
+  }),
+}));
+
+import type { Conversation } from "../daemon/conversation.js";
+import {
+  clearConversations,
+  conversationIds,
+  findConversation,
+  setConversation,
+} from "../daemon/conversation-registry.js";
+import { evictConversationsForReload } from "../daemon/conversation-store.js";
+
+interface FakeConversation {
+  disposed: boolean;
+  markedStale: boolean;
+}
+
+function register(
+  id: string,
+  state: { processing: boolean; queued: boolean },
+): FakeConversation {
+  const fake: FakeConversation & Record<string, unknown> = {
+    disposed: false,
+    markedStale: false,
+    conversationId: id,
+    isProcessing: () => state.processing,
+    hasQueuedMessages: () => state.queued,
+    dispose() {
+      fake.disposed = true;
+    },
+    markStale() {
+      fake.markedStale = true;
+    },
+  };
+  setConversation(id, fake as unknown as Conversation);
+  return fake;
+}
+
+describe("evictConversationsForReload", () => {
+  beforeEach(() => {
+    clearConversations();
+  });
+
+  test("disposes an idle conversation", () => {
+    const idle = register("reload-idle", { processing: false, queued: false });
+
+    evictConversationsForReload();
+
+    expect(idle.disposed).toBe(true);
+    expect(findConversation("reload-idle")).toBeUndefined();
+  });
+
+  test("keeps a conversation with queued messages and marks it stale", () => {
+    const queued = register("reload-queued", {
+      processing: false,
+      queued: true,
+    });
+
+    evictConversationsForReload();
+
+    // Disposing here would silently destroy the in-memory queue.
+    expect(queued.disposed).toBe(false);
+    expect(queued.markedStale).toBe(true);
+    expect(findConversation("reload-queued")).toBeDefined();
+  });
+
+  test("marks a mid-turn conversation stale instead of disposing it", () => {
+    const busy = register("reload-busy", { processing: true, queued: false });
+
+    evictConversationsForReload();
+
+    expect(busy.disposed).toBe(false);
+    expect(busy.markedStale).toBe(true);
+    expect([...conversationIds()]).toEqual(["reload-busy"]);
+  });
+});

package/src/__tests__/file-list-tool.test.ts

@@ -50,7 +50,7 @@ function sandboxPolicyFor(boundary: string): PathPolicy {
 // ---------------------------------------------------------------------------
 
 describe("FileSystemOps.listDirSafe", () => {
-  test("lists directory contents with type indicators (dirs end with /)", () => {
+  test("lists directory contents with type indicators (dirs end with /)", async () => {
     const dir = makeTempDir();
     mkdirSync(join(dir, "subdir-a"));
     mkdirSync(join(dir, "subdir-b"));
@@ -58,7 +58,7 @@ describe("FileSystemOps.listDirSafe", () => {
     writeFileSync(join(dir, "file-b.md"), "world");
 
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
-    const result = ops.listDirSafe({ path: dir });
+    const result = await ops.listDirSafe({ path: dir });
     expect(result.ok).toBe(true);
     if (!result.ok) {
       return;
@@ -73,7 +73,7 @@ describe("FileSystemOps.listDirSafe", () => {
     expect(lines[3]).toMatch(/^file-b\.md\s+\d+\s*B$/);
   });
 
-  test("glob filtering works (e.g. '*.md' only returns .md files)", () => {
+  test("glob filtering works (e.g. '*.md' only returns .md files)", async () => {
     const dir = makeTempDir();
     writeFileSync(join(dir, "readme.md"), "# Title");
     writeFileSync(join(dir, "notes.md"), "some notes");
@@ -81,7 +81,7 @@ describe("FileSystemOps.listDirSafe", () => {
     writeFileSync(join(dir, "config.json"), "{}");
 
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
-    const result = ops.listDirSafe({ path: dir, glob: "*.md" });
+    const result = await ops.listDirSafe({ path: dir, glob: "*.md" });
     expect(result.ok).toBe(true);
     if (!result.ok) {
       return;
@@ -93,12 +93,14 @@ describe("FileSystemOps.listDirSafe", () => {
     expect(lines[1]).toMatch(/^readme\.md/);
   });
 
-  test("returns NOT_A_DIRECTORY error for file paths", () => {
+  test("returns NOT_A_DIRECTORY error for file paths", async () => {
     const dir = makeTempDir();
     writeFileSync(join(dir, "regular-file.txt"), "content");
 
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
-    const result = ops.listDirSafe({ path: join(dir, "regular-file.txt") });
+    const result = await ops.listDirSafe({
+      path: join(dir, "regular-file.txt"),
+    });
     expect(result.ok).toBe(false);
     if (result.ok) {
       return;
@@ -106,11 +108,11 @@ describe("FileSystemOps.listDirSafe", () => {
     expect(result.error.code).toBe("NOT_A_DIRECTORY");
   });
 
-  test("returns NOT_FOUND error for nonexistent paths", () => {
+  test("returns NOT_FOUND error for nonexistent paths", async () => {
     const dir = makeTempDir();
 
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
-    const result = ops.listDirSafe({ path: join(dir, "nonexistent") });
+    const result = await ops.listDirSafe({ path: join(dir, "nonexistent") });
     expect(result.ok).toBe(false);
     if (result.ok) {
       return;
@@ -118,11 +120,11 @@ describe("FileSystemOps.listDirSafe", () => {
     expect(result.error.code).toBe("NOT_FOUND");
   });
 
-  test("sandbox policy rejects paths outside boundary", () => {
+  test("sandbox policy rejects paths outside boundary", async () => {
     const dir = makeTempDir();
 
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
-    const result = ops.listDirSafe({ path: "../../../etc" });
+    const result = await ops.listDirSafe({ path: "../../../etc" });
     expect(result.ok).toBe(false);
     if (result.ok) {
       return;