@vellumai/assistant 0.6.3 → 0.6.4

package/src/workspace/migrations/037-create-meets-dir.ts

@@ -0,0 +1,61 @@
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  rmdirSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * `.keep` sentinel content. Keeps the directory tracked/visible even when
+ * empty and documents the purpose for anyone inspecting the workspace.
+ */
+const KEEP_CONTENT =
+  "# Per-meeting artifacts live under <workspace>/meets/<meeting-id>/.\n";
+
+export const createMeetsDirMigration: WorkspaceMigration = {
+  id: "037-create-meets-dir",
+  description:
+    "Create meets/ storage directory with a .keep sentinel file for per-meeting artifacts",
+
+  down(workspaceDir: string): void {
+    // Best-effort: only remove the seeded .keep file and the meets/ directory
+    // itself if it is otherwise empty. Never delete user/meeting content.
+    const meetsDir = join(workspaceDir, "meets");
+    if (!existsSync(meetsDir)) return;
+
+    const keepPath = join(meetsDir, ".keep");
+    if (existsSync(keepPath)) {
+      try {
+        unlinkSync(keepPath);
+      } catch {
+        // Best-effort — leave the file alone if we can't remove it.
+      }
+    }
+
+    try {
+      const entries = readdirSync(meetsDir);
+      if (entries.length === 0) {
+        rmdirSync(meetsDir);
+      }
+    } catch {
+      // Best-effort — directory missing or unreadable; skip.
+    }
+  },
+
+  run(workspaceDir: string): void {
+    const meetsDir = join(workspaceDir, "meets");
+    mkdirSync(meetsDir, { recursive: true });
+
+    // Seed the .keep sentinel only if it doesn't already exist so re-runs
+    // don't clobber user edits (idempotent).
+    const keepPath = join(meetsDir, ".keep");
+    if (!existsSync(keepPath)) {
+      writeFileSync(keepPath, KEEP_CONTENT, "utf-8");
+    }
+  },
+};

package/src/workspace/migrations/registry.ts

@@ -27,6 +27,14 @@ import { removeOrphanedOptimizedImagesCacheMigration } from "./027-remove-orphan
 import { recoverConversationsFromDiskViewMigration } from "./028-recover-conversations-from-disk-view.js";
 import { seedPkbMigration } from "./029-seed-pkb.js";
 import { seedPkbAutoinjectMigration } from "./030-seed-pkb-autoinject.js";
+import { dropUserMdMigration } from "./031-drop-user-md.js";
+import { llmLogRetentionZeroToNullMigration } from "./031-llm-log-retention-zero-to-null.js";
+import { ttsProviderUnificationMigration } from "./032-tts-provider-unification.js";
+import { sttServiceExplicitConfigMigration } from "./033-stt-service-explicit-config.js";
+import { removeCallsVoiceTranscriptionProviderMigration } from "./034-remove-calls-voice-transcription-provider.js";
+import { seedSlackChannelPersonaMigration } from "./035-seed-slack-channel-persona.js";
+import { updatePkbIndexBarMigration } from "./036-update-pkb-index-bar.js";
+import { createMeetsDirMigration } from "./037-create-meets-dir.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -65,4 +73,12 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   recoverConversationsFromDiskViewMigration,
   seedPkbMigration,
   seedPkbAutoinjectMigration,
+  llmLogRetentionZeroToNullMigration,
+  ttsProviderUnificationMigration,
+  dropUserMdMigration,
+  sttServiceExplicitConfigMigration,
+  removeCallsVoiceTranscriptionProviderMigration,
+  seedSlackChannelPersonaMigration,
+  updatePkbIndexBarMigration,
+  createMeetsDirMigration,
 ];

package/src/workspace/top-level-renderer.ts

@@ -2,6 +2,18 @@ import { homedir, userInfo } from "node:os";
 
 import type { TopLevelSnapshot } from "./top-level-scanner.js";
 
+// `os.userInfo()` throws `SystemError` when the current UID has no passwd
+// entry (possible in sandboxed/containerized envs, including the daemon's
+// own container). Guarding here keeps the renderer safe since this runs
+// inside the daemon and crashing would break workspace context injection.
+function safeUserInfoUsername(): string {
+  try {
+    return userInfo().username;
+  } catch {
+    return "unknown";
+  }
+}
+
 export interface WorkspaceTopLevelRenderOptions {
   conversationAttachmentsPath?: string | null;
   /**
@@ -41,7 +53,7 @@ export function renderWorkspaceTopLevelContext(
     lines.push("(list truncated — more entries exist)");
   }
   lines.push(`Host home directory: ${options.hostHomeDir ?? homedir()}`);
-  lines.push(`Host username: ${options.hostUsername ?? userInfo().username}`);
+  lines.push(`Host username: ${options.hostUsername ?? safeUserInfoUsername()}`);
   lines.push("</workspace>");
   return lines.join("\n");
 }

package/src/workspace/turn-commit.ts

@@ -9,7 +9,12 @@
  * preventing cross-turn attribution of file changes.
  */
 
+import { existsSync, readFileSync } from "node:fs";
+
+import { parseIdentityFields } from "../daemon/handlers/identity.js";
+import { syncIdentityNameToPlatform } from "../platform/sync-identity.js";
 import { getLogger } from "../util/logger.js";
+import { getWorkspacePromptPath } from "../util/platform.js";
 import { getEnrichmentService } from "./commit-message-enrichment-service.js";
 import {
   type CommitContext,
@@ -166,6 +171,32 @@ export async function commitTurnChanges(
         "Turn-boundary commit created",
       );
 
+      // If IDENTITY.md changed, trigger a best-effort sync of the
+      // assistant name to the platform record.  This acts as a fallback
+      // for environments where fs.watch / inotify is unreliable (e.g.
+      // container runtimes using gVisor or Docker-in-Docker).
+      if (
+        uniqueFiles.some(
+          (f) => f === "IDENTITY.md" || f.endsWith("/IDENTITY.md"),
+        )
+      ) {
+        try {
+          const identityPath = getWorkspacePromptPath("IDENTITY.md");
+          if (existsSync(identityPath)) {
+            const content = readFileSync(identityPath, "utf-8");
+            const fields = parseIdentityFields(content);
+            if (fields.name) {
+              syncIdentityNameToPlatform(fields.name);
+            }
+          }
+        } catch (syncErr) {
+          log.debug(
+            { syncErr },
+            "Identity sync after turn-commit failed (non-fatal)",
+          );
+        }
+      }
+
       // Fire-and-forget enrichment — never blocks turn completion
       try {
         const commitHash = await gitService.getHeadHash();

package/src/__tests__/email-cli.test.ts

@@ -1,297 +0,0 @@
-import { mkdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Test isolation: override VELLUM_WORKSPACE_DIR so guardrails state uses a temp dir
-// ---------------------------------------------------------------------------
-const testDir = join(tmpdir(), `email-cli-test-${Date.now()}`);
-const originalWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
-
-beforeEach(() => {
-  mkdirSync(testDir, { recursive: true });
-  process.env.VELLUM_WORKSPACE_DIR = testDir;
-});
-
-afterEach(() => {
-  if (originalWorkspaceDir === undefined) {
-    delete process.env.VELLUM_WORKSPACE_DIR;
-  } else {
-    process.env.VELLUM_WORKSPACE_DIR = originalWorkspaceDir;
-  }
-  try {
-    rmSync(testDir, { recursive: true, force: true });
-  } catch {
-    // Ignore cleanup errors
-  }
-});
-
-// ---------------------------------------------------------------------------
-// Provider factory tests
-// ---------------------------------------------------------------------------
-describe("email provider factory", () => {
-  test("getActiveProviderName defaults to agentmail", async () => {
-    const { getActiveProviderName } =
-      await import("../email/providers/index.js");
-    expect(getActiveProviderName()).toBe("agentmail");
-  });
-
-  test("SUPPORTED_PROVIDERS includes agentmail", async () => {
-    const { SUPPORTED_PROVIDERS } = await import("../email/providers/index.js");
-    expect(SUPPORTED_PROVIDERS).toContain("agentmail");
-  });
-
-  test("createProvider throws without API key", async () => {
-    const { createProvider } = await import("../email/providers/index.js");
-    try {
-      await createProvider("agentmail");
-      // If we get here, the API key might be set in the env
-      // The important thing is it doesn't throw for wrong reasons
-    } catch (err) {
-      expect(err instanceof Error).toBe(true);
-      expect((err as Error).message).toContain("API key");
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Service guardrail tests (via guardrails module directly)
-// ---------------------------------------------------------------------------
-describe("email guardrails", () => {
-  test("pause blocks sends (returns outbound_paused)", async () => {
-    const guardrails = await import("../email/guardrails.js");
-
-    guardrails.setOutboundPaused(true);
-    expect(guardrails.isOutboundPaused()).toBe(true);
-
-    const result = guardrails.checkSendGuardrails(["user@example.com"]);
-    expect(result).not.toBeNull();
-    expect(result!.error).toBe("outbound_paused");
-  });
-
-  test("resume allows sends", async () => {
-    const guardrails = await import("../email/guardrails.js");
-
-    guardrails.setOutboundPaused(true);
-    guardrails.setOutboundPaused(false);
-
-    const result = guardrails.checkSendGuardrails(["user@example.com"]);
-    expect(result).toBeNull();
-  });
-
-  test("daily cap enforced", async () => {
-    const guardrails = await import("../email/guardrails.js");
-
-    guardrails.setDailySendCap(2);
-    guardrails.incrementDailySendCount();
-    guardrails.incrementDailySendCount();
-
-    const result = guardrails.checkSendGuardrails(["user@example.com"]);
-    expect(result).not.toBeNull();
-    expect(result!.error).toBe("daily_cap_reached");
-    expect(result!.count).toBe(2);
-    expect(result!.cap).toBe(2);
-  });
-
-  test("blocklist checked", async () => {
-    const guardrails = await import("../email/guardrails.js");
-
-    guardrails.addAddressRule("block", "*@spam.com");
-
-    const result = guardrails.checkSendGuardrails(["user@spam.com"]);
-    expect(result).not.toBeNull();
-    expect(result!.error).toBe("address_blocked");
-    expect(result!.address).toBe("user@spam.com");
-  });
-
-  test("allowlist enforcement", async () => {
-    const guardrails = await import("../email/guardrails.js");
-
-    guardrails.addAddressRule("allow", "*@trusted.com");
-
-    expect(guardrails.checkSendGuardrails(["bob@trusted.com"])).toBeNull();
-
-    const result = guardrails.checkSendGuardrails(["bob@untrusted.com"]);
-    expect(result).not.toBeNull();
-    expect(result!.error).toBe("address_blocked");
-    expect(result!.reason).toBe("not in allowlist");
-  });
-
-  test("rule lifecycle: add, list, remove", async () => {
-    const guardrails = await import("../email/guardrails.js");
-
-    const rule = guardrails.addAddressRule("block", "*@evil.com");
-    expect(rule.id).toBeTruthy();
-    expect(rule.type).toBe("block");
-
-    const rules = guardrails.listRules();
-    expect(rules.length).toBe(1);
-    expect(rules[0].pattern).toBe("*@evil.com");
-
-    expect(guardrails.removeAddressRule(rule.id)).toBe(true);
-    expect(guardrails.listRules().length).toBe(0);
-  });
-
-  test("remove non-existent rule returns false", async () => {
-    const guardrails = await import("../email/guardrails.js");
-    expect(guardrails.removeAddressRule("non-existent")).toBe(false);
-  });
-
-  test("default cap is 25", async () => {
-    const guardrails = await import("../email/guardrails.js");
-    expect(guardrails.getDailySendCap()).toBe(25);
-  });
-
-  test("incrementDailySendCount returns new count", async () => {
-    const guardrails = await import("../email/guardrails.js");
-
-    expect(guardrails.incrementDailySendCount()).toBe(1);
-    expect(guardrails.incrementDailySendCount()).toBe(2);
-    expect(guardrails.getDailySendCount()).toBe(2);
-  });
-
-  test("guardrails check priority: pause > cap > blocklist", async () => {
-    const guardrails = await import("../email/guardrails.js");
-
-    guardrails.setOutboundPaused(true);
-    guardrails.setDailySendCap(0);
-    guardrails.addAddressRule("block", "*@blocked.com");
-
-    const result = guardrails.checkSendGuardrails(["user@blocked.com"]);
-    expect(result!.error).toBe("outbound_paused");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Service layer tests (with mocked provider)
-// ---------------------------------------------------------------------------
-describe("email service guardrails integration", () => {
-  test("GuardrailError has correct structure", async () => {
-    const { GuardrailError } = await import("../email/service.js");
-
-    const err = new GuardrailError("outbound_paused", "Send blocked", {
-      extra: true,
-    });
-    expect(err.code).toBe("outbound_paused");
-    expect(err.message).toBe("Send blocked");
-    expect(err.details).toEqual({ extra: true });
-    expect(err.name).toBe("GuardrailError");
-    expect(err instanceof Error).toBe(true);
-  });
-
-  test("getEmailService returns singleton", async () => {
-    const { getEmailService } = await import("../email/service.js");
-    const a = getEmailService();
-    const b = getEmailService();
-    expect(a).toBe(b);
-  });
-
-  test("service getProviderName returns default", async () => {
-    const { getEmailService } = await import("../email/service.js");
-    const svc = getEmailService();
-    expect(svc.getProviderName()).toBe("agentmail");
-  });
-
-  test("service guardrails methods work", async () => {
-    const { getEmailService } = await import("../email/service.js");
-    const svc = getEmailService();
-
-    const initial = svc.getGuardrails();
-    expect(initial.paused).toBe(false);
-    expect(initial.dailyCap).toBe(25);
-
-    svc.setGuardrails({ paused: true, dailyCap: 10 });
-    const updated = svc.getGuardrails();
-    expect(updated.paused).toBe(true);
-    expect(updated.dailyCap).toBe(10);
-  });
-
-  test("service address rule methods work", async () => {
-    const { getEmailService } = await import("../email/service.js");
-    const svc = getEmailService();
-
-    const rule = svc.addRule("block", "*@test.com");
-    expect(rule.type).toBe("block");
-
-    const rules = svc.listAddressRules();
-    expect(rules.length).toBe(1);
-
-    expect(svc.removeRule(rule.id)).toBe(true);
-    expect(svc.listAddressRules().length).toBe(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// JSON output format / contract tests
-// ---------------------------------------------------------------------------
-describe("email JSON contract", () => {
-  test("guardrails status has expected shape", async () => {
-    const guardrails = await import("../email/guardrails.js");
-    const status = guardrails.getGuardrailsStatus();
-    const json = JSON.stringify(status);
-    const parsed = JSON.parse(json);
-
-    expect(parsed).toHaveProperty("paused");
-    expect(parsed).toHaveProperty("dailyCap");
-    expect(parsed).toHaveProperty("dailyCount");
-    expect(parsed).toHaveProperty("rules");
-    expect(typeof parsed.paused).toBe("boolean");
-    expect(typeof parsed.dailyCap).toBe("number");
-    expect(typeof parsed.dailyCount).toBe("number");
-    expect(Array.isArray(parsed.rules)).toBe(true);
-  });
-
-  test("address rule has expected JSON fields", async () => {
-    const guardrails = await import("../email/guardrails.js");
-    const rule = guardrails.addAddressRule("block", "*@test.com");
-    const parsed = JSON.parse(JSON.stringify(rule));
-
-    expect(parsed).toHaveProperty("id");
-    expect(parsed).toHaveProperty("type");
-    expect(parsed).toHaveProperty("pattern");
-    expect(parsed).toHaveProperty("createdAt");
-    expect(parsed.type).toBe("block");
-    expect(parsed.pattern).toBe("*@test.com");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Provider interface conformance
-// ---------------------------------------------------------------------------
-describe("AgentMailProvider interface", () => {
-  test("AgentMailProvider implements all required methods", async () => {
-    const { AgentMailProvider } =
-      await import("../email/providers/agentmail.js");
-
-    // Create with a dummy client — we won't call any methods
-    const provider = new AgentMailProvider({} as never);
-
-    // Verify all interface methods exist
-    const requiredMethods = [
-      "health",
-      "setupDomain",
-      "getDomainDnsRecords",
-      "verifyDomain",
-      "ensureInboxes",
-      "setupWebhook",
-      "createDraft",
-      "listDrafts",
-      "getDraft",
-      "deleteDraft",
-      "sendDraft",
-      "listMessages",
-      "getMessage",
-      "listThreads",
-      "getThread",
-    ];
-
-    for (const method of requiredMethods) {
-      expect(
-        typeof (provider as unknown as Record<string, unknown>)[method],
-      ).toBe("function");
-    }
-
-    expect(provider.name).toBe("agentmail");
-  });
-});

package/src/__tests__/email-service-config-fallback.test.ts

@@ -1,102 +0,0 @@
-/**
- * Tests that getPrimaryInboxAddress() falls back to the workspace config's
- * email.address when the provider can't list inboxes.
- */
-import { afterEach, describe, expect, mock, test } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Mock dependencies before importing the service
-// ---------------------------------------------------------------------------
-
-let mockProviderThrows = false;
-let mockProviderInboxes: { address: string }[] = [];
-
-mock.module("../email/providers/index.js", () => ({
-  createProvider: async () => ({
-    name: "mock",
-    health: async () => {
-      if (mockProviderThrows) throw new Error("provider unavailable");
-      return { inboxes: mockProviderInboxes, domains: [] };
-    },
-  }),
-  getActiveProviderName: () => "mock",
-}));
-
-let mockRawConfig: Record<string, unknown> = {};
-
-mock.module("../config/loader.js", () => ({
-  loadRawConfig: () => mockRawConfig,
-  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;
-  },
-  saveRawConfig: () => {},
-  setNestedValue: () => {},
-}));
-
-// Stub guardrails (imported by service.ts but not relevant here)
-mock.module("../email/guardrails.js", () => ({
-  addAddressRule: () => ({}),
-  checkSendGuardrails: () => null,
-  getGuardrailsStatus: () => ({}),
-  incrementDailySendCount: () => 0,
-  listRules: () => [],
-  removeAddressRule: () => false,
-  setDailySendCap: () => {},
-  setOutboundPaused: () => {},
-}));
-
-// Now import the service under test
-const { EmailService } = await import("../email/service.js");
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("getPrimaryInboxAddress — config fallback", () => {
-  afterEach(() => {
-    mockProviderThrows = false;
-    mockProviderInboxes = [];
-    mockRawConfig = {};
-  });
-
-  test("returns provider inbox address when available", async () => {
-    mockProviderInboxes = [{ address: "inbox@provider.example" }];
-    const svc = new EmailService();
-
-    const addr = await svc.getPrimaryInboxAddress();
-    expect(addr).toBe("inbox@provider.example");
-  });
-
-  test("falls back to email.address from config when provider returns no inboxes", async () => {
-    mockProviderInboxes = [];
-    mockRawConfig = { email: { address: "configured@example.com" } };
-    const svc = new EmailService();
-
-    const addr = await svc.getPrimaryInboxAddress();
-    expect(addr).toBe("configured@example.com");
-  });
-
-  test("falls back to email.address from config when provider throws", async () => {
-    mockProviderThrows = true;
-    mockRawConfig = { email: { address: "fallback@example.com" } };
-    const svc = new EmailService();
-
-    const addr = await svc.getPrimaryInboxAddress();
-    expect(addr).toBe("fallback@example.com");
-  });
-
-  test("returns undefined when neither provider nor config has an address", async () => {
-    mockProviderThrows = true;
-    mockRawConfig = {};
-    const svc = new EmailService();
-
-    const addr = await svc.getPrimaryInboxAddress();
-    expect(addr).toBeUndefined();
-  });
-});