@vellumai/assistant 0.6.2 → 0.6.4

package/src/__tests__/device-id.test.ts

@@ -0,0 +1,112 @@
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// Suppress logger output before importing the module under test.
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { getDeviceId, resetDeviceIdCache } from "../util/device-id.js";
+
+const originalVellumEnvironment = process.env.VELLUM_ENVIRONMENT;
+const originalXdgConfigHome = process.env.XDG_CONFIG_HOME;
+const originalIsContainerized = process.env.IS_CONTAINERIZED;
+
+let tempDir: string;
+
+beforeEach(() => {
+  tempDir = mkdtempSync(join(tmpdir(), "vellum-device-id-test-"));
+  resetDeviceIdCache();
+});
+
+afterEach(() => {
+  resetDeviceIdCache();
+
+  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;
+  }
+  if (originalIsContainerized == null) {
+    delete process.env.IS_CONTAINERIZED;
+  } else {
+    process.env.IS_CONTAINERIZED = originalIsContainerized;
+  }
+
+  try {
+    rmSync(tempDir, { recursive: true, force: true });
+  } catch {
+    /* best-effort */
+  }
+});
+
+describe("getDeviceId env-awareness", () => {
+  test("non-prod (dev) writes device.json under $XDG_CONFIG_HOME/vellum-dev", () => {
+    // Guarantee we're not containerized — the test-preload deletes this,
+    // but be defensive.
+    delete process.env.IS_CONTAINERIZED;
+    process.env.VELLUM_ENVIRONMENT = "dev";
+    process.env.XDG_CONFIG_HOME = tempDir;
+
+    const id = getDeviceId();
+    expect(typeof id).toBe("string");
+    expect(id.length).toBeGreaterThan(0);
+
+    const expectedPath = join(tempDir, "vellum-dev", "device.json");
+    expect(existsSync(expectedPath)).toBe(true);
+
+    const parsed = JSON.parse(readFileSync(expectedPath, "utf-8"));
+    expect(parsed.deviceId).toBe(id);
+  });
+
+  test("staging environment writes under $XDG_CONFIG_HOME/vellum-staging", () => {
+    delete process.env.IS_CONTAINERIZED;
+    process.env.VELLUM_ENVIRONMENT = "staging";
+    process.env.XDG_CONFIG_HOME = tempDir;
+
+    getDeviceId();
+
+    const expectedPath = join(tempDir, "vellum-staging", "device.json");
+    expect(existsSync(expectedPath)).toBe(true);
+  });
+
+  test("unknown environment does NOT write under $XDG_CONFIG_HOME/vellum-<unknown>", () => {
+    // Unknown env names fall back to the legacy production behavior.
+    // We can't assert the exact legacy path without mocking homedir(),
+    // but we can assert that the XDG env-scoped dir is NOT created.
+    delete process.env.IS_CONTAINERIZED;
+    process.env.VELLUM_ENVIRONMENT = "no-such-env";
+    process.env.XDG_CONFIG_HOME = tempDir;
+
+    getDeviceId();
+
+    // No `vellum-no-such-env` directory created under our XDG tempdir.
+    const envScopedPath = join(tempDir, "vellum-no-such-env", "device.json");
+    expect(existsSync(envScopedPath)).toBe(false);
+    // Legacy fallback would write under `${homedir()}/.vellum` — not touched.
+    const productionXdgPath = join(tempDir, "vellum", "device.json");
+    expect(existsSync(productionXdgPath)).toBe(false);
+  });
+
+  test("production does NOT write under $XDG_CONFIG_HOME/vellum", () => {
+    // Production path is ~/.vellum/device.json, never XDG_CONFIG_HOME.
+    delete process.env.IS_CONTAINERIZED;
+    delete process.env.VELLUM_ENVIRONMENT;
+    process.env.XDG_CONFIG_HOME = tempDir;
+
+    getDeviceId();
+
+    const xdgPath = join(tempDir, "vellum", "device.json");
+    expect(existsSync(xdgPath)).toBe(false);
+  });
+});

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

@@ -1,9 +1,17 @@
 /**
- * Tests for resolveSigningKey() covering env var injection (Docker)
- * and file-based load/create (local mode).
+ * Tests for resolveSigningKey() covering env var injection (Docker),
+ * file-based load/create (local mode), and env-to-disk sync for CLI
+ * signing-key convergence.
  */
 
-import { existsSync, rmSync } from "node:fs";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../util/logger.js", () => ({
@@ -13,7 +21,15 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-const { resolveSigningKey } = await import("../runtime/auth/token-service.js");
+const {
+  resolveSigningKey,
+  initAuthSigningKey,
+  loadSigningKey,
+  mintToken,
+  verifyToken,
+  _resetSigningKeyForTesting,
+} = await import("../runtime/auth/token-service.js");
+const { CURRENT_POLICY_EPOCH } = await import("../runtime/auth/policy.js");
 const { getDeprecatedDir } = await import("../util/platform.js");
 
 const VALID_HEX_KEY = "ab".repeat(32); // 64 hex chars = 32 bytes
@@ -22,6 +38,7 @@ const savedEnv: Record<string, string | undefined> = {};
 
 beforeEach(() => {
   savedEnv.ACTOR_TOKEN_SIGNING_KEY = process.env.ACTOR_TOKEN_SIGNING_KEY;
+  savedEnv.IS_CONTAINERIZED = process.env.IS_CONTAINERIZED;
   // Clean up key files from previous tests so they don't leak between cases.
   const deprecatedDir = getDeprecatedDir();
   if (existsSync(deprecatedDir))
@@ -34,6 +51,13 @@ afterEach(() => {
   } else {
     process.env.ACTOR_TOKEN_SIGNING_KEY = savedEnv.ACTOR_TOKEN_SIGNING_KEY;
   }
+  if (savedEnv.IS_CONTAINERIZED === undefined) {
+    delete process.env.IS_CONTAINERIZED;
+  } else {
+    process.env.IS_CONTAINERIZED = savedEnv.IS_CONTAINERIZED;
+  }
+  // Reset signing key so interop tests don't leak state
+  _resetSigningKeyForTesting();
 });
 
 describe("resolveSigningKey", () => {
@@ -76,3 +100,142 @@ describe("resolveSigningKey", () => {
     expect(key2.toString("hex")).not.toBe(key1.toString("hex"));
   });
 });
+
+// ---------------------------------------------------------------------------
+// Env-to-disk signing key sync
+// ---------------------------------------------------------------------------
+
+describe("env-to-disk signing key sync", () => {
+  test("env key syncs to canonical disk path in non-containerized mode", () => {
+    delete process.env.IS_CONTAINERIZED;
+    process.env.ACTOR_TOKEN_SIGNING_KEY = VALID_HEX_KEY;
+
+    const key = resolveSigningKey();
+
+    expect(key.toString("hex")).toBe(VALID_HEX_KEY);
+
+    const keyPath = join(getDeprecatedDir(), "actor-token-signing-key");
+    expect(existsSync(keyPath)).toBe(true);
+    const diskKey = readFileSync(keyPath);
+    expect(diskKey.length).toBe(32);
+    expect(diskKey.toString("hex")).toBe(VALID_HEX_KEY);
+  });
+
+  test("env key does NOT sync to disk in containerized mode", () => {
+    process.env.IS_CONTAINERIZED = "true";
+    process.env.ACTOR_TOKEN_SIGNING_KEY = VALID_HEX_KEY;
+
+    const key = resolveSigningKey();
+
+    expect(key.toString("hex")).toBe(VALID_HEX_KEY);
+
+    const keyPath = join(getDeprecatedDir(), "actor-token-signing-key");
+    expect(existsSync(keyPath)).toBe(false);
+  });
+
+  test("mismatched disk key is updated to env key in non-containerized mode", () => {
+    delete process.env.IS_CONTAINERIZED;
+
+    // Write a mismatched key to disk first
+    const keyPath = join(getDeprecatedDir(), "actor-token-signing-key");
+    const dir = dirname(keyPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    const mismatchedKey = Buffer.from("ff".repeat(32), "hex");
+    writeFileSync(keyPath, mismatchedKey, { mode: 0o600 });
+
+    // Set a different env key
+    process.env.ACTOR_TOKEN_SIGNING_KEY = VALID_HEX_KEY;
+
+    const key = resolveSigningKey();
+    expect(key.toString("hex")).toBe(VALID_HEX_KEY);
+
+    // Disk key should now match env key
+    const diskKey = readFileSync(keyPath);
+    expect(diskKey.toString("hex")).toBe(VALID_HEX_KEY);
+  });
+
+  test("matching disk key is not rewritten (no-op)", () => {
+    delete process.env.IS_CONTAINERIZED;
+    process.env.ACTOR_TOKEN_SIGNING_KEY = VALID_HEX_KEY;
+
+    // First call writes the key
+    resolveSigningKey();
+    const keyPath = join(getDeprecatedDir(), "actor-token-signing-key");
+    expect(existsSync(keyPath)).toBe(true);
+
+    // Second call with same key should not throw or fail
+    const key2 = resolveSigningKey();
+    expect(key2.toString("hex")).toBe(VALID_HEX_KEY);
+
+    const diskKey = readFileSync(keyPath);
+    expect(diskKey.toString("hex")).toBe(VALID_HEX_KEY);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Signature interoperability between daemon (env key) and CLI (disk key)
+// ---------------------------------------------------------------------------
+
+describe("daemon/CLI signing key interoperability", () => {
+  test("token minted via CLI disk-load path verifies with daemon env key after sync", () => {
+    delete process.env.IS_CONTAINERIZED;
+
+    // Pre-seed a mismatched "legacy" disk key to simulate the pre-fix state
+    const keyPath = join(getDeprecatedDir(), "actor-token-signing-key");
+    const dir = dirname(keyPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    const legacyKey = Buffer.from("ee".repeat(32), "hex");
+    writeFileSync(keyPath, legacyKey, { mode: 0o600 });
+
+    // --- Daemon startup path ---
+    // Set the env key and call resolveSigningKey (daemon behavior).
+    // This syncs the env key to disk.
+    process.env.ACTOR_TOKEN_SIGNING_KEY = VALID_HEX_KEY;
+    const daemonKey = resolveSigningKey();
+    initAuthSigningKey(daemonKey);
+
+    // Mint a token using the daemon's key
+    const daemonToken = mintToken({
+      aud: "vellum-daemon",
+      sub: "svc:daemon:self",
+      scope_profile: "gateway_service_v1",
+      policy_epoch: CURRENT_POLICY_EPOCH,
+      ttlSeconds: 60,
+    });
+
+    // --- CLI subprocess path ---
+    // Reset signing key to simulate a fresh CLI subprocess context
+    _resetSigningKeyForTesting();
+
+    // CLI loads key from disk (post-sync, disk now matches env key)
+    const cliDiskKey = loadSigningKey();
+    expect(cliDiskKey).toBeDefined();
+    initAuthSigningKey(cliDiskKey!);
+
+    // Mint a token using the CLI's disk-loaded key
+    const cliToken = mintToken({
+      aud: "vellum-daemon",
+      sub: "svc:daemon:self",
+      scope_profile: "gateway_service_v1",
+      policy_epoch: CURRENT_POLICY_EPOCH,
+      ttlSeconds: 60,
+    });
+
+    // --- Cross-verification ---
+    // CLI-minted token must verify with daemon key
+    _resetSigningKeyForTesting();
+    initAuthSigningKey(daemonKey);
+    const cliResult = verifyToken(cliToken, "vellum-daemon");
+    expect(cliResult.ok).toBe(true);
+
+    // Daemon-minted token must verify with CLI disk key
+    _resetSigningKeyForTesting();
+    initAuthSigningKey(cliDiskKey!);
+    const daemonResult = verifyToken(daemonToken, "vellum-daemon");
+    expect(daemonResult.ok).toBe(true);
+  });
+});

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

@@ -83,15 +83,13 @@ describe("Dynamic Skill Authoring Workflow moved to tool descriptions", () => {
     expect(result).not.toContain("**test-skill**");
   });
 
-  test("prompt is additive with IDENTITY/SOUL/USER files", () => {
+  test("prompt is additive with IDENTITY/SOUL files", () => {
     writeFileSync(join(TEST_DIR, "IDENTITY.md"), "Identity here");
     writeFileSync(join(TEST_DIR, "SOUL.md"), "Soul here");
-    writeFileSync(join(TEST_DIR, "USER.md"), "User here");
 
     const result = buildSystemPrompt();
     expect(result).toContain("Identity here");
     expect(result).toContain("Soul here");
-    expect(result).toContain("User here");
   });
 
   test("browser skill activation hints no longer appear in system prompt", () => {

package/src/__tests__/email-html-renderer.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, test } from "bun:test";
+
+import { markdownToEmailHtml } from "../email/html-renderer.js";
+
+describe("markdownToEmailHtml", () => {
+  test("wraps plain text in email template", () => {
+    const result = markdownToEmailHtml("Hello world");
+    expect(result).toContain("<!DOCTYPE html>");
+    expect(result).toContain("<p>Hello world</p>");
+    expect(result).toContain("max-width:600px");
+  });
+
+  test("converts markdown bold to <strong>", () => {
+    const result = markdownToEmailHtml("This is **bold** text");
+    expect(result).toContain("<strong>bold</strong>");
+  });
+
+  test("converts markdown links", () => {
+    const result = markdownToEmailHtml("Visit [Vellum](https://vellum.ai)");
+    expect(result).toContain('<a href="https://vellum.ai">Vellum</a>');
+  });
+
+  test("converts markdown lists", () => {
+    const result = markdownToEmailHtml("- item one\n- item two\n- item three");
+    expect(result).toContain("<li>item one</li>");
+    expect(result).toContain("<li>item two</li>");
+    expect(result).toContain("<ul>");
+  });
+
+  test("converts markdown code blocks", () => {
+    const result = markdownToEmailHtml("```\nconsole.log('hi')\n```");
+    expect(result).toContain("<code>");
+    expect(result).toContain("console.log(");
+  });
+
+  test("converts line breaks (GFM breaks mode)", () => {
+    const result = markdownToEmailHtml("line one\nline two");
+    expect(result).toContain("<br>");
+  });
+
+  test("returns raw HTML input as-is", () => {
+    const rawHtml = "<div>Already HTML</div>";
+    const result = markdownToEmailHtml(rawHtml);
+    expect(result).toBe(rawHtml);
+  });
+
+  test("handles empty string", () => {
+    const result = markdownToEmailHtml("");
+    expect(result).toBe("");
+  });
+
+  test("handles multiline markdown email", () => {
+    const md = `Hi there,
+
+Thanks for reaching out! Here's what I found:
+
+1. **First point** — some details
+2. **Second point** — more details
+
+Let me know if you need anything else.
+
+Best,
+Assistant`;
+
+    const result = markdownToEmailHtml(md);
+    expect(result).toContain("<!DOCTYPE html>");
+    expect(result).toContain("<strong>First point</strong>");
+    expect(result).toContain("<ol>");
+    expect(result).toContain("<li>");
+  });
+});

package/src/__tests__/email-invite-adapter.test.ts

@@ -1,51 +1,66 @@
 /**
  * Tests for the email invite adapter.
  *
- * Verifies that the email adapter resolves the assistant's real inbox
- * address when one is configured and falls back to `undefined` (triggering
- * generic invite instructions) when no inbox exists.
+ * Verifies that the email adapter resolves the assistant's email address
+ * from workspace config and falls back to `undefined` when no address
+ * is configured.
  */
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { resolveAdapterHandle } from "../runtime/channel-invite-transport.js";
-import { emailInviteAdapter } from "../runtime/channel-invite-transports/email.js";
-
 // ---------------------------------------------------------------------------
-// Mock the EmailService singleton
+// Mock the config loader
 // ---------------------------------------------------------------------------
 
-let mockPrimaryAddress: string | undefined;
-
-mock.module("../email/service.js", () => ({
-  getEmailService: () => ({
-    getPrimaryInboxAddress: async () => mockPrimaryAddress,
-  }),
-  // Re-export other symbols that callers might need
-  EmailService: class {},
+let mockConfig: Record<string, unknown> = {};
+
+mock.module("../config/loader.js", () => ({
+  loadRawConfig: () => mockConfig,
+  getNestedValue: (obj: Record<string, unknown>, path: string) => {
+    const keys = path.split(".");
+    let current: unknown = obj;
+    for (const key of keys) {
+      if (current == null || typeof current !== "object") return undefined;
+      current = (current as Record<string, unknown>)[key];
+    }
+    return current;
+  },
+  getConfig: () => ({}),
+  saveRawConfig: () => {},
+  setNestedValue: () => {},
 }));
 
+import { resolveAdapterHandle } from "../runtime/channel-invite-transport.js";
+import { emailInviteAdapter } from "../runtime/channel-invite-transports/email.js";
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
 
 describe("emailInviteAdapter", () => {
   beforeEach(() => {
-    mockPrimaryAddress = undefined;
+    mockConfig = {};
   });
 
   afterEach(() => {
-    mockPrimaryAddress = undefined;
+    mockConfig = {};
   });
 
   test("returns configured email address via resolveChannelHandleAsync", async () => {
-    mockPrimaryAddress = "hello@mycompany.agentmail.to";
+    mockConfig = { email: { address: "hello@vellum.me" } };
+
+    const handle = await resolveAdapterHandle(emailInviteAdapter);
+    expect(handle).toBe("hello@vellum.me");
+  });
+
+  test("returns undefined when no address is configured", async () => {
+    mockConfig = {};
 
     const handle = await resolveAdapterHandle(emailInviteAdapter);
-    expect(handle).toBe("hello@mycompany.agentmail.to");
+    expect(handle).toBeUndefined();
   });
 
-  test("returns undefined when no inbox is configured", async () => {
-    mockPrimaryAddress = undefined;
+  test("returns undefined when email.address is empty string", async () => {
+    mockConfig = { email: { address: "" } };
 
     const handle = await resolveAdapterHandle(emailInviteAdapter);
     expect(handle).toBeUndefined();
@@ -56,7 +71,6 @@ describe("emailInviteAdapter", () => {
   });
 
   test("does not define sync resolveChannelHandle", () => {
-    // The email adapter uses the async path exclusively
     expect(emailInviteAdapter.resolveChannelHandle).toBeUndefined();
   });
 
@@ -64,14 +78,4 @@ describe("emailInviteAdapter", () => {
     expect(emailInviteAdapter.buildShareLink).toBeUndefined();
     expect(emailInviteAdapter.extractInboundToken).toBeUndefined();
   });
-
-  test("returns config fallback address when provider has no inboxes", async () => {
-    // Simulates the config fallback: provider returns no inboxes, but
-    // email.address is set in workspace config. The service's
-    // getPrimaryInboxAddress() should return the configured address.
-    mockPrimaryAddress = "configured@example.com";
-
-    const handle = await resolveAdapterHandle(emailInviteAdapter);
-    expect(handle).toBe("configured@example.com");
-  });
 });