@vellumai/assistant 0.6.3 → 0.6.4

package/src/__tests__/secure-keys.test.ts

@@ -23,6 +23,7 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+import type { CesClient } from "../credential-execution/client.js";
 import * as encryptedStore from "../security/encrypted-store.js";
 import { _setStorePath } from "../security/encrypted-store.js";
 import {
@@ -31,6 +32,8 @@ import {
   getSecureKeyAsync,
   getSecureKeyResultAsync,
   listSecureKeysAsync,
+  setCesClient,
+  setCesReconnect,
   setSecureKeyAsync,
 } from "../security/secure-keys.js";
 
@@ -291,4 +294,108 @@ describe("secure-keys", () => {
       expect(result.unreachable).toBe(false);
     });
   });
+
+  // -----------------------------------------------------------------------
+  // CES reconnection reentrancy
+  // -----------------------------------------------------------------------
+  //
+  // The reconnect callback runs while the credential resolver is waiting on
+  // `_reconnectInFlight`. A nested `getSecureKeyAsync()` from inside the
+  // callback — e.g. `resolveManagedProxyContext()` reading the assistant API
+  // key for the handshake — would recursively `await` the same in-flight
+  // promise and deadlock for 45 seconds until `CREDENTIAL_OP_TIMEOUT_MS`
+  // fires. The guard in `attemptCesReconnection` short-circuits that
+  // reentrant case so nested reads resolve immediately (as "unreachable")
+  // and the outer reconnect makes progress.
+  describe("reconnect callback reentrancy", () => {
+    interface ControllableClient extends CesClient {
+      setReady: (ready: boolean) => void;
+    }
+
+    function makeControllableClient(initialReady = true): ControllableClient {
+      let ready = initialReady;
+      return {
+        handshake: async () => ({ accepted: true }),
+        call: async () => ({ found: false, value: undefined }) as never,
+        isReady: () => ready,
+        close: () => {
+          ready = false;
+        },
+        updateAssistantApiKey: async () => ({ updated: true }),
+        setReady: (r: boolean) => {
+          ready = r;
+        },
+      } as ControllableClient;
+    }
+
+    test("nested credential read inside reconnect callback does not deadlock", async () => {
+      // Seed the encrypted store with a value so nested reads have something
+      // to target if they were to accidentally succeed via fallback paths.
+      encryptedStore.setKey("test-key", "encrypted-value");
+
+      // Install a CES client that starts ready so the first read resolves
+      // the backend to CES RPC, then flip it to unready so the NEXT read
+      // triggers the reconnect path.
+      const client = makeControllableClient(true);
+      setCesClient(client);
+
+      // Prime the resolver so `_resolvedBackend` points at CES RPC.
+      await getSecureKeyAsync("test-key");
+      client.setReady(false);
+
+      let nestedReadResolved = false;
+      let reconnectCallbackRan = 0;
+
+      setCesReconnect(async () => {
+        reconnectCallbackRan++;
+        // Yield once so `_reconnectInFlight` (assigned after this IIFE's
+        // first await) is observable to any nested resolver. This matches
+        // production timing, where the callback awaits `pm.stop()` /
+        // `pm.start()` before reading credentials — those awaits complete
+        // the outer assignment, so the subsequent nested read sees a live
+        // `_reconnectInFlight` and is the recursion that caused the 45s
+        // deadlock.
+        await Promise.resolve();
+        await getSecureKeyAsync("test-key");
+        nestedReadResolved = true;
+        return makeControllableClient(true);
+      });
+
+      const start = Date.now();
+      await getSecureKeyAsync("test-key");
+      const elapsed = Date.now() - start;
+
+      expect(reconnectCallbackRan).toBe(1);
+      expect(nestedReadResolved).toBe(true);
+      // Pre-fix, this took 45s (CREDENTIAL_OP_TIMEOUT_MS). Post-fix it's
+      // bounded only by the mock callback's own work.
+      expect(elapsed).toBeLessThan(2000);
+    });
+
+    test("reconnect callback that throws still releases the reentrancy flag", async () => {
+      const client = makeControllableClient(true);
+      setCesClient(client);
+      await getSecureKeyAsync("any-key"); // prime the resolver
+      client.setReady(false);
+
+      setCesReconnect(async () => {
+        throw new Error("boom");
+      });
+
+      await getSecureKeyAsync("any-key");
+
+      // Swap in a reconnect that succeeds and wait past the 3s cooldown
+      // in `attemptCesReconnection`. A stuck reentrancy flag from the
+      // throwing callback would prevent this second attempt from running.
+      let secondCallbackRan = 0;
+      setCesReconnect(async () => {
+        secondCallbackRan++;
+        return makeControllableClient(true);
+      });
+      await new Promise((resolve) => setTimeout(resolve, 3_100));
+
+      await getSecureKeyAsync("any-key");
+      expect(secondCallbackRan).toBe(1);
+    });
+  });
 });

package/src/__tests__/send-endpoint-busy.test.ts

@@ -6,7 +6,7 @@
  * - Messages are queued (202, queued: true) when the conversation is busy, not 409.
  * - SSE subscribers receive events from messages sent via this endpoint.
  */
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
 
@@ -322,6 +322,10 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
     eventHub = new AssistantEventHub();
   });
 
+  afterEach(async () => {
+    await server?.stop();
+  });
+
   async function startServer(
     conversationFactory: () => Conversation,
     options?: { approvalConversationGenerator?: ApprovalConversationGenerator },

package/src/__tests__/sequence-store.test.ts

@@ -130,7 +130,7 @@ describe("sequence-store", () => {
   describe("listSequences", () => {
     test("lists all sequences", () => {
       createSequence({ name: "A", channel: "gmail", steps: testSteps });
-      createSequence({ name: "B", channel: "agentmail", steps: testSteps });
+      createSequence({ name: "B", channel: "email", steps: testSteps });
       expect(listSequences()).toHaveLength(2);
     });
 

package/src/__tests__/server-history-render.test.ts

@@ -283,6 +283,55 @@ describe("renderHistoryContent", () => {
     expect(output2.textSegments).toEqual(["raw string"]);
     expect(output2.contentOrder).toEqual(["text:0"]);
   });
+
+  test("skips empty text blocks between consecutive tool_use blocks (consolidated message scenario)", () => {
+    // Simulates message consolidation where empty text blocks from intermediate
+    // API turns end up between tool_use blocks. Without the fix, these create
+    // phantom text segments that break tool-call grouping in the UI.
+    const output = renderHistoryContent([
+      { type: "text", text: "Let me check." },
+      { type: "tool_use", id: "tu_1", name: "bash", input: { command: "ls" } },
+      { type: "tool_result", tool_use_id: "tu_1", content: "file.txt" },
+      { type: "text", text: "" },
+      { type: "tool_use", id: "tu_2", name: "bash", input: { command: "pwd" } },
+      { type: "tool_result", tool_use_id: "tu_2", content: "/home" },
+      { type: "text", text: "Done." },
+    ]);
+
+    expect(output.textSegments).toEqual(["Let me check.", "Done."]);
+    expect(output.contentOrder).toEqual([
+      "text:0",
+      "tool:0",
+      "tool:1",
+      "text:1",
+    ]);
+  });
+
+  test("skips whitespace-only text blocks between consecutive tool_use blocks", () => {
+    const output = renderHistoryContent([
+      { type: "tool_use", id: "tu_1", name: "bash", input: { command: "ls" } },
+      { type: "tool_result", tool_use_id: "tu_1", content: "file.txt" },
+      { type: "text", text: "   \n  " },
+      { type: "tool_use", id: "tu_2", name: "bash", input: { command: "pwd" } },
+      { type: "tool_result", tool_use_id: "tu_2", content: "/home" },
+    ]);
+
+    expect(output.textSegments).toEqual([]);
+    expect(output.contentOrder).toEqual(["tool:0", "tool:1"]);
+  });
+
+  test("preserves non-empty text blocks between tool_use blocks", () => {
+    const output = renderHistoryContent([
+      { type: "tool_use", id: "tu_1", name: "bash", input: { command: "ls" } },
+      { type: "tool_result", tool_use_id: "tu_1", content: "file.txt" },
+      { type: "text", text: "Now let me try something else." },
+      { type: "tool_use", id: "tu_2", name: "bash", input: { command: "pwd" } },
+      { type: "tool_result", tool_use_id: "tu_2", content: "/home" },
+    ]);
+
+    expect(output.textSegments).toEqual(["Now let me try something else."]);
+    expect(output.contentOrder).toEqual(["tool:0", "text:0", "tool:1"]);
+  });
 });
 
 describe("getAttachmentsForMessage", () => {

package/src/__tests__/settings-routes.test.ts

@@ -0,0 +1,201 @@
+/**
+ * Tests for the `workspace-files` list/read endpoints in settings-routes.
+ *
+ * Focus: the list includes the guardian's per-user persona file
+ * (`users/<slug>.md`) whenever a guardian exists, and the read endpoint
+ * accepts paths under `users/`.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { createGuardianBinding } from "../contacts/contacts-write.js";
+import { getSqlite, initializeDb } from "../memory/db.js";
+import { settingsRouteDefinitions } from "../runtime/routes/settings-routes.js";
+
+initializeDb();
+
+const testWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR!;
+
+function resetContactTables(): void {
+  const sqlite = getSqlite();
+  sqlite.run("DELETE FROM contact_channels");
+  sqlite.run("DELETE FROM contacts");
+}
+
+// ---------------------------------------------------------------------------
+// RouteContext helpers (mirrors workspace-routes.test.ts)
+// ---------------------------------------------------------------------------
+
+function makeCtx(
+  endpoint: string,
+  searchParams: Record<string, string> = {},
+) {
+  const url = new URL(`http://localhost/v1/${endpoint}`);
+  for (const [k, v] of Object.entries(searchParams)) {
+    url.searchParams.set(k, v);
+  }
+  return {
+    url,
+    req: new Request(url),
+    server: {} as ReturnType<typeof Bun.serve>,
+    authContext: {} as never,
+    params: {},
+  };
+}
+
+function getHandler(endpoint: string, method: string) {
+  const routes = settingsRouteDefinitions();
+  const route = routes.find(
+    (r) => r.endpoint === endpoint && r.method === method,
+  );
+  if (!route) {
+    throw new Error(`No route found for ${method} ${endpoint}`);
+  }
+  return route.handler;
+}
+
+// ---------------------------------------------------------------------------
+// GET /workspace-files
+// ---------------------------------------------------------------------------
+
+describe("GET /workspace-files", () => {
+  const handler = getHandler("workspace-files", "GET");
+
+  beforeEach(() => {
+    resetContactTables();
+  });
+
+  test("with no guardian: returns the static entries only", async () => {
+    const res = await handler(makeCtx("workspace-files"));
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as {
+      files: Array<{ path: string; name: string; exists: boolean }>;
+    };
+    const paths = body.files.map((f) => f.path);
+    expect(paths).toEqual(["IDENTITY.md", "SOUL.md", "skills/"]);
+    // No guardian → no users/*.md entry.
+    expect(paths.find((p) => p.startsWith("users/"))).toBeUndefined();
+  });
+
+  test("with a guardian: includes users/<slug>.md", async () => {
+    createGuardianBinding({
+      channel: "telegram",
+      guardianExternalUserId: "Alice",
+      guardianDeliveryChatId: "chat-alice",
+      guardianPrincipalId: "principal-alice",
+      verifiedVia: "challenge",
+    });
+
+    const res = await handler(makeCtx("workspace-files"));
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as {
+      files: Array<{ path: string; name: string; exists: boolean }>;
+    };
+    const paths = body.files.map((f) => f.path);
+
+    // The guardian per-user persona is the sole user-profile entry; USER.md
+    // is not included.
+    expect(paths).not.toContain("USER.md");
+    // Guardian per-user persona is appended.
+    expect(paths).toContain("users/alice.md");
+
+    // The guardian entry reports `exists: true` because the template scaffold
+    // is seeded when the binding is created.
+    const guardianEntry = body.files.find((f) => f.path === "users/alice.md");
+    expect(guardianEntry).toBeDefined();
+    expect(guardianEntry!.exists).toBe(true);
+  });
+
+  test("reflects guardian changes on a subsequent request (not cached)", async () => {
+    // Initially no guardian.
+    let res = await handler(makeCtx("workspace-files"));
+    let body = (await res.json()) as {
+      files: Array<{ path: string }>;
+    };
+    expect(body.files.map((f) => f.path)).not.toContain("users/alice.md");
+
+    // Create a guardian mid-session.
+    createGuardianBinding({
+      channel: "telegram",
+      guardianExternalUserId: "Alice",
+      guardianDeliveryChatId: "chat-alice",
+      guardianPrincipalId: "principal-alice",
+      verifiedVia: "challenge",
+    });
+
+    // The next request must reflect the new guardian — we do not want a
+    // stale module-level cache here.
+    res = await handler(makeCtx("workspace-files"));
+    body = (await res.json()) as {
+      files: Array<{ path: string }>;
+    };
+    expect(body.files.map((f) => f.path)).toContain("users/alice.md");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// GET /workspace-files/read
+// ---------------------------------------------------------------------------
+
+describe("GET /workspace-files/read", () => {
+  const handler = getHandler("workspace-files/read", "GET");
+
+  beforeEach(() => {
+    resetContactTables();
+  });
+
+  test("reads a guardian users/<slug>.md file", async () => {
+    createGuardianBinding({
+      channel: "telegram",
+      guardianExternalUserId: "Alice",
+      guardianDeliveryChatId: "chat-alice",
+      guardianPrincipalId: "principal-alice",
+      verifiedVia: "challenge",
+    });
+
+    const personaPath = join(testWorkspaceDir, "users", "alice.md");
+    // The template scaffold is seeded when the binding is created; overwrite
+    // with something recognizable so the test asserts on exact content rather
+    // than scaffold boilerplate.
+    expect(existsSync(personaPath)).toBe(true);
+    writeFileSync(
+      personaPath,
+      "# Alice\n\n- Preferred name/reference: Alice\n",
+      "utf-8",
+    );
+
+    const res = await handler(
+      makeCtx("workspace-files/read", { path: "users/alice.md" }),
+    );
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { path: string; content: string };
+    expect(body.path).toBe("users/alice.md");
+    expect(body.content).toBe(readFileSync(personaPath, "utf-8"));
+    expect(body.content).toContain("Preferred name/reference: Alice");
+  });
+
+  test("rejects path traversal attempts via users/", async () => {
+    const res = await handler(
+      makeCtx("workspace-files/read", {
+        path: "users/../../etc/passwd",
+      }),
+    );
+    expect(res.status).toBe(400);
+  });
+
+  test("returns 404 for a non-existent users/<slug>.md", async () => {
+    const res = await handler(
+      makeCtx("workspace-files/read", { path: "users/nobody.md" }),
+    );
+    expect(res.status).toBe(404);
+  });
+});

package/src/__tests__/skill-load-feature-flag.test.ts

@@ -32,6 +32,7 @@ mock.module("../util/logger.js", () => ({
 
 mock.module("../config/loader.js", () => ({
   getConfig: () => currentConfig,
+  getConfigReadOnly: () => currentConfig,
   loadConfig: () => currentConfig,
   loadRawConfig: () => ({}),
   saveConfig: () => {},