@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

package/src/__tests__/config-set-route.test.ts

@@ -4,52 +4,14 @@
  * handlers directly (Codex review feedback on PR #30262).
  */
 
+import { utimesSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { describe, expect, mock, test } from "bun:test";
 
-import { makeMockLogger } from "./helpers/mock-logger.js";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
-
 // ---------------------------------------------------------------------------
 // Mocks for handleSetConfig's transitive deps
 // ---------------------------------------------------------------------------
 
-let savedRaw: Record<string, unknown> | null = null;
-let rawConfig: Record<string, unknown> = {};
-
-mock.module("../config/loader.js", () => ({
-  loadRawConfig: () => structuredClone(rawConfig),
-  saveRawConfig: (raw: Record<string, unknown>) => {
-    savedRaw = raw;
-  },
-  deepMergeOverwrite: () => {},
-  getConfig: () => rawConfig,
-  invalidateConfigCache: () => {},
-  withSuppressedConfigDiskWrites: async (fn: () => unknown) => fn(),
-  withSuppressedConfigDiskWritesSync: (fn: () => unknown) => fn(),
-  // setNestedValue is also exported by loader; handleSetConfig imports the
-  // real one from this module, so we re-export a thin implementation that
-  // mutates in place (matches loader's behavior).
-  setNestedValue: (
-    obj: Record<string, unknown>,
-    path: string,
-    value: unknown,
-  ) => {
-    const keys = path.split(".");
-    let current: Record<string, unknown> = obj;
-    for (let i = 0; i < keys.length - 1; i++) {
-      const key = keys[i]!;
-      if (current[key] == null || typeof current[key] !== "object") {
-        current[key] = {};
-      }
-      current = current[key] as Record<string, unknown>;
-    }
-    current[keys[keys.length - 1]!] = value;
-  },
-}));
-
 mock.module("../providers/registry.js", () => ({
   initializeProviders: async () => {},
 }));
@@ -78,9 +40,26 @@ mock.module("../security/secret-allowlist.js", () => ({
   },
 }));
 
+import { loadRawConfig } from "../config/loader.js";
 import { ROUTES } from "../runtime/routes/conversation-query-routes.js";
 import { BadRequestError } from "../runtime/routes/errors.js";
 
+/**
+ * Replace the workspace config.json with exactly `config`. The route under
+ * test edits the raw file wholesale, so each test starts from a complete
+ * known file state rather than composing per-key seeds. Bumps the mtime
+ * monotonically so the loader's file-signature cache re-reads (same trick as
+ * helpers/set-config.ts).
+ */
+let mtimeSeq = 0;
+function seedRawConfig(config: Record<string, unknown>): void {
+  const path = join(process.env.VELLUM_WORKSPACE_DIR!, "config.json");
+  writeFileSync(path, JSON.stringify(config));
+  mtimeSeq += 1;
+  const stamp = new Date(Date.now() + mtimeSeq);
+  utimesSync(path, stamp, stamp);
+}
+
 const configSetRoute = ROUTES.find((r) => r.operationId === "config_set")!;
 const allowlistRoute = ROUTES.find(
   (r) => r.operationId === "config_allowlist_validate",
@@ -103,15 +82,12 @@ describe("config_set route - request validation", () => {
   });
 
   test("accepts body with explicit null value", async () => {
-    rawConfig = { heartbeat: { activeHoursStart: "09:00" } };
-    savedRaw = null;
+    seedRawConfig({ heartbeat: { activeHoursStart: 9 } });
     const result = await configSetRoute.handler({
       body: { path: "heartbeat.activeHoursStart", value: null },
     });
     expect(result).toEqual({ ok: true });
-    expect(savedRaw).not.toBeNull();
-    const heartbeat = (savedRaw as unknown as Record<string, unknown>)
-      .heartbeat as Record<string, unknown>;
+    const heartbeat = loadRawConfig().heartbeat as Record<string, unknown>;
     expect(heartbeat.activeHoursStart).toBeNull();
   });
 
@@ -138,19 +114,17 @@ describe("config_set route - request validation", () => {
   });
 
   test("accepts a normal scalar set and writes to raw config", async () => {
-    rawConfig = {};
-    savedRaw = null;
+    seedRawConfig({});
     const result = await configSetRoute.handler({
       body: { path: "calls.enabled", value: true },
     });
     expect(result).toEqual({ ok: true });
-    const calls = (savedRaw as unknown as Record<string, unknown>)
-      .calls as Record<string, unknown>;
+    const calls = loadRawConfig().calls as Record<string, unknown>;
     expect(calls.enabled).toBe(true);
   });
 
   test("preserves user profiles and custom settings when setting unrelated key", async () => {
-    rawConfig = {
+    seedRawConfig({
       llm: {
         activeProfile: "my-custom-profile",
         profiles: {
@@ -170,8 +144,7 @@ describe("config_set route - request validation", () => {
       memory: {
         embeddings: { provider: "openai" },
       },
-    };
-    savedRaw = null;
+    });
     const result = await configSetRoute.handler({
       body: {
         path: "memory.cleanup.llmRequestLogRetentionMs",
@@ -179,9 +152,8 @@ describe("config_set route - request validation", () => {
       },
     });
     expect(result).toEqual({ ok: true });
-    expect(savedRaw).not.toBeNull();
 
-    const saved = savedRaw as unknown as Record<string, unknown>;
+    const saved = loadRawConfig();
     const llm = saved.llm as Record<string, unknown>;
     expect(llm.activeProfile).toBe("my-custom-profile");
 
@@ -208,22 +180,20 @@ describe("config_set route - request validation", () => {
   });
 
   test("preserves all top-level keys when setting a nested path", async () => {
-    rawConfig = {
+    seedRawConfig({
       llm: { default: { provider: "anthropic" } },
       calls: { enabled: true },
-      heartbeat: { activeHoursStart: "09:00", activeHoursEnd: "22:00" },
-    };
-    savedRaw = null;
+      heartbeat: { activeHoursStart: 9, activeHoursEnd: 22 },
+    });
     await configSetRoute.handler({
       body: { path: "memory.cleanup.conversationRetentionDays", value: 30 },
     });
-    expect(savedRaw).not.toBeNull();
-    const saved = savedRaw as unknown as Record<string, unknown>;
+    const saved = loadRawConfig();
     expect(saved.llm).toEqual({ default: { provider: "anthropic" } });
     expect(saved.calls).toEqual({ enabled: true });
     expect(saved.heartbeat).toEqual({
-      activeHoursStart: "09:00",
-      activeHoursEnd: "22:00",
+      activeHoursStart: 9,
+      activeHoursEnd: 22,
     });
   });
 });

package/src/__tests__/config-watcher-cleanup-throttle.test.ts

@@ -23,8 +23,10 @@
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { getConfig } from "../config/loader.js";
 import type { MemoryCleanupConfig } from "../config/schemas/memory-lifecycle.js";
 import { cleanupSettingsChanged } from "../daemon/config-watcher.js";
+import { setConfig } from "./helpers/set-config.js";
 
 // ---------------------------------------------------------------------------
 // 1. Pure helper test — cleanupSettingsChanged
@@ -118,65 +120,30 @@ mock.module("../persistence/cleanup-schedule-state.js", () => ({
   markScheduledCleanupEnqueued: () => {},
 }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (v: string) => v,
-}));
-
-// Simulate a config-cache layer: `diskConfig` is the on-disk value and
-// `cachedConfig` is the in-memory value returned by getConfig() when present.
-// Tests mutate `diskConfig` to simulate a user writing a new config.json.
-interface TestConfig {
-  memory: {
+// Seed `memory.cleanup` in the real workspace config.json. Each call replaces
+// the whole `memory` key, so tests simulate a user writing a new config.json
+// by re-seeding with different cleanup values; the real loader cache picks the
+// change up on the next getConfig() after invalidation (or via the file
+// signature check).
+function seedCleanup(
+  overrides: Partial<{
     enabled: boolean;
+    supersededItemRetentionMs: number;
+    conversationRetentionDays: number;
+    llmRequestLogRetentionMs: number | null;
+  }> = {},
+): void {
+  setConfig("memory", {
     cleanup: {
-      enabled: boolean;
-      supersededItemRetentionMs: number;
-      conversationRetentionDays: number;
-      llmRequestLogRetentionMs: number | null;
-    };
-  };
-}
-
-let diskConfig: TestConfig = makeConfig();
-let cachedConfig: TestConfig | null = null;
-
-function makeConfig(
-  overrides: Partial<TestConfig["memory"]["cleanup"]> = {},
-): TestConfig {
-  return {
-    memory: {
       enabled: true,
-      cleanup: {
-        enabled: true,
-        supersededItemRetentionMs: 30 * 24 * 60 * 60 * 1000,
-        conversationRetentionDays: 0,
-        llmRequestLogRetentionMs: 1 * 24 * 60 * 60 * 1000,
-        ...overrides,
-      },
+      supersededItemRetentionMs: 30 * 24 * 60 * 60 * 1000,
+      conversationRetentionDays: 0,
+      llmRequestLogRetentionMs: 1 * 24 * 60 * 60 * 1000,
+      ...overrides,
     },
-  };
-}
-
-function primeConfigCache(): void {
-  cachedConfig = diskConfig;
+  });
 }
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => {
-    if (!cachedConfig) {
-      cachedConfig = diskConfig;
-    }
-    return cachedConfig;
-  },
-  invalidateConfigCache: () => {
-    cachedConfig = null;
-  },
-}));
-
 mock.module("../config/assistant-feature-flags.js", () => ({
   clearFeatureFlagOverridesCache: () => {},
 }));
@@ -219,21 +186,18 @@ const { ConfigWatcher } = await import("../daemon/config-watcher.js");
 describe("ConfigWatcher.refreshConfigFromSources cleanup throttle reset", () => {
   beforeEach(() => {
     resetCleanupScheduleThrottleCalls = 0;
-    diskConfig = makeConfig();
-    cachedConfig = null;
+    seedCleanup();
   });
 
   test("resets throttle when llmRequestLogRetentionMs changes", async () => {
     const watcher = new ConfigWatcher();
-    // Seed the initial fingerprint and prime the cache so refreshConfigFromSources
-    // can compare the prev (cached) and next (fresh-from-disk) snapshots.
-    watcher.initFingerprint(diskConfig as never);
-    primeConfigCache();
-
-    // Simulate user changing retention from 1d to 7d via the UI — this
-    // writes to disk and is ONLY visible to getConfig() after a cache
-    // invalidation.
-    diskConfig = makeConfig({
+    // Seed the initial fingerprint (this also primes the loader cache) so
+    // refreshConfigFromSources can compare the prev and next snapshots.
+    watcher.initFingerprint(getConfig());
+
+    // Simulate the user changing retention from 1d to 7d via the UI — this
+    // writes config.json for real.
+    seedCleanup({
       llmRequestLogRetentionMs: 7 * 24 * 60 * 60 * 1000,
     });
 
@@ -244,12 +208,14 @@ describe("ConfigWatcher.refreshConfigFromSources cleanup throttle reset", () =>
 
   test("resets throttle when the loader cache has already observed the disk change", async () => {
     const watcher = new ConfigWatcher();
-    watcher.initFingerprint(diskConfig as never);
+    watcher.initFingerprint(getConfig());
 
-    diskConfig = makeConfig({
+    seedCleanup({
       llmRequestLogRetentionMs: 7 * 24 * 60 * 60 * 1000,
     });
-    cachedConfig = null;
+    // The loader's file-signature check re-reads the changed file on this
+    // access, so the cache already holds the new config before the refresh.
+    getConfig();
 
     const changed = await watcher.refreshConfigFromSources();
     expect(changed).toBe(true);
@@ -258,10 +224,9 @@ describe("ConfigWatcher.refreshConfigFromSources cleanup throttle reset", () =>
 
   test("does NOT reset throttle when config is identical (no fingerprint change)", async () => {
     const watcher = new ConfigWatcher();
-    watcher.initFingerprint(diskConfig as never);
-    primeConfigCache();
+    watcher.initFingerprint(getConfig());
 
-    // No change: diskConfig is the same value.
+    // No change: config.json keeps the same value.
     const changed = await watcher.refreshConfigFromSources();
     expect(changed).toBe(false);
     expect(resetCleanupScheduleThrottleCalls).toBe(0);
@@ -269,13 +234,12 @@ describe("ConfigWatcher.refreshConfigFromSources cleanup throttle reset", () =>
 
   test("does NOT reset throttle when an unrelated cleanup field changes", async () => {
     const watcher = new ConfigWatcher();
-    watcher.initFingerprint(diskConfig as never);
-    primeConfigCache();
+    watcher.initFingerprint(getConfig());
 
     // supersededItemRetentionMs is a daemon tunable, not a user-facing
     // setting. The fingerprint changes but the tracked cleanup retention
     // fields don't, so the throttle should NOT be reset.
-    diskConfig = makeConfig({ supersededItemRetentionMs: 0 });
+    seedCleanup({ supersededItemRetentionMs: 60_000 });
 
     const changed = await watcher.refreshConfigFromSources();
     expect(changed).toBe(true);
@@ -284,10 +248,9 @@ describe("ConfigWatcher.refreshConfigFromSources cleanup throttle reset", () =>
 
   test("resets throttle when conversationRetentionDays changes", async () => {
     const watcher = new ConfigWatcher();
-    watcher.initFingerprint(diskConfig as never);
-    primeConfigCache();
+    watcher.initFingerprint(getConfig());
 
-    diskConfig = makeConfig({ conversationRetentionDays: 30 });
+    seedCleanup({ conversationRetentionDays: 30 });
 
     const changed = await watcher.refreshConfigFromSources();
     expect(changed).toBe(true);
@@ -296,10 +259,9 @@ describe("ConfigWatcher.refreshConfigFromSources cleanup throttle reset", () =>
 
   test("resets throttle when llmRequestLogRetentionMs changes from number to null", async () => {
     const watcher = new ConfigWatcher();
-    watcher.initFingerprint(diskConfig as never);
-    primeConfigCache();
+    watcher.initFingerprint(getConfig());
 
-    diskConfig = makeConfig({ llmRequestLogRetentionMs: null });
+    seedCleanup({ llmRequestLogRetentionMs: null });
 
     const changed = await watcher.refreshConfigFromSources();
     expect(changed).toBe(true);
@@ -317,12 +279,11 @@ describe("ConfigWatcher.refreshConfigFromSources cleanup throttle reset", () =>
     // internal state. memory-jobs-worker-backoff tests cover the
     // jobs-worker throttle semantics independently.
     const watcher = new ConfigWatcher();
-    watcher.initFingerprint(diskConfig as never);
-    primeConfigCache();
+    watcher.initFingerprint(getConfig());
 
     expect(resetCleanupScheduleThrottleCalls).toBe(0);
 
-    diskConfig = makeConfig({
+    seedCleanup({
       llmRequestLogRetentionMs: 3 * 24 * 60 * 60 * 1000,
     });
     await watcher.refreshConfigFromSources();
@@ -330,7 +291,7 @@ describe("ConfigWatcher.refreshConfigFromSources cleanup throttle reset", () =>
 
     // Changing retention again should trigger another reset, confirming
     // the wiring holds up for repeated edits.
-    diskConfig = makeConfig({
+    seedCleanup({
       llmRequestLogRetentionMs: 14 * 24 * 60 * 60 * 1000,
     });
     await watcher.refreshConfigFromSources();

package/src/__tests__/config-watcher-skill-reseed.test.ts

@@ -15,14 +15,6 @@ const WORKSPACE_DIR = mkdtempSync(join(tmpdir(), "vellum-skills-watch-"));
 const SKILLS_DIR = join(WORKSPACE_DIR, "skills");
 process.env.VELLUM_WORKSPACE_DIR = WORKSPACE_DIR;
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (v: string) => v,
-}));
-
 type WatchCallback = (eventType: string, filename: string | null) => void;
 
 interface CapturedWatcher {
@@ -75,14 +67,6 @@ mock.module("node:fs", () => {
   };
 });
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-    memory: { v2: { enabled: false } },
-  }),
-  invalidateConfigCache: () => {},
-}));
-
 mock.module("../persistence/embeddings/embedding-backend.js", () => ({
   clearEmbeddingBackendCache: () => {},
 }));

package/src/__tests__/config-watcher.test.ts

@@ -20,14 +20,6 @@ const WORKSPACE_DIR = process.env.VELLUM_WORKSPACE_DIR!;
 // Mock platform paths
 // ---------------------------------------------------------------------------
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (v: string) => v,
-}));
-
 // ---------------------------------------------------------------------------
 // Capture fs.watch and fs.watchFile calls so we can simulate file system
 // events deterministically. Bun's libuv-based fs.watchFile is too unreliable
@@ -96,15 +88,8 @@ mock.module("node:fs", () => {
   };
 });
 
-// Mock config/loader and other dependencies that ConfigWatcher imports
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-  }),
-  loadConfig: () => ({ ui: {} }),
-  invalidateConfigCache: () => {},
-}));
-
+// Mock dependencies that ConfigWatcher imports. The real config loader is
+// used — nothing here depends on non-default config values.
 mock.module("../persistence/embeddings/embedding-backend.js", () => ({
   clearEmbeddingBackendCache: () => {},
 }));