@vellumai/assistant 0.6.3 → 0.6.4

package/src/__tests__/openrouter-token-estimation.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, test } from "bun:test";
+
+import { estimatePromptTokens } from "../context/token-estimator.js";
+import { OpenRouterProvider } from "../providers/openrouter/client.js";
+import type { Message } from "../providers/types.js";
+
+/** Build a minimal valid PNG header encoding the given dimensions. */
+function makePngBase64(width: number, height: number, paddingBytes = 0): string {
+  const header = Buffer.alloc(24);
+  header[0] = 0x89;
+  header[1] = 0x50;
+  header[2] = 0x4e;
+  header[3] = 0x47;
+  header[4] = 0x0d;
+  header[5] = 0x0a;
+  header[6] = 0x1a;
+  header[7] = 0x0a;
+  header.writeUInt32BE(13, 8);
+  header[12] = 0x49;
+  header[13] = 0x48;
+  header[14] = 0x44;
+  header[15] = 0x52;
+  header.writeUInt32BE(width, 16);
+  header.writeUInt32BE(height, 20);
+  const padding = Buffer.alloc(paddingBytes, 0x42);
+  return Buffer.concat([header, padding]).toString("base64");
+}
+
+describe("OpenRouterProvider token estimation routing", () => {
+  test("reports 'anthropic' for anthropic/* default models", () => {
+    const provider = new OpenRouterProvider(
+      "fake-key",
+      "anthropic/claude-opus-4-6",
+    );
+    expect(provider.tokenEstimationProvider).toBe("anthropic");
+  });
+
+  test("reports its own name for non-Anthropic default models", () => {
+    const provider = new OpenRouterProvider("fake-key", "x-ai/grok-4.20-beta");
+    expect(provider.tokenEstimationProvider).toBe(provider.name);
+    expect(provider.tokenEstimationProvider).toBe("openrouter");
+  });
+
+  test("estimatePromptTokens applies Anthropic image scaling when routed via OpenRouter", () => {
+    const provider = new OpenRouterProvider(
+      "fake-key",
+      "anthropic/claude-opus-4-6",
+    );
+    // 1920x1080 screenshot with ~200 KB of pixel data → base64/4 would be ~65k
+    // tokens; dimension-based Anthropic rules land around 1.6k tokens.
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          {
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: "image/png",
+              data: makePngBase64(1920, 1080, 200_000),
+            },
+          },
+        ],
+      },
+    ];
+
+    const estimated = estimatePromptTokens(messages, "system", {
+      providerName: provider.tokenEstimationProvider,
+    });
+
+    // Dimension-based estimate should be well under 5k; base64/4 would exceed 50k.
+    expect(estimated).toBeLessThan(5_000);
+  });
+
+  test("estimatePromptTokens falls back to base64/4 for non-Anthropic OpenRouter models", () => {
+    const provider = new OpenRouterProvider("fake-key", "x-ai/grok-4.20-beta");
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          {
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: "image/png",
+              data: makePngBase64(1920, 1080, 200_000),
+            },
+          },
+        ],
+      },
+    ];
+
+    const estimated = estimatePromptTokens(messages, "system", {
+      providerName: provider.tokenEstimationProvider,
+    });
+
+    // Base64/4 heuristic on ~200 KB of image data → far more than 10k tokens.
+    expect(estimated).toBeGreaterThan(50_000);
+  });
+});

package/src/__tests__/outlook-unsubscribe.test.ts

@@ -91,15 +91,44 @@ function makeMessage(
 // ── Tests ────────────────────────────────────────────────────────────────────
 
 describe("outlook_unsubscribe", () => {
-  test("rejects when not triggered by surface action", async () => {
+  test("rejects when neither surface action nor batch-authorized task", async () => {
     const result = await run(
       { message_id: "msg-1", confidence: 0.9 },
-      makeContext({ triggeredBySurfaceAction: false }),
+      makeContext({
+        triggeredBySurfaceAction: false,
+        batchAuthorizedByTask: false,
+      }),
     );
     expect(result.isError).toBe(true);
     expect(result.content).toContain("surface action");
   });
 
+  test("allows scheduled task run with batchAuthorizedByTask", async () => {
+    mockResolveOAuthConnection.mockResolvedValueOnce(fakeConnection);
+    mockGetMessageWithHeaders.mockResolvedValueOnce(
+      makeMessage([
+        {
+          name: "List-Unsubscribe",
+          value: "<https://mail.example.com/unsubscribe?id=789>",
+        },
+      ]),
+    );
+    mockResolveRequestAddress.mockResolvedValueOnce({
+      addresses: ["93.184.216.34"],
+    });
+    mockPinnedHttpsRequest.mockResolvedValueOnce(200);
+
+    const result = await run(
+      { message_id: "msg-1", confidence: 0.9 },
+      makeContext({
+        triggeredBySurfaceAction: false,
+        batchAuthorizedByTask: true,
+      }),
+    );
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Successfully unsubscribed via HTTPS GET");
+  });
+
   test("returns error when message_id is missing", async () => {
     const result = await run({}, makeContext());
     expect(result.isError).toBe(true);

package/src/__tests__/persona-resolver.test.ts

@@ -0,0 +1,251 @@
+/**
+ * Tests for persona-resolver helpers used by the drop-user-md migration:
+ * `resolveGuardianPersonaPath` and `ensureGuardianPersonaFile`.
+ *
+ * The module under test reads/writes files under `getWorkspaceDir()`,
+ * so these tests stub `util/platform.js` to point at an ephemeral temp
+ * directory and stub `contacts/contact-store.js` to control which
+ * guardian (if any) is returned by the resolver.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+// ── Mock state ────────────────────────────────────────────────────
+
+let mockWorkspaceDir: string = "";
+let mockVellumGuardian:
+  | {
+      contact: { userFile: string | null };
+      channel: Record<string, unknown>;
+    }
+  | null = null;
+let mockAnyGuardian:
+  | {
+      contact: { userFile: string | null };
+      channels: Record<string, unknown>[];
+    }
+  | null = null;
+
+// ── Mock modules (must precede imports from the module under test) ──
+
+mock.module("../util/platform.js", () => ({
+  getWorkspaceDir: () => mockWorkspaceDir,
+}));
+
+mock.module("../contacts/contact-store.js", () => ({
+  findContactByChannelExternalId: () => null,
+  findGuardianForChannel: (channelType: string) =>
+    channelType === "vellum" ? mockVellumGuardian : null,
+  listGuardianChannels: () => mockAnyGuardian,
+}));
+
+// Import AFTER mocks so the module under test binds to the stubbed
+// implementations.
+import {
+  ensureGuardianPersonaFile,
+  isGuardianPersonaCustomized,
+  resolveGuardianPersona,
+  resolveGuardianPersonaPath,
+  resolveGuardianPersonaStrict,
+} from "../prompts/persona-resolver.js";
+
+// ── Temp workspace scaffold ───────────────────────────────────────
+
+let testRoot: string;
+
+beforeAll(() => {
+  testRoot = mkdtempSync(join(tmpdir(), "persona-resolver-test-"));
+});
+
+afterAll(() => {
+  rmSync(testRoot, { recursive: true, force: true });
+});
+
+beforeEach(() => {
+  // Fresh workspace per test, so filesystem state doesn't leak.
+  mockWorkspaceDir = mkdtempSync(join(testRoot, "ws-"));
+  mockVellumGuardian = null;
+  mockAnyGuardian = null;
+});
+
+afterEach(() => {
+  rmSync(mockWorkspaceDir, { recursive: true, force: true });
+});
+
+// ── resolveGuardianPersonaPath ─────────────────────────────────────
+
+describe("resolveGuardianPersonaPath", () => {
+  test("returns null when no guardian exists", () => {
+    mockVellumGuardian = null;
+    mockAnyGuardian = null;
+
+    expect(resolveGuardianPersonaPath()).toBeNull();
+  });
+
+  test("returns absolute path when guardian has userFile set", () => {
+    mockVellumGuardian = {
+      contact: { userFile: "sidd.md" },
+      channel: {},
+    };
+
+    const result = resolveGuardianPersonaPath();
+    expect(result).toBe(join(mockWorkspaceDir, "users", "sidd.md"));
+  });
+});
+
+// ── ensureGuardianPersonaFile ──────────────────────────────────────
+
+describe("ensureGuardianPersonaFile", () => {
+  test("writes the template when the file is missing", () => {
+    const userFile = "sidd.md";
+    const filePath = join(mockWorkspaceDir, "users", userFile);
+
+    expect(existsSync(filePath)).toBe(false);
+
+    ensureGuardianPersonaFile(userFile);
+
+    expect(existsSync(filePath)).toBe(true);
+    const content = readFileSync(filePath, "utf-8");
+    expect(content).toContain("# User Profile");
+    expect(content).toContain("Preferred name/reference:");
+    expect(content).toContain("Daily tools:");
+    // Sanity check the comment-line prefix survives verbatim.
+    expect(content.startsWith("_ Lines starting with _ are comments")).toBe(
+      true,
+    );
+  });
+
+  test("is a no-op when the file already exists (does not clobber)", () => {
+    const userFile = "sidd.md";
+    const dir = join(mockWorkspaceDir, "users");
+    const filePath = join(dir, userFile);
+    const existingContent = "# Existing user notes\n\n- Likes sparkling water\n";
+
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(filePath, existingContent, "utf-8");
+
+    ensureGuardianPersonaFile(userFile);
+
+    const content = readFileSync(filePath, "utf-8");
+    expect(content).toBe(existingContent);
+  });
+});
+
+// ── resolveGuardianPersonaStrict ───────────────────────────────────
+
+describe("resolveGuardianPersonaStrict", () => {
+  test("returns null when no guardian contact exists", () => {
+    mockVellumGuardian = null;
+    mockAnyGuardian = null;
+
+    expect(resolveGuardianPersonaStrict()).toBeNull();
+  });
+
+  test("returns null when the guardian's own file is missing, even if default.md exists", () => {
+    mockVellumGuardian = {
+      contact: { userFile: "sidd.md" },
+      channel: {},
+    };
+
+    // default.md is populated but sidd.md is not on disk.
+    const usersDir = join(mockWorkspaceDir, "users");
+    mkdirSync(usersDir, { recursive: true });
+    writeFileSync(
+      join(usersDir, "default.md"),
+      "- Preferred name/reference: DefaultName\n",
+      "utf-8",
+    );
+
+    // Strict variant must not leak default.md content.
+    expect(resolveGuardianPersonaStrict()).toBeNull();
+    // Sanity: the non-strict variant DOES fall back to default.md, which
+    // is the documented divergence these tests pin down.
+    expect(resolveGuardianPersona()).toContain("DefaultName");
+  });
+
+  test("returns guardian file content when present", () => {
+    mockVellumGuardian = {
+      contact: { userFile: "sidd.md" },
+      channel: {},
+    };
+
+    const usersDir = join(mockWorkspaceDir, "users");
+    mkdirSync(usersDir, { recursive: true });
+    writeFileSync(
+      join(usersDir, "sidd.md"),
+      "- Preferred name/reference: Sidd\n",
+      "utf-8",
+    );
+
+    expect(resolveGuardianPersonaStrict()).toContain("Sidd");
+  });
+});
+
+// ── isGuardianPersonaCustomized ────────────────────────────────────
+
+describe("isGuardianPersonaCustomized", () => {
+  test("returns false when the file does not exist", () => {
+    const filePath = join(mockWorkspaceDir, "users", "nobody.md");
+    expect(isGuardianPersonaCustomized(filePath)).toBe(false);
+  });
+
+  test("returns false for the bare scaffold template (no user edits)", () => {
+    const userFile = "sidd.md";
+    const filePath = join(mockWorkspaceDir, "users", userFile);
+
+    // ensureGuardianPersonaFile writes the canonical template — the
+    // exact bytes that "not customized" accepts.
+    ensureGuardianPersonaFile(userFile);
+
+    expect(isGuardianPersonaCustomized(filePath)).toBe(false);
+  });
+
+  test("returns false when the file contains only comment lines", () => {
+    const userFile = "sidd.md";
+    const dir = join(mockWorkspaceDir, "users");
+    const filePath = join(dir, userFile);
+
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      filePath,
+      "_ only comments here\n_ nothing meaningful\n",
+      "utf-8",
+    );
+
+    expect(isGuardianPersonaCustomized(filePath)).toBe(false);
+  });
+
+  test("returns true when the file has user-authored content", () => {
+    const userFile = "sidd.md";
+    const dir = join(mockWorkspaceDir, "users");
+    const filePath = join(dir, userFile);
+
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      filePath,
+      "# My profile\n\n- Preferred name/reference: Real User\n",
+      "utf-8",
+    );
+
+    expect(isGuardianPersonaCustomized(filePath)).toBe(true);
+  });
+});

package/src/__tests__/platform-bash-auto-approve.test.ts

@@ -99,8 +99,12 @@ mock.module("../permissions/checker.js", () => ({
     scopeOptionsOverride ?? [{ label: "/tmp", scope: "/tmp" }],
 }));
 
+// Mock every export so downstream test files that dynamically import modules
+// with a static `from "../memory/tool-usage-store.js"` still see all symbols.
 mock.module("../memory/tool-usage-store.js", () => ({
   recordToolInvocation: () => {},
+  getRecentInvocations: () => [],
+  rotateToolInvocations: () => 0,
 }));
 
 mock.module("../tools/registry.js", () => ({

package/src/__tests__/platform.test.ts

@@ -7,10 +7,13 @@ import {
   ensureDataDir,
   getDataDir,
   getDbPath,
+  getDotEnvPath,
   getHistoryPath,
   getInterfacesDir,
   getLogPath,
   getPidPath,
+  getProtectedDir,
+  getRuntimePortFilePath,
   getSandboxRootDir,
   getSandboxWorkingDir,
   getWorkspaceConfigPath,
@@ -18,9 +21,14 @@ import {
   getWorkspaceHooksDir,
   getWorkspacePromptPath,
   getWorkspaceSkillsDir,
+  getXdgPlatformTokenPath,
+  getXdgVellumConfigDirName,
 } from "../util/platform.js";
 
 const originalWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
+const originalBaseDataDir = process.env.BASE_DATA_DIR;
+const originalVellumEnvironment = process.env.VELLUM_ENVIRONMENT;
+const originalXdgConfigHome = process.env.XDG_CONFIG_HOME;
 
 afterEach(() => {
   if (originalWorkspaceDir == null) {
@@ -28,6 +36,21 @@ afterEach(() => {
   } else {
     process.env.VELLUM_WORKSPACE_DIR = originalWorkspaceDir;
   }
+  if (originalBaseDataDir == null) {
+    delete process.env.BASE_DATA_DIR;
+  } else {
+    process.env.BASE_DATA_DIR = originalBaseDataDir;
+  }
+  if (originalVellumEnvironment == null) {
+    delete process.env.VELLUM_ENVIRONMENT;
+  } else {
+    process.env.VELLUM_ENVIRONMENT = originalVellumEnvironment;
+  }
+  if (originalXdgConfigHome == null) {
+    delete process.env.XDG_CONFIG_HOME;
+  } else {
+    process.env.XDG_CONFIG_HOME = originalXdgConfigHome;
+  }
 });
 
 // Path characterization: documents the current path layout.
@@ -71,6 +94,25 @@ describe("path characterization", () => {
     expect(getPidPath()).toBe(join(homedir(), ".vellum", "vellum.pid"));
   });
 
+  test("BASE_DATA_DIR relocates vellumRoot()-derived paths", () => {
+    const saved = process.env.BASE_DATA_DIR;
+    process.env.BASE_DATA_DIR = "/tmp/fake-instance";
+    try {
+      delete process.env.VELLUM_WORKSPACE_DIR;
+      expect(getPidPath()).toBe("/tmp/fake-instance/.vellum/vellum.pid");
+      expect(getProtectedDir()).toBe("/tmp/fake-instance/.vellum/protected");
+      expect(getRuntimePortFilePath()).toBe(
+        "/tmp/fake-instance/.vellum/runtime-port",
+      );
+      expect(getDotEnvPath()).toBe("/tmp/fake-instance/.vellum/.env");
+      // Workspace transitively relocates via vellumRoot()
+      expect(getWorkspaceDir()).toBe("/tmp/fake-instance/.vellum/workspace");
+    } finally {
+      if (saved === undefined) delete process.env.BASE_DATA_DIR;
+      else process.env.BASE_DATA_DIR = saved;
+    }
+  });
+
   test("hooks directory is inside the workspace boundary", () => {
     delete process.env.VELLUM_WORKSPACE_DIR;
     expect(getWorkspaceHooksDir().startsWith(getWorkspaceDir())).toBe(true);
@@ -109,6 +151,56 @@ describe("path characterization", () => {
   });
 });
 
+describe("XDG platform-token path env-awareness", () => {
+  test("production returns ~/.config/vellum/platform-token", () => {
+    delete process.env.VELLUM_ENVIRONMENT;
+    delete process.env.XDG_CONFIG_HOME;
+    expect(getXdgVellumConfigDirName()).toBe("vellum");
+    expect(getXdgPlatformTokenPath()).toBe(
+      join(homedir(), ".config", "vellum", "platform-token"),
+    );
+  });
+
+  test("production (explicit) returns ~/.config/vellum/platform-token", () => {
+    process.env.VELLUM_ENVIRONMENT = "production";
+    delete process.env.XDG_CONFIG_HOME;
+    expect(getXdgVellumConfigDirName()).toBe("vellum");
+    expect(getXdgPlatformTokenPath()).toBe(
+      join(homedir(), ".config", "vellum", "platform-token"),
+    );
+  });
+
+  test("dev environment returns $XDG_CONFIG_HOME/vellum-dev/platform-token", () => {
+    process.env.VELLUM_ENVIRONMENT = "dev";
+    process.env.XDG_CONFIG_HOME = "/tmp/fake-xdg";
+    expect(getXdgVellumConfigDirName()).toBe("vellum-dev");
+    expect(getXdgPlatformTokenPath()).toBe(
+      "/tmp/fake-xdg/vellum-dev/platform-token",
+    );
+  });
+
+  test.each(["staging", "test", "local"])(
+    "%s environment returns env-scoped path",
+    (env) => {
+      process.env.VELLUM_ENVIRONMENT = env;
+      process.env.XDG_CONFIG_HOME = "/tmp/fake-xdg";
+      expect(getXdgVellumConfigDirName()).toBe(`vellum-${env}`);
+      expect(getXdgPlatformTokenPath()).toBe(
+        `/tmp/fake-xdg/vellum-${env}/platform-token`,
+      );
+    },
+  );
+
+  test("unknown environment falls back to production path", () => {
+    process.env.VELLUM_ENVIRONMENT = "no-such-env";
+    process.env.XDG_CONFIG_HOME = "/tmp/fake-xdg";
+    expect(getXdgVellumConfigDirName()).toBe("vellum");
+    expect(getXdgPlatformTokenPath()).toBe(
+      "/tmp/fake-xdg/vellum/platform-token",
+    );
+  });
+});
+
 describe("workspace path primitives", () => {
   test("workspace helpers resolve under workspace dir", () => {
     delete process.env.VELLUM_WORKSPACE_DIR;
@@ -119,6 +211,5 @@ describe("workspace path primitives", () => {
     expect(getWorkspaceHooksDir()).toBe(join(ws, "hooks"));
     expect(getWorkspacePromptPath("IDENTITY.md")).toBe(join(ws, "IDENTITY.md"));
     expect(getWorkspacePromptPath("SOUL.md")).toBe(join(ws, "SOUL.md"));
-    expect(getWorkspacePromptPath("USER.md")).toBe(join(ws, "USER.md"));
   });
 });

package/src/__tests__/post-turn-tool-result-truncation.test.ts

@@ -294,3 +294,50 @@ describe("derefToolResultReReads", () => {
     expect(b2.content).toBe("normal read content"); // unchanged
   });
 });
+
+function hasOrphanedSurrogate(str: string): boolean {
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    if (code >= 0xd800 && code <= 0xdbff) {
+      const next = i + 1 < str.length ? str.charCodeAt(i + 1) : 0;
+      if (next < 0xdc00 || next > 0xdfff) return true;
+      i++;
+    } else if (code >= 0xdc00 && code <= 0xdfff) {
+      return true;
+    }
+  }
+  return false;
+}
+
+describe("buildTruncatedContent surrogate-pair safety", () => {
+  const EMOJI = "\uD83C\uDF89";
+  const half = Math.floor(TARGET_CHARS / 2);
+
+  test("does not orphan a surrogate pair at the prefix cut boundary", () => {
+    // Put the emoji so its high surrogate lands exactly at position half - 1.
+    // The naive slice(0, half) would cut the pair in half.
+    const prefix = "a".repeat(half - 1);
+    const filler = "b".repeat(10_000);
+    const original = prefix + EMOJI + filler;
+    const result = buildTruncatedContent(original, "/tmp/fake");
+    expect(hasOrphanedSurrogate(result)).toBe(false);
+    expect(() => JSON.stringify(result)).not.toThrow();
+  });
+
+  test("does not orphan a surrogate pair at the suffix cut boundary", () => {
+    // Put the emoji so its low surrogate lands exactly at position
+    // original.length - half (the start of the suffix slice). Naive
+    // slice(-half) would start mid-pair and leave a lone low surrogate.
+    const head = "a".repeat(10_000);
+    const suffixTail = "b".repeat(half - 1);
+    // head + EMOJI (2 code units) + suffixTail has length
+    // 10_000 + 2 + (half - 1). The suffix starts at length - half, which
+    // equals 10_000 + 2 + (half - 1) - half = 10_001. That lands on the
+    // low surrogate of the emoji (emoji starts at position 10_000, high at
+    // 10_000, low at 10_001). Exactly the orphan case.
+    const original = head + EMOJI + suffixTail;
+    const result = buildTruncatedContent(original, "/tmp/fake");
+    expect(hasOrphanedSurrogate(result)).toBe(false);
+    expect(() => JSON.stringify(result)).not.toThrow();
+  });
+});