@vellumai/assistant 0.4.55 → 0.4.57

package/src/work-items/work-item-runner.ts

@@ -1,13 +1,13 @@
 /**
  * Module-level registry for running work items from tool context.
  *
- * The daemon server registers its `getOrCreateSession` and `broadcast`
+ * The daemon server registers its `getOrCreateConversation` and `broadcast`
  * callbacks at startup. Tool implementations can then trigger async
  * work item execution without needing direct access to HandlerContext.
  */
 
+import type { Conversation } from "../daemon/conversation.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
-import type { Session } from "../daemon/session.js";
 import { runTask } from "../tasks/task-runner.js";
 import { getTask } from "../tasks/task-store.js";
 import {
@@ -15,6 +15,7 @@ import {
   sanitizeToolList,
 } from "../tasks/tool-sanitizer.js";
 import { getLogger } from "../util/logger.js";
+import { resolveRequiredTools } from "./resolve-required-tools.js";
 import {
   getWorkItem,
   updateWorkItem,
@@ -26,7 +27,7 @@ const log = getLogger("work-item-runner");
 // ── Daemon callback registry ─────────────────────────────────────────
 
 interface DaemonCallbacks {
-  getOrCreateSession: (conversationId: string) => Promise<Session>;
+  getOrCreateConversation: (conversationId: string) => Promise<Conversation>;
   broadcast: (msg: ServerMessage) => void;
 }
 
@@ -117,15 +118,15 @@ export function runWorkItemInBackground(workItemId: string): RunWorkItemResult {
     };
   }
 
-  // Resolve required tools
-  let requiredTools: string[];
-  if (workItem.requiredTools != null) {
-    requiredTools = sanitizeToolList(JSON.parse(workItem.requiredTools));
-  } else {
-    requiredTools = task.requiredTools
-      ? sanitizeToolList(JSON.parse(task.requiredTools))
-      : getRegisteredToolNames();
-  }
+  // Resolve required tools — falls back to task-level tools when the
+  // snapshot is empty, preventing an empty-snapshot permission bypass.
+  const taskRequiredTools = task.requiredTools
+    ? sanitizeToolList(JSON.parse(task.requiredTools))
+    : getRegisteredToolNames();
+  const requiredTools = resolveRequiredTools(
+    workItem.requiredTools,
+    taskRequiredTools,
+  );
 
   // Auto-approve all required tools for chat-initiated runs.
   // The user explicitly asked to run the task, so we treat that as consent.
@@ -134,44 +135,45 @@ export function runWorkItemInBackground(workItemId: string): RunWorkItemResult {
   // Set status to running
   updateWorkItem(workItemId, { status: "running" });
 
-  const { getOrCreateSession, broadcast } = _callbacks;
+  const { getOrCreateConversation, broadcast } = _callbacks;
 
   // Broadcast the running state
   broadcastWorkItemStatus(broadcast, workItemId);
   broadcast({ type: "tasks_changed" } as ServerMessage);
 
   // Execute asynchronously
-  let session: Awaited<ReturnType<typeof getOrCreateSession>> | null = null;
+  let conversation: Awaited<ReturnType<typeof getOrCreateConversation>> | null =
+    null;
   void (async () => {
     try {
       const result = await runTask(
         { taskId: workItem.taskId, workingDir: process.cwd(), approvedTools },
         async (conversationId, message, taskRunId) => {
-          if (!session) {
+          if (!conversation) {
             updateWorkItem(workItemId, {
               lastRunConversationId: conversationId,
             });
-            session = await getOrCreateSession(conversationId);
+            conversation = await getOrCreateConversation(conversationId);
 
             broadcast({
-              type: "task_run_thread_created",
+              type: "task_run_conversation_created",
               conversationId,
               workItemId,
               title: workItem.title,
             } as ServerMessage);
-            session.taskRunId = taskRunId;
-            session.headlessLock = true;
+            conversation.taskRunId = taskRunId;
+            conversation.headlessLock = true;
           }
-          await session.processMessage(message, [], (event) => {
+          await conversation.processMessage(message, [], (event) => {
             broadcast(event);
           });
         },
       );
 
-      // TS can't track that session is mutated inside the closure above
-      const doneSession = session as { headlessLock: boolean } | null;
-      if (doneSession) {
-        doneSession.headlessLock = false;
+      // TS can't track that conversation is mutated inside the closure above
+      const doneConversation = conversation as { headlessLock: boolean } | null;
+      if (doneConversation) {
+        doneConversation.headlessLock = false;
       }
 
       const current = getWorkItem(workItemId);
@@ -189,9 +191,9 @@ export function runWorkItemInBackground(workItemId: string): RunWorkItemResult {
       broadcastWorkItemStatus(broadcast, workItemId);
       broadcast({ type: "tasks_changed" } as ServerMessage);
     } catch (err) {
-      const errSession = session as { headlessLock: boolean } | null;
-      if (errSession) {
-        errSession.headlessLock = false;
+      const errConversation = conversation as { headlessLock: boolean } | null;
+      if (errConversation) {
+        errConversation.headlessLock = false;
       }
       log.error({ err, workItemId }, "work item background run failed");
       updateWorkItem(workItemId, {

package/src/workspace/commit-message-enrichment-service.ts

@@ -293,7 +293,7 @@ export class CommitEnrichmentService {
       trigger: job.context.trigger,
       filesChanged: job.context.changedFiles.length,
       timestamp: job.context.timestampMs,
-      sessionId: job.context.sessionId,
+      conversationId: job.context.conversationId,
       turnNumber: job.context.turnNumber,
     });
 

package/src/workspace/commit-message-provider.ts

@@ -8,7 +8,7 @@
 export interface CommitContext {
   workspaceDir: string;
   trigger: "turn" | "heartbeat" | "shutdown";
-  sessionId?: string;
+  conversationId?: string;
   turnNumber?: number;
   changedFiles: string[];
   timestampMs: number;
@@ -70,7 +70,7 @@ export class DefaultCommitMessageProvider implements CommitMessageProvider {
     const message = [
       `Turn: ${summary}`,
       "",
-      `Session: ${ctx.sessionId}`,
+      `Conversation: ${ctx.conversationId}`,
       `Turn: ${ctx.turnNumber}`,
       `Timestamp: ${timestamp}`,
       `Files: ${ctx.changedFiles.length} changed`,

package/src/workspace/git-service.ts

@@ -456,7 +456,9 @@ export class WorkspaceGitService {
             ? "Initial commit: migrated existing workspace"
             : "Initial commit: new workspace";
 
-          await this.execGit(["commit", "-m", message, "--allow-empty"]);
+          await this.execGit(
+            this.buildSafeCommitArgs(["-m", message, "--allow-empty"]),
+          );
 
           this.initialized = true;
           this.recordInitSuccess();
@@ -494,7 +496,9 @@ export class WorkspaceGitService {
       }
 
       // Commit (will succeed even if no changes)
-      await this.execGit(["commit", "-m", fullMessage, "--allow-empty"]);
+      await this.execGit(
+        this.buildSafeCommitArgs(["-m", fullMessage, "--allow-empty"]),
+      );
     });
   }
 
@@ -634,7 +638,7 @@ export class WorkspaceGitService {
               .join("\n");
         }
 
-        await this.execGit(["commit", "-m", fullMessage]);
+        await this.execGit(this.buildSafeCommitArgs(["-m", fullMessage]));
         return { committed: true, status, didRunGit: true as const };
       });
       if (result.didRunGit) {
@@ -711,15 +715,8 @@ export class WorkspaceGitService {
       // This keeps user-tracked files under data/ visible to git.
       const lines = content.split("\n");
       const hadLegacyDataRule = lines.some((line) => line.trim() === "data/");
-      const hadLegacyHttpToken = lines.some(
-        (line) => line.trim() === "http-token",
-      );
-      if (hadLegacyDataRule || hadLegacyHttpToken) {
-        content = lines
-          .filter(
-            (line) => line.trim() !== "data/" && line.trim() !== "http-token",
-          )
-          .join("\n");
+      if (hadLegacyDataRule) {
+        content = lines.filter((line) => line.trim() !== "data/").join("\n");
         if (!content.endsWith("\n")) {
           content += "\n";
         }
@@ -728,7 +725,7 @@ export class WorkspaceGitService {
       const missingRules = WORKSPACE_GITIGNORE_RULES.filter(
         (rule) => !content.includes(rule),
       );
-      if (hadLegacyDataRule || hadLegacyHttpToken || missingRules.length > 0) {
+      if (hadLegacyDataRule || missingRules.length > 0) {
         let updated = content;
         if (missingRules.length > 0) {
           if (!updated.endsWith("\n")) {
@@ -870,6 +867,16 @@ export class WorkspaceGitService {
     }
   }
 
+  /**
+   * Build commit args that disable all git hook execution.
+   *
+   * Workspace contents are model-writable, so hooks in `.git/hooks` (or via
+   * `core.hooksPath`) are untrusted. Auto-commit paths must not execute them.
+   */
+  private buildSafeCommitArgs(args: string[]): string[] {
+    return ["-c", "core.hooksPath=/dev/null", "commit", "--no-verify", ...args];
+  }
+
   /**
    * Run an arbitrary read-only git command in the workspace directory.
    * Uses the same clean env and timeout as other git operations.
@@ -896,7 +903,13 @@ export class WorkspaceGitService {
     await this.ensureInitialized();
     await this.mutex.withLock(async () => {
       this.cleanStaleLockFile();
-      await fn((args) => this.execGit(args));
+      await fn((args) => {
+        // Intercept commit commands to enforce hook hardening.
+        if (args[0] === "commit") {
+          return this.execGit(this.buildSafeCommitArgs(args.slice(1)));
+        }
+        return this.execGit(args);
+      });
     });
   }
 

package/src/workspace/migrations/001-avatar-rename.ts

@@ -0,0 +1,25 @@
+import { existsSync, renameSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+export const avatarRenameMigration: WorkspaceMigration = {
+  id: "001-avatar-rename",
+  description:
+    "Rename custom-avatar.png → avatar-image.png and avatar-components.json → character-traits.json",
+  run(workspaceDir: string): void {
+    const avatarDir = join(workspaceDir, "data", "avatar");
+
+    const oldImage = join(avatarDir, "custom-avatar.png");
+    const newImage = join(avatarDir, "avatar-image.png");
+    if (existsSync(oldImage) && !existsSync(newImage)) {
+      renameSync(oldImage, newImage);
+    }
+
+    const oldTraits = join(avatarDir, "avatar-components.json");
+    const newTraits = join(avatarDir, "character-traits.json");
+    if (existsSync(oldTraits) && !existsSync(newTraits)) {
+      renameSync(oldTraits, newTraits);
+    }
+  },
+};

package/src/workspace/migrations/002-backfill-installation-id.ts

@@ -0,0 +1,75 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import {
+  deleteMemoryCheckpoint,
+  getMemoryCheckpoint,
+} from "../../memory/checkpoints.js";
+import { getExternalAssistantId } from "../../runtime/auth/external-assistant-id.js";
+import type { WorkspaceMigration } from "./types.js";
+
+export const backfillInstallationIdMigration: WorkspaceMigration = {
+  id: "002-backfill-installation-id",
+  description:
+    "Backfill installationId into lockfile from SQLite checkpoint and clean up stale row",
+  run(_workspaceDir: string): void {
+    // a. Read existing installation ID from SQLite, or generate a new one.
+    //    On fresh installs the memory_checkpoints table may not exist yet
+    //    (workspace migrations run before initializeDb), so treat errors as null.
+    let existingId: string | null = null;
+    try {
+      existingId = getMemoryCheckpoint("telemetry:installation_id");
+    } catch {
+      // Table doesn't exist yet — fresh install, no prior ID to recover.
+    }
+    const installationId = existingId || randomUUID();
+
+    // b. Read the lockfile from the standard path
+    const base = process.env.BASE_DATA_DIR?.trim() || homedir();
+    const lockPath = join(base, ".vellum.lock.json");
+    if (!existsSync(lockPath)) return;
+
+    let lockData: Record<string, unknown>;
+    try {
+      const raw = JSON.parse(readFileSync(lockPath, "utf-8"));
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+      lockData = raw as Record<string, unknown>;
+    } catch {
+      return;
+    }
+
+    // c. Find the assistant entry that corresponds to this daemon instance
+    const assistants = lockData.assistants as
+      | Array<Record<string, unknown>>
+      | undefined;
+    if (!Array.isArray(assistants)) return;
+
+    const externalId = getExternalAssistantId();
+    const entry = assistants.find((a) => a.assistantId === externalId);
+    if (!entry) return;
+
+    // d. If already has a truthy installationId, skip lockfile write (idempotent)
+    if (entry.installationId) {
+      // e is skipped for lockfile write, but still clean up SQLite
+      try {
+        deleteMemoryCheckpoint("telemetry:installation_id");
+      } catch {
+        // Table doesn't exist — nothing to clean up.
+      }
+      return;
+    }
+
+    // e. Set installationId on the entry and write the lockfile back
+    entry.installationId = installationId;
+    writeFileSync(lockPath, JSON.stringify(lockData, null, 2) + "\n");
+
+    // f. Delete the stale SQLite row
+    try {
+      deleteMemoryCheckpoint("telemetry:installation_id");
+    } catch {
+      // Table doesn't exist — nothing to clean up.
+    }
+  },
+};

package/src/workspace/migrations/003-seed-device-id.ts

@@ -0,0 +1,101 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import { getBaseDataDir } from "../../config/env-registry.js";
+import type { WorkspaceMigration } from "./types.js";
+
+export const seedDeviceIdMigration: WorkspaceMigration = {
+  id: "003-seed-device-id",
+  description:
+    "Seed ~/.vellum/device.json deviceId from the most recent lockfile installationId for continuity",
+  run(_workspaceDir: string): void {
+    const base = getBaseDataDir() || homedir();
+    const vellumDir = join(base, ".vellum");
+    const devicePath = join(vellumDir, "device.json");
+
+    // a. If device.json already has a deviceId, nothing to do.
+    if (existsSync(devicePath)) {
+      try {
+        const parsed = JSON.parse(readFileSync(devicePath, "utf-8"));
+        if (
+          parsed &&
+          typeof parsed === "object" &&
+          typeof parsed.deviceId === "string" &&
+          parsed.deviceId
+        ) {
+          return;
+        }
+      } catch {
+        // Unreadable or malformed — fall through and try to seed.
+      }
+    }
+
+    // b. Read the lockfile to find an existing installationId.
+    //    Check both the current and legacy lockfile paths to support installs
+    //    that haven't migrated the filename yet.
+    const lockCandidates = [
+      join(base, ".vellum.lock.json"),
+      join(base, ".vellum.lockfile.json"),
+    ];
+
+    let lockData: Record<string, unknown> | undefined;
+    for (const lockPath of lockCandidates) {
+      if (!existsSync(lockPath)) continue;
+      try {
+        const raw = JSON.parse(readFileSync(lockPath, "utf-8"));
+        if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+          lockData = raw as Record<string, unknown>;
+          break;
+        }
+      } catch {
+        // Malformed — try next candidate.
+      }
+    }
+    if (!lockData) return;
+
+    const assistants = lockData.assistants as
+      | Array<Record<string, unknown>>
+      | undefined;
+    if (!Array.isArray(assistants) || assistants.length === 0) return;
+
+    // c. Find the most recently hatched entry with an installationId.
+    const withInstallId = assistants.filter(
+      (a) => typeof a.installationId === "string" && a.installationId,
+    );
+    if (withInstallId.length === 0) return;
+
+    withInstallId.sort((a, b) => {
+      const ta =
+        typeof a.hatchedAt === "string" ? new Date(a.hatchedAt).getTime() : 0;
+      const tb =
+        typeof b.hatchedAt === "string" ? new Date(b.hatchedAt).getTime() : 0;
+      return tb - ta;
+    });
+
+    const seedId = withInstallId[0].installationId as string;
+
+    // d. Write device.json, preserving any existing fields.
+    let existing: Record<string, unknown> = {};
+    if (existsSync(devicePath)) {
+      try {
+        const parsed = JSON.parse(readFileSync(devicePath, "utf-8"));
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          existing = parsed as Record<string, unknown>;
+        }
+      } catch {
+        // Malformed — start fresh.
+      }
+    }
+    existing.deviceId = seedId;
+
+    try {
+      mkdirSync(vellumDir, { recursive: true });
+      writeFileSync(devicePath, JSON.stringify(existing, null, 2) + "\n", {
+        mode: 0o644,
+      });
+    } catch {
+      // Best-effort — getDeviceId() will generate a new one if this fails.
+    }
+  },
+};

package/src/workspace/migrations/004-extract-collect-usage-data.ts

@@ -0,0 +1,50 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+export const extractCollectUsageDataMigration: WorkspaceMigration = {
+  id: "004-extract-collect-usage-data",
+  description:
+    "Move collect-usage-data opt-out from assistantFeatureFlagValues to top-level collectUsageData config key",
+  run(workspaceDir: string): void {
+    const configPath = join(workspaceDir, "config.json");
+    if (!existsSync(configPath)) return;
+
+    let config: Record<string, unknown>;
+    try {
+      const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+      config = raw as Record<string, unknown>;
+    } catch {
+      return; // Malformed config — skip
+    }
+
+    const flagValues = config.assistantFeatureFlagValues as
+      | Record<string, unknown>
+      | undefined;
+    if (!flagValues || typeof flagValues !== "object") return;
+
+    const FLAG_KEY = "feature_flags.collect-usage-data.enabled";
+    if (!(FLAG_KEY in flagValues)) return;
+
+    const value = flagValues[FLAG_KEY];
+    if (typeof value !== "boolean") return;
+
+    // Only write collectUsageData if the user had explicitly opted out.
+    // The schema default is true, so we only need to persist false.
+    if (!value) {
+      config.collectUsageData = false;
+    }
+
+    // Remove from feature flag values
+    delete flagValues[FLAG_KEY];
+
+    // Clean up empty assistantFeatureFlagValues object
+    if (Object.keys(flagValues).length === 0) {
+      delete config.assistantFeatureFlagValues;
+    }
+
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+};

package/src/workspace/migrations/005-add-send-diagnostics.ts

@@ -0,0 +1,12 @@
+import type { WorkspaceMigration } from "./types.js";
+
+export const addSendDiagnosticsMigration: WorkspaceMigration = {
+  id: "005-add-send-diagnostics",
+  description:
+    "Add sendDiagnostics config key (defaults to true, no data to migrate from UserDefaults)",
+  run(_workspaceDir: string): void {
+    // No-op — the schema default handles new installs, and the macOS client
+    // will sync the UserDefaults value on first startup. This migration exists
+    // as a checkpoint marker for future reference.
+  },
+};

package/src/workspace/migrations/006-services-config.ts

@@ -0,0 +1,132 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { credentialKey } from "../../security/credential-key.js";
+import {
+  getProviderKeyAsync,
+  getSecureKeyAsync,
+} from "../../security/secure-keys.js";
+import type { WorkspaceMigration } from "./types.js";
+
+export const servicesConfigMigration: WorkspaceMigration = {
+  id: "006-services-config",
+  description:
+    "Move top-level provider/model/imageGenModel/webSearchProvider into services object with mode",
+  async run(workspaceDir: string): Promise<void> {
+    const configPath = join(workspaceDir, "config.json");
+    if (!existsSync(configPath)) return;
+
+    let config: Record<string, unknown>;
+    try {
+      const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+      config = raw as Record<string, unknown>;
+    } catch {
+      return;
+    }
+
+    // Skip if no legacy fields remain — either already migrated or a fresh install
+    // where schema defaults are correct. We check for legacy fields instead of
+    // services existence because backfillConfigDefaults may have written a default
+    // services object before migrations run.
+    const hasLegacyFields =
+      "provider" in config ||
+      "model" in config ||
+      "imageGenModel" in config ||
+      "webSearchProvider" in config;
+    if (!hasLegacyFields) return;
+
+    // Start from existing services (may have been backfilled by loadConfig defaults)
+    // so we don't discard any non-default values already written there.
+    const existingServices =
+      config.services != null &&
+      typeof config.services === "object" &&
+      !Array.isArray(config.services)
+        ? (config.services as Record<string, Record<string, unknown>>)
+        : {};
+
+    // Determine inference mode
+    let inferenceMode: "managed" | "your-own" = "your-own";
+    try {
+      // Check if the user has ANY inference provider key configured.
+      // If so, keep "your-own" regardless of managed credentials.
+      const inferenceProviders = [
+        "anthropic",
+        "openai",
+        "gemini",
+        "fireworks",
+        "openrouter",
+      ];
+      let hasAnyUserKey = false;
+      for (const p of inferenceProviders) {
+        if (await getProviderKeyAsync(p)) {
+          hasAnyUserKey = true;
+          break;
+        }
+      }
+      if (!hasAnyUserKey) {
+        const apiKey = await getSecureKeyAsync(
+          credentialKey("vellum", "assistant_api_key"),
+        );
+        const baseUrl = await getSecureKeyAsync(
+          credentialKey("vellum", "platform_base_url"),
+        );
+        if (apiKey && baseUrl) {
+          inferenceMode = "managed";
+        }
+      }
+    } catch {
+      // Can't determine -- default to "your-own"
+    }
+
+    const services: Record<string, Record<string, unknown>> = {
+      ...existingServices,
+    };
+
+    services.inference = {
+      ...(existingServices.inference ?? {}),
+      mode: inferenceMode,
+      provider:
+        typeof config.provider === "string"
+          ? config.provider
+          : (existingServices.inference?.provider ?? "anthropic"),
+      model:
+        typeof config.model === "string"
+          ? config.model
+          : (existingServices.inference?.model ?? "claude-opus-4-6"),
+    };
+
+    const imageGenModel =
+      typeof config.imageGenModel === "string"
+        ? config.imageGenModel
+        : typeof existingServices["image-generation"]?.model === "string"
+          ? (existingServices["image-generation"].model as string)
+          : "gemini-2.5-flash-image";
+    services["image-generation"] = {
+      ...(existingServices["image-generation"] ?? {}),
+      mode: "your-own",
+      provider:
+        imageGenModel.startsWith("dall-e") || imageGenModel.startsWith("gpt")
+          ? "openai"
+          : "gemini",
+      model: imageGenModel,
+    };
+
+    services["web-search"] = {
+      ...(existingServices["web-search"] ?? {}),
+      mode: "your-own",
+      provider:
+        typeof config.webSearchProvider === "string"
+          ? config.webSearchProvider
+          : (existingServices["web-search"]?.provider ?? "anthropic-native"),
+    };
+
+    config.services = services;
+    delete config.provider;
+    delete config.model;
+    delete config.imageGenModel;
+    delete config.webSearchProvider;
+
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+};