@vellumai/assistant 0.5.5 → 0.5.7

package/src/__tests__/docker-signing-key-bootstrap.test.ts

@@ -0,0 +1,98 @@
+/**
+ * Tests for resolveSigningKey() covering env var injection (Docker)
+ * and file-based load/create (local mode).
+ */
+
+import { mkdirSync, mkdtempSync, realpathSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+const testDir = realpathSync(mkdtempSync(join(tmpdir(), "signing-key-test-")));
+
+mock.module("../util/platform.js", () => ({
+  getRootDir: () => testDir,
+  getDataDir: () => testDir,
+  getDbPath: () => join(testDir, "test.db"),
+  normalizeAssistantId: (id: string) => (id === "self" ? "self" : id),
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getPidPath: () => join(testDir, "test.pid"),
+  getLogPath: () => join(testDir, "test.log"),
+  ensureDataDir: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+const { resolveSigningKey } = await import("../runtime/auth/token-service.js");
+
+const VALID_HEX_KEY = "ab".repeat(32); // 64 hex chars = 32 bytes
+
+const savedEnv: Record<string, string | undefined> = {};
+
+beforeEach(() => {
+  savedEnv.ACTOR_TOKEN_SIGNING_KEY = process.env.ACTOR_TOKEN_SIGNING_KEY;
+  mkdirSync(join(testDir, "protected"), { recursive: true });
+});
+
+afterEach(() => {
+  if (savedEnv.ACTOR_TOKEN_SIGNING_KEY === undefined) {
+    delete process.env.ACTOR_TOKEN_SIGNING_KEY;
+  } else {
+    process.env.ACTOR_TOKEN_SIGNING_KEY = savedEnv.ACTOR_TOKEN_SIGNING_KEY;
+  }
+});
+
+afterAll(() => {
+  try {
+    rmSync(testDir, { recursive: true, force: true });
+  } catch {}
+});
+
+describe("resolveSigningKey", () => {
+  test("reads key from ACTOR_TOKEN_SIGNING_KEY env var", () => {
+    process.env.ACTOR_TOKEN_SIGNING_KEY = VALID_HEX_KEY;
+
+    const key = resolveSigningKey();
+
+    expect(key).toBeInstanceOf(Buffer);
+    expect(key.length).toBe(32);
+    expect(key.toString("hex")).toBe(VALID_HEX_KEY);
+  });
+
+  test("rejects invalid ACTOR_TOKEN_SIGNING_KEY", () => {
+    process.env.ACTOR_TOKEN_SIGNING_KEY = "tooshort";
+
+    expect(() => resolveSigningKey()).toThrow("Invalid ACTOR_TOKEN_SIGNING_KEY");
+  });
+
+  test("falls back to file-based load/create when env var is not set", () => {
+    delete process.env.ACTOR_TOKEN_SIGNING_KEY;
+
+    const key = resolveSigningKey();
+
+    expect(key).toBeInstanceOf(Buffer);
+    expect(key.length).toBe(32);
+  });
+
+  test("env var takes priority over file on disk", () => {
+    process.env.ACTOR_TOKEN_SIGNING_KEY = VALID_HEX_KEY;
+
+    // First call creates a file-based key
+    delete process.env.ACTOR_TOKEN_SIGNING_KEY;
+    const fileKey = resolveSigningKey();
+
+    // Second call with env var should use the env var, not the file
+    process.env.ACTOR_TOKEN_SIGNING_KEY = "cd".repeat(32);
+    const envKey = resolveSigningKey();
+
+    expect(envKey.toString("hex")).toBe("cd".repeat(32));
+    expect(envKey.toString("hex")).not.toBe(fileKey.toString("hex"));
+  });
+});

package/src/__tests__/dynamic-skill-workflow-prompt.test.ts

@@ -53,9 +53,6 @@ mock.module("../util/logger.js", () => ({
 
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
-    assistantFeatureFlagValues: {
-      "feature_flags.browser.enabled": true,
-    },
     services: {
       inference: {
         mode: "your-own",
@@ -77,17 +74,22 @@ mock.module("../config/loader.js", () => ({
   invalidateConfigCache: () => {},
   getNestedValue: () => undefined,
   setNestedValue: () => {},
-  syncConfigToLockfile: () => {},
 }));
 
 const { buildSystemPrompt } = await import("../prompts/system-prompt.js");
+const { _setOverridesForTesting } =
+  await import("../config/assistant-feature-flags.js");
 
 describe("Dynamic Skill Authoring Workflow moved to tool descriptions", () => {
   beforeEach(() => {
     mkdirSync(TEST_DIR, { recursive: true });
+    _setOverridesForTesting({
+      "feature_flags.browser.enabled": true,
+    });
   });
 
   afterEach(() => {
+    _setOverridesForTesting({});
     if (existsSync(TEST_DIR)) {
       rmSync(TEST_DIR, { recursive: true, force: true });
     }

package/src/__tests__/guardian-routing-state.test.ts

@@ -31,11 +31,6 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-// Mock security check to always pass
-mock.module("../security/secret-ingress.js", () => ({
-  checkIngressForSecrets: () => ({ blocked: false }),
-}));
-
 import { upsertContact } from "../contacts/contact-store.js";
 import { createGuardianBinding } from "../contacts/contacts-write.js";
 import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";

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

@@ -846,12 +846,12 @@ describe("host_bash — proxy delegation", () => {
   });
 
   test("propagates VELLUM_UNTRUSTED_SHELL env to proxy under CES lockdown", async () => {
-    // Enable CES shell lockdown
-    const origFlags = (mockConfig as Record<string, unknown>)
-      .assistantFeatureFlagValues;
-    (mockConfig as Record<string, unknown>).assistantFeatureFlagValues = {
+    // Enable CES shell lockdown via the override cache
+    const { _setOverridesForTesting } =
+      await import("../config/assistant-feature-flags.js");
+    _setOverridesForTesting({
       "feature_flags.ces-shell-lockdown.enabled": true,
-    };
+    });
 
     try {
       const proxyResult: ToolExecutionResult = {
@@ -875,8 +875,7 @@ describe("host_bash — proxy delegation", () => {
       expect(calls.length).toBe(1);
       expect(calls[0].input.env).toEqual({ VELLUM_UNTRUSTED_SHELL: "1" });
     } finally {
-      (mockConfig as Record<string, unknown>).assistantFeatureFlagValues =
-        origFlags;
+      _setOverridesForTesting({});
     }
   });
 

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

@@ -2,10 +2,9 @@
  * Tests for HTTP POST /v1/messages behavior after the legacy handleUserMessage
  * legacy entry point was retired.
  *
- * Secret ingress blocking has been ported to the HTTP path. Recording intent
- * interception has been deliberately retired — the HTTP path has dedicated
- * /v1/recording/* endpoints and the model handles recording-related messages
- * through the agent loop.
+ * Recording intent interception has been deliberately retired — the HTTP path
+ * has dedicated /v1/recording/* endpoints and the model handles
+ * recording-related messages through the agent loop.
  *
  * Approval reply interception has parity and is covered by
  * conversation-routes-guardian-reply.test.ts and send-endpoint-busy.test.ts.
@@ -121,12 +120,10 @@ mock.module("../runtime/trust-context-resolver.js", () => ({
   }),
 }));
 
-// Mock config to enable secret detection + ingress blocking
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     secretDetection: {
       enabled: true,
-      blockIngress: true,
       customPatterns: [],
       entropyThreshold: 3.5,
     },
@@ -238,103 +235,6 @@ async function sendMessage(
   );
 }
 
-// ============================================================================
-// SECRET INGRESS BLOCKING — now ported to HTTP path
-// ============================================================================
-describe("HTTP POST /v1/messages blocks secret ingress", () => {
-  beforeEach(() => {
-    routeGuardianReplyMock.mockClear();
-    listPendingByDestinationMock.mockClear();
-    listCanonicalMock.mockClear();
-    addMessageMock.mockClear();
-  });
-
-  test("handleSendMessage rejects messages containing Telegram bot token patterns", async () => {
-    const secretContent =
-      "Set up Telegram with my bot token 123456789:ABCDefGHIJklmnopQRSTuvwxyz012345678";
-    const persistUserMessage = mock(async () => "persisted-msg-id");
-    const runAgentLoop = mock(async () => undefined);
-    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
-
-    const res = await sendMessage(secretContent, conversation);
-
-    expect(res.status).toBe(422);
-    const body = (await res.json()) as {
-      accepted: boolean;
-      error: string;
-      message: string;
-      detectedTypes: string[];
-    };
-    expect(body.accepted).toBe(false);
-    expect(body.error).toBe("secret_blocked");
-    expect(body.detectedTypes.length).toBeGreaterThan(0);
-
-    // The message should NOT reach the agent loop
-    expect(persistUserMessage).toHaveBeenCalledTimes(0);
-    expect(runAgentLoop).toHaveBeenCalledTimes(0);
-  });
-
-  test("handleSendMessage rejects messages containing AWS credentials", async () => {
-    const secretContent =
-      "Here is my AWS key AKIAQRSTUVWXYZ123456 and secret wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY";
-    const persistUserMessage = mock(async () => "persisted-msg-id");
-    const runAgentLoop = mock(async () => undefined);
-    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
-
-    const res = await sendMessage(secretContent, conversation);
-
-    expect(res.status).toBe(422);
-    const body = (await res.json()) as {
-      accepted: boolean;
-      error: string;
-    };
-    expect(body.accepted).toBe(false);
-    expect(body.error).toBe("secret_blocked");
-
-    // The message should NOT reach the agent loop
-    expect(persistUserMessage).toHaveBeenCalledTimes(0);
-    expect(runAgentLoop).toHaveBeenCalledTimes(0);
-  });
-
-  test("handleSendMessage rejects messages containing Stripe live API keys", async () => {
-    const secretContent = "My Stripe key is sk_live_4eC39HqLyjWDarjtT1zdp7dc";
-    const persistUserMessage = mock(async () => "persisted-msg-id");
-    const runAgentLoop = mock(async () => undefined);
-    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
-
-    const res = await sendMessage(secretContent, conversation);
-
-    expect(res.status).toBe(422);
-    const body = (await res.json()) as {
-      accepted: boolean;
-      error: string;
-    };
-    expect(body.accepted).toBe(false);
-    expect(body.error).toBe("secret_blocked");
-
-    // The message should NOT reach the agent loop
-    expect(persistUserMessage).toHaveBeenCalledTimes(0);
-    expect(runAgentLoop).toHaveBeenCalledTimes(0);
-  });
-
-  test("handleSendMessage allows normal messages without secrets", async () => {
-    const normalContent = "What is the weather today?";
-    const persistUserMessage = mock(async () => "persisted-msg-id");
-    const runAgentLoop = mock(async () => undefined);
-    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
-
-    const res = await sendMessage(normalContent, conversation);
-
-    expect(res.status).toBe(202);
-    const body = (await res.json()) as { accepted: boolean };
-    expect(body.accepted).toBe(true);
-
-    // Normal messages proceed to the agent loop
-    expect(persistUserMessage).toHaveBeenCalledTimes(1);
-    expect(runAgentLoop).toHaveBeenCalledTimes(1);
-  });
-});
-
 // ============================================================================
 // RECORDING INTENT — deliberately NOT intercepted on HTTP path
 // ============================================================================

package/src/__tests__/inbound-invite-redemption.test.ts

@@ -35,10 +35,6 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-mock.module("../security/secret-ingress.js", () => ({
-  checkIngressForSecrets: () => ({ blocked: false }),
-}));
-
 mock.module("../config/env.js", () => ({
   isHttpAuthDisabled: () => true,
   getGatewayInternalBaseUrl: () => "http://127.0.0.1:7830",

package/src/__tests__/inline-skill-load-permissions.test.ts

@@ -18,6 +18,8 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
+
 // ── Mock setup (must be before any imports from the project) ──────────────
 
 const testDir = mkdtempSync(join(tmpdir(), "inline-skill-perm-test-"));
@@ -46,7 +48,6 @@ interface TestConfig {
   permissions: { mode: "strict" | "workspace" };
   skills: { load: { extraDirs: string[] } };
   sandbox: { enabled: boolean };
-  assistantFeatureFlagValues?: Record<string, boolean>;
   [key: string]: unknown;
 }
 
@@ -54,9 +55,6 @@ const testConfig: TestConfig = {
   permissions: { mode: "workspace" },
   skills: { load: { extraDirs: [] } },
   sandbox: { enabled: true },
-  assistantFeatureFlagValues: {
-    "feature_flags.inline-skill-commands.enabled": true,
-  },
 };
 
 mock.module("../config/loader.js", () => ({
@@ -118,9 +116,9 @@ describe("inline-command skill_load permissions", () => {
     clearCache();
     testConfig.permissions = { mode: "workspace" };
     testConfig.skills = { load: { extraDirs: [] } };
-    testConfig.assistantFeatureFlagValues = {
+    _setOverridesForTesting({
       "feature_flags.inline-skill-commands.enabled": true,
-    };
+    });
     try {
       rmSync(join(testDir, "protected", "trust.json"));
     } catch {
@@ -352,9 +350,9 @@ describe("inline-command skill_load permissions", () => {
       writeDynamicSkill("dynamic-flag-off", "Dynamic Flag Off Skill");
 
       // Disable the feature flag
-      testConfig.assistantFeatureFlagValues = {
+      _setOverridesForTesting({
         "feature_flags.inline-skill-commands.enabled": false,
-      };
+      });
 
       const result = await check(
         "skill_load",

package/src/__tests__/intent-routing.test.ts

@@ -53,8 +53,6 @@ mock.module("../util/logger.js", () => ({
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
-
-    assistantFeatureFlagValues: {},
     services: {
       inference: {
         mode: "your-own",
@@ -76,7 +74,6 @@ mock.module("../config/loader.js", () => ({
   invalidateConfigCache: () => {},
   getNestedValue: () => undefined,
   setNestedValue: () => {},
-  syncConfigToLockfile: () => {},
 }));
 
 // ── Import after mocks ───────────────────────────────────────────────
@@ -250,16 +247,6 @@ describe("Activation hints in skills catalog", () => {
     expect(line).toContain("voice-setup");
   });
 
-  test("orchestration skill includes hints and avoid-when in catalog line", () => {
-    const prompt = buildSystemPrompt();
-    const line = prompt
-      .split("\n")
-      .find((l) => l.includes("**orchestration**"));
-    expect(line).toBeDefined();
-    expect(line).toContain("parallel");
-    expect(line).toContain("Single-focus");
-  });
-
   test("browser skill includes hints in catalog line", () => {
     const prompt = buildSystemPrompt();
     const line = prompt.split("\n").find((l) => l.includes("**browser**"));

package/src/__tests__/jobs-store-qdrant-breaker.test.ts

@@ -0,0 +1,178 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+const testDir = mkdtempSync(join(tmpdir(), "jobs-store-qdrant-breaker-"));
+
+mock.module("../util/platform.js", () => ({
+  getDataDir: () => testDir,
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => join(testDir, "test.db"),
+  getLogPath: () => join(testDir, "test.log"),
+  ensureDataDir: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  loadConfig: () => ({}),
+  getConfig: () => ({}),
+  invalidateConfigCache: () => {},
+}));
+
+import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import {
+  claimMemoryJobs,
+  enqueueMemoryJob,
+  type MemoryJobType,
+} from "../memory/jobs-store.js";
+import {
+  _resetQdrantBreaker,
+  withQdrantBreaker,
+} from "../memory/qdrant-circuit-breaker.js";
+
+describe("claimMemoryJobs with Qdrant circuit breaker", () => {
+  beforeAll(() => {
+    initializeDb();
+  });
+
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM memory_jobs");
+    _resetQdrantBreaker();
+  });
+
+  afterAll(() => {
+    resetDb();
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  test("claims embed jobs when circuit breaker is closed (healthy)", () => {
+    enqueueMemoryJob("embed_segment", { segmentId: "seg-1" });
+    enqueueMemoryJob("embed_item", { itemId: "item-1" });
+    enqueueMemoryJob("extract_items", { conversationId: "conv-1" });
+
+    const claimed = claimMemoryJobs(10);
+    const types = claimed.map((j) => j.type);
+
+    expect(types).toContain("embed_segment");
+    expect(types).toContain("embed_item");
+    expect(types).toContain("extract_items");
+    expect(claimed).toHaveLength(3);
+  });
+
+  test("skips embed jobs when circuit breaker is open", async () => {
+    // Trip the circuit breaker by recording 5 consecutive failures
+    for (let i = 0; i < 5; i++) {
+      try {
+        await withQdrantBreaker(async () => {
+          throw new Error("simulated qdrant failure");
+        });
+      } catch {
+        // expected
+      }
+    }
+
+    enqueueMemoryJob("embed_segment", { segmentId: "seg-1" });
+    enqueueMemoryJob("embed_item", { itemId: "item-1" });
+    enqueueMemoryJob("embed_summary", { summaryId: "sum-1" });
+    enqueueMemoryJob("extract_items", { conversationId: "conv-1" });
+    enqueueMemoryJob("build_conversation_summary", {
+      conversationId: "conv-1",
+    });
+
+    const claimed = claimMemoryJobs(10);
+    const types = claimed.map((j) => j.type);
+
+    // Only non-embed jobs should be claimed
+    expect(types).toContain("extract_items");
+    expect(types).toContain("build_conversation_summary");
+    expect(types).not.toContain("embed_segment");
+    expect(types).not.toContain("embed_item");
+    expect(types).not.toContain("embed_summary");
+    expect(claimed).toHaveLength(2);
+  });
+
+  test("resumes claiming embed jobs after circuit breaker closes", async () => {
+    // Trip the circuit breaker
+    for (let i = 0; i < 5; i++) {
+      try {
+        await withQdrantBreaker(async () => {
+          throw new Error("simulated qdrant failure");
+        });
+      } catch {
+        // expected
+      }
+    }
+
+    // Verify embed jobs are skipped while open
+    enqueueMemoryJob("embed_segment", { segmentId: "seg-1" });
+    enqueueMemoryJob("extract_items", { conversationId: "conv-1" });
+
+    const claimedWhileOpen = claimMemoryJobs(10);
+    expect(claimedWhileOpen.map((j) => j.type)).not.toContain("embed_segment");
+
+    // Reset breaker (simulates successful probe closing the circuit)
+    _resetQdrantBreaker();
+
+    // Re-enqueue an embed job (the previous one is now "running")
+    enqueueMemoryJob("embed_item", { itemId: "item-2" });
+
+    const claimedAfterClose = claimMemoryJobs(10);
+    const types = claimedAfterClose.map((j) => j.type);
+
+    expect(types).toContain("embed_item");
+  });
+
+  test("all embed job types are skipped when breaker is open", async () => {
+    const embedTypes: MemoryJobType[] = [
+      "embed_segment",
+      "embed_item",
+      "embed_summary",
+      "embed_media",
+      "embed_attachment",
+    ];
+
+    // Trip the circuit breaker
+    for (let i = 0; i < 5; i++) {
+      try {
+        await withQdrantBreaker(async () => {
+          throw new Error("simulated qdrant failure");
+        });
+      } catch {
+        // expected
+      }
+    }
+
+    // Enqueue one of each embed type
+    for (const type of embedTypes) {
+      enqueueMemoryJob(type, { id: `test-${type}` });
+    }
+    // Also enqueue a non-embed job
+    enqueueMemoryJob("extract_entities", { conversationId: "conv-1" });
+
+    const claimed = claimMemoryJobs(20);
+    const types = claimed.map((j) => j.type);
+
+    // Only the non-embed job should be claimed
+    expect(claimed).toHaveLength(1);
+    expect(types).toEqual(["extract_entities"]);
+  });
+});