@vellumai/assistant 0.5.6 → 0.5.7

package/src/workspace/migrations/016-migrate-credentials-from-keychain.ts

@@ -0,0 +1,150 @@
+import { getLogger } from "../../util/logger.js";
+import type { WorkspaceMigration } from "./types.js";
+
+const log = getLogger("workspace-migrations");
+
+const BROKER_WAIT_INTERVAL_MS = 500;
+const BROKER_WAIT_MAX_ATTEMPTS = 10; // 5 seconds total
+
+export const migrateCredentialsFromKeychainMigration: WorkspaceMigration = {
+  id: "016-migrate-credentials-from-keychain",
+  description:
+    "Copy keychain credentials back to encrypted store for CES unification",
+
+  async down(_workspaceDir: string): Promise<void> {
+    // Reverse: copy credentials from encrypted store back to keychain.
+    // Mirrors the forward logic of 015-migrate-credentials-to-keychain.
+    if (
+      process.env.VELLUM_DESKTOP_APP !== "1" ||
+      process.env.VELLUM_DEV === "1"
+    ) {
+      return;
+    }
+
+    const { createBrokerClient } =
+      await import("../../security/keychain-broker-client.js");
+    const client = createBrokerClient();
+
+    let brokerAvailable = false;
+    for (let i = 0; i < BROKER_WAIT_MAX_ATTEMPTS; i++) {
+      if (client.isAvailable()) {
+        brokerAvailable = true;
+        break;
+      }
+      await new Promise((r) => setTimeout(r, BROKER_WAIT_INTERVAL_MS));
+    }
+
+    if (!brokerAvailable) {
+      throw new Error(
+        "Keychain broker not available after waiting — credential rollback " +
+          "will be retried on next startup",
+      );
+    }
+
+    const { listKeys, getKey, deleteKey } =
+      await import("../../security/encrypted-store.js");
+
+    const accounts = listKeys();
+    if (accounts.length === 0) return;
+
+    let rolledBackCount = 0;
+    let failedCount = 0;
+
+    for (const account of accounts) {
+      const value = getKey(account);
+      if (value === undefined) {
+        log.warn(
+          { account },
+          "Failed to read key from encrypted store during rollback — skipping",
+        );
+        failedCount++;
+        continue;
+      }
+
+      const result = await client.set(account, value);
+      if (result.status === "ok") {
+        deleteKey(account);
+        rolledBackCount++;
+      } else {
+        log.warn(
+          { account, status: result.status },
+          "Failed to write key to keychain during rollback — skipping",
+        );
+        failedCount++;
+      }
+    }
+
+    log.info(
+      { rolledBackCount, failedCount },
+      "Credential rollback from encrypted store to keychain complete",
+    );
+  },
+
+  async run(_workspaceDir: string): Promise<void> {
+    // Only run on mac production builds (desktop app, non-dev).
+    if (
+      process.env.VELLUM_DESKTOP_APP !== "1" ||
+      process.env.VELLUM_DEV === "1"
+    ) {
+      return;
+    }
+
+    const { createBrokerClient } =
+      await import("../../security/keychain-broker-client.js");
+    const client = createBrokerClient();
+
+    // Wait for the broker to become available (up to 5 seconds), matching
+    // the retry strategy in secure-keys.ts waitForBrokerAvailability().
+    let brokerAvailable = false;
+    for (let i = 0; i < BROKER_WAIT_MAX_ATTEMPTS; i++) {
+      if (client.isAvailable()) {
+        brokerAvailable = true;
+        break;
+      }
+      await new Promise((r) => setTimeout(r, BROKER_WAIT_INTERVAL_MS));
+    }
+
+    if (!brokerAvailable) {
+      // Unlike migration 015, we return silently here. If the broker is not
+      // available, credentials may already be in the encrypted store from
+      // before migration 015 ran, or from a non-desktop environment.
+      return;
+    }
+
+    const { setKey } = await import("../../security/encrypted-store.js");
+
+    const accounts = await client.list();
+    if (accounts.length === 0) {
+      return;
+    }
+
+    let migratedCount = 0;
+    let failedCount = 0;
+
+    for (const account of accounts) {
+      const result = await client.get(account);
+      if (!result || !result.found || result.value === undefined) {
+        log.warn({ account }, "Failed to read key from keychain — skipping");
+        failedCount++;
+        continue;
+      }
+
+      const written = setKey(account, result.value);
+      if (written) {
+        await client.del(account);
+        migratedCount++;
+      } else {
+        log.warn(
+          { account },
+          "Failed to write key to encrypted store — skipping",
+        );
+        failedCount++;
+      }
+    }
+
+    log.info(
+      { migratedCount, failedCount },
+      "Credential migration from keychain complete",
+    );
+  },
+};

package/src/workspace/migrations/017-seed-persona-dirs.ts

@@ -0,0 +1,95 @@
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmdirSync,
+} from "node:fs";
+import { join } from "node:path";
+
+import { eq } from "drizzle-orm";
+
+import { generateUserFileSlug } from "../../contacts/contact-store.js";
+import { getDb } from "../../memory/db.js";
+import { contacts } from "../../memory/schema/contacts.js";
+import {
+  isTemplateContent,
+  stripCommentLines,
+} from "../../prompts/system-prompt.js";
+import type { WorkspaceMigration } from "./types.js";
+
+export const seedPersonaDirsMigration: WorkspaceMigration = {
+  id: "017-seed-persona-dirs",
+  description:
+    "Create users/ and channels/ persona directories and migrate customized USER.md",
+
+  down(workspaceDir: string): void {
+    // Remove the seeded persona directories only if they are empty.
+    // We don't delete user-created content — only clean up the empty
+    // directories that the forward migration created.
+    const usersDir = join(workspaceDir, "users");
+    const channelsDir = join(workspaceDir, "channels");
+
+    for (const dir of [usersDir, channelsDir]) {
+      if (!existsSync(dir)) continue;
+      try {
+        const entries = readdirSync(dir);
+        if (entries.length === 0) {
+          rmdirSync(dir);
+        }
+      } catch {
+        // Best-effort: skip if we can't read or remove
+      }
+    }
+  },
+
+  run(workspaceDir: string): void {
+    // Create persona directories
+    mkdirSync(join(workspaceDir, "users"), { recursive: true });
+    mkdirSync(join(workspaceDir, "channels"), { recursive: true });
+
+    // Check if USER.md exists and has been customized
+    const userMdPath = join(workspaceDir, "USER.md");
+    if (!existsSync(userMdPath)) return;
+
+    const rawContent = readFileSync(userMdPath, "utf-8");
+    const content = stripCommentLines(rawContent);
+    if (!content) return;
+
+    // Skip if the content is the unmodified template
+    if (isTemplateContent(content, "USER.md")) return;
+
+    // Determine destination filename based on guardian contact
+    let destFilename = "guardian.md";
+    try {
+      const db = getDb();
+      const guardian = db
+        .select()
+        .from(contacts)
+        .where(eq(contacts.role, "guardian"))
+        .limit(1)
+        .get();
+
+      if (guardian) {
+        if (guardian.userFile) {
+          destFilename = guardian.userFile;
+        } else {
+          const slug = generateUserFileSlug(guardian.displayName);
+          db.update(contacts)
+            .set({ userFile: slug })
+            .where(eq(contacts.id, guardian.id))
+            .run();
+          destFilename = slug;
+        }
+      }
+    } catch {
+      // DB might not be initialized yet — fall back to guardian.md
+    }
+
+    const destPath = join(workspaceDir, "users", destFilename);
+    if (!existsSync(destPath)) {
+      copyFileSync(userMdPath, destPath);
+    }
+  },
+};

package/src/workspace/migrations/migrate-to-workspace-volume.ts

@@ -14,7 +14,13 @@
  * - Skips if the old workspace directory doesn't exist or is empty.
  */
 
-import { cpSync, existsSync, readdirSync, writeFileSync } from "node:fs";
+import {
+  cpSync,
+  existsSync,
+  readdirSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
 import { join } from "node:path";
 
 import {
@@ -30,6 +36,22 @@ export const migrateToWorkspaceVolumeMigration: WorkspaceMigration = {
   description:
     "Copy workspace data from old /data/.vellum/workspace to new WORKSPACE_DIR volume on first boot",
 
+  down(workspaceDir: string): void {
+    // This migration copies data between volumes. Actually reversing the copy
+    // (deleting data from the workspace volume) is dangerous and could cause
+    // data loss. Instead, we just remove the sentinel file so the migration
+    // will re-run and re-evaluate on next startup.
+    const sentinelPath = join(workspaceDir, SENTINEL_FILENAME);
+    if (existsSync(sentinelPath)) {
+      try {
+        unlinkSync(sentinelPath);
+      } catch {
+        // Best-effort — the migration runner's checkpoint removal will
+        // also ensure the migration re-runs.
+      }
+    }
+  },
+
   run(workspaceDir: string): void {
     const workspaceDirOverride = getWorkspaceDirOverride();
 

package/src/workspace/migrations/registry.ts

@@ -10,6 +10,10 @@ import { appDirRenameMigration } from "./010-app-dir-rename.js";
 import { backfillInstallationIdMigration } from "./011-backfill-installation-id.js";
 import { renameConversationDiskViewDirsMigration } from "./012-rename-conversation-disk-view-dirs.js";
 import { repairConversationDiskViewMigration } from "./013-repair-conversation-disk-view.js";
+import { migrateCredentialsToKeychainMigration } from "./015-migrate-credentials-to-keychain.js";
+import { extractFeatureFlagsToProtectedMigration } from "./016-extract-feature-flags-to-protected.js";
+import { migrateCredentialsFromKeychainMigration } from "./016-migrate-credentials-from-keychain.js";
+import { seedPersonaDirsMigration } from "./017-seed-persona-dirs.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -31,4 +35,8 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   renameConversationDiskViewDirsMigration,
   repairConversationDiskViewMigration,
   migrateToWorkspaceVolumeMigration,
+  migrateCredentialsToKeychainMigration,
+  migrateCredentialsFromKeychainMigration,
+  seedPersonaDirsMigration,
+  extractFeatureFlagsToProtectedMigration,
 ];

package/src/workspace/migrations/runner.ts

@@ -7,10 +7,16 @@ import type { WorkspaceMigration } from "./types.js";
 
 const log = getLogger("workspace-migrations");
 
+export function getLastWorkspaceMigrationId(
+  migrations: WorkspaceMigration[],
+): string | null {
+  return migrations.length > 0 ? migrations[migrations.length - 1].id : null;
+}
+
 export type CheckpointFile = {
   applied: Record<
     string,
-    { appliedAt: string; status?: "started" | "completed" }
+    { appliedAt: string; status?: "started" | "completed" | "rolling_back" }
   >;
 };
 
@@ -73,7 +79,7 @@ export async function runWorkspaceMigrations(
   const checkpoints = loadCheckpoints(workspaceDir);
 
   for (const [id, entry] of Object.entries(checkpoints.applied)) {
-    if (entry.status === "started") {
+    if (entry.status === "started" || entry.status === "rolling_back") {
       log.warn(
         `Workspace migration "${id}" was interrupted during a previous run; will re-run`,
       );
@@ -115,3 +121,101 @@ export async function runWorkspaceMigrations(
     saveCheckpoints(workspaceDir, checkpoints);
   }
 }
+
+/**
+ * Roll back workspace (filesystem) migrations in reverse order, stopping before
+ * the target migration.
+ *
+ * Migrations after `targetMigrationId` in the registry array are reversed in
+ * reverse order; the target migration itself is kept applied.
+ *
+ * **Usage**: Pass the full migrations array (typically `WORKSPACE_MIGRATIONS`
+ * from `registry.ts`) and the ID of the migration you want to roll back *to*.
+ * For example, `rollbackWorkspaceMigrations(dir, migrations, "010-app-dir-rename")`
+ * rolls back all applied migrations that appear after `010-app-dir-rename` in
+ * the registry.
+ *
+ * **Checkpoint state**: Each rolled-back migration's entry is deleted from the
+ * `.workspace-migrations.json` checkpoint file. If the process crashes
+ * mid-rollback, the `"rolling_back"` marker is detected and cleared by
+ * `runWorkspaceMigrations` on the next startup (it re-runs interrupted
+ * migrations).
+ *
+ * **Warning — data loss**: Every workspace migration must define a `down()`
+ * method (enforced at the type level), but some rollbacks are lossy (e.g.,
+ * file deletions or format conversions that discard the original cannot fully
+ * restore prior state). Review each migration's `down()` implementation
+ * before calling this function.
+ *
+ * **Important**: Stop the assistant before running rollbacks. Rolling back
+ * workspace migrations while the assistant is running may cause file conflicts,
+ * stale caches, or data corruption.
+ *
+ * @param workspaceDir  The workspace directory path (e.g., `~/.vellum/workspace`).
+ * @param migrations  The full ordered array of workspace migrations (from `WORKSPACE_MIGRATIONS`).
+ * @param targetMigrationId  The migration ID to roll back to (exclusive — all
+ *   migrations after this one are reversed).
+ */
+export async function rollbackWorkspaceMigrations(
+  workspaceDir: string,
+  migrations: WorkspaceMigration[],
+  targetMigrationId: string,
+): Promise<void> {
+  // Find the index of the target migration
+  const targetIndex = migrations.findIndex((m) => m.id === targetMigrationId);
+  if (targetIndex === -1) {
+    throw new Error(
+      `Target migration "${targetMigrationId}" not found in the migrations array`,
+    );
+  }
+
+  // Collect migrations that come after the target, in reverse order
+  const migrationsToRollback = migrations.slice(targetIndex + 1).reverse();
+  if (migrationsToRollback.length === 0) {
+    log.info("No migrations to roll back");
+    return;
+  }
+
+  const checkpoints = loadCheckpoints(workspaceDir);
+
+  for (const migration of migrationsToRollback) {
+    // Only roll back migrations that have been fully applied.
+    // Legacy checkpoints may not have a status field (just appliedAt) — treat
+    // missing/undefined status as completed, matching runWorkspaceMigrations behavior.
+    const entry = checkpoints.applied[migration.id];
+    if (
+      !entry ||
+      entry.status === "started" ||
+      entry.status === "rolling_back"
+    ) {
+      continue;
+    }
+
+    log.info(
+      `Rolling back workspace migration: ${migration.id} — ${migration.description}`,
+    );
+
+    // Mark as rolling_back before execution (for crash recovery)
+    checkpoints.applied[migration.id] = {
+      appliedAt: checkpoints.applied[migration.id]!.appliedAt,
+      status: "rolling_back",
+    };
+    saveCheckpoints(workspaceDir, checkpoints);
+
+    try {
+      await migration.down(workspaceDir);
+    } catch (error) {
+      log.error(
+        { migrationId: migration.id, error },
+        `Workspace migration rollback failed: ${migration.id}`,
+      );
+      throw error;
+    }
+
+    // Remove the migration entry from checkpoints
+    delete checkpoints.applied[migration.id];
+    saveCheckpoints(workspaceDir, checkpoints);
+
+    log.info(`Rolled back workspace migration: ${migration.id}`);
+  }
+}

package/src/workspace/migrations/types.ts

@@ -8,4 +8,8 @@ export interface WorkspaceMigration {
    *  Must be idempotent — safe to re-run if it was interrupted.
    *  Both synchronous and asynchronous migrations are supported. */
   run(workspaceDir: string): void | Promise<void>;
+  /** Reverse the migration. Receives the workspace directory path.
+   *  Must be idempotent — safe to re-run if it was interrupted.
+   *  Both synchronous and asynchronous rollbacks are supported. */
+  down(workspaceDir: string): void | Promise<void>;
 }

package/src/__tests__/claude-code-skill-regression.test.ts

@@ -1,206 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { describe, expect, mock, spyOn, test } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Mocks — must be set up before importing modules that use them
-// ---------------------------------------------------------------------------
-
-mock.module("@anthropic-ai/claude-agent-sdk", () => ({
-  query: () => ({
-    async *[Symbol.asyncIterator]() {
-      yield {
-        type: "result" as const,
-        session_id: "s",
-        subtype: "success" as const,
-        result: "ok",
-      };
-    },
-  }),
-}));
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-    services: {
-      inference: {
-        mode: "your-own",
-        provider: "anthropic",
-        model: "claude-opus-4-6",
-      },
-      "image-generation": {
-        mode: "your-own",
-        provider: "gemini",
-        model: "gemini-3.1-flash-image-preview",
-      },
-      "web-search": { mode: "your-own", provider: "inference-provider-native" },
-    },
-  }),
-  loadConfig: () => ({}),
-  loadRawConfig: () => ({}),
-  saveConfig: () => {},
-  saveRawConfig: () => {},
-  invalidateConfigCache: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-  syncConfigToLockfile: () => {},
-}));
-
-mock.module("../security/secure-keys.js", () => ({
-  getSecureKeyAsync: async (name: string) =>
-    name === "anthropic" ? "fake-anthropic-key" : null,
-  getProviderKeyAsync: async (provider: string) =>
-    provider === "anthropic" ? "fake-anthropic-key" : undefined,
-}));
-
-// ---------------------------------------------------------------------------
-// Imports (after mocks)
-// ---------------------------------------------------------------------------
-
-import { claudeCodeTool } from "../tools/claude-code/claude-code.js";
-
-// ---------------------------------------------------------------------------
-// Locate the bundled skill directory relative to the test file
-// ---------------------------------------------------------------------------
-
-const SKILL_DIR = path.resolve(
-  import.meta.dirname ?? __dirname,
-  "../config/bundled-skills/claude-code",
-);
-
-const SHARED_DIR = path.resolve(
-  import.meta.dirname ?? __dirname,
-  "../config/bundled-skills/_shared",
-);
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("Claude Code skill migration regression", () => {
-  test("skill script wrapper exports a `run` function", async () => {
-    const wrapperPath = path.join(SKILL_DIR, "tools/claude-code.ts");
-    // The wrapper module must exist and export `run`
-    const mod = await import(wrapperPath);
-    expect(typeof mod.run).toBe("function");
-  });
-
-  test("TOOLS.json manifest lists claude_code as the tool name", () => {
-    const manifestPath = path.join(SKILL_DIR, "TOOLS.json");
-    const raw = fs.readFileSync(manifestPath, "utf-8");
-    const manifest = JSON.parse(raw);
-
-    expect(manifest.version).toBe(1);
-    expect(Array.isArray(manifest.tools)).toBe(true);
-
-    const toolNames = manifest.tools.map((t: { name: string }) => t.name);
-    expect(toolNames).toContain("claude_code");
-  });
-
-  test("TOOLS.json input_schema matches claudeCodeTool.getDefinition()", () => {
-    const manifestPath = path.join(SKILL_DIR, "TOOLS.json");
-    const raw = fs.readFileSync(manifestPath, "utf-8");
-    const manifest = JSON.parse(raw);
-
-    const manifestTool = manifest.tools.find(
-      (t: { name: string }) => t.name === "claude_code",
-    );
-    expect(manifestTool).toBeDefined();
-
-    const runtimeDef = claudeCodeTool.getDefinition();
-
-    // The input_schema declared in the static manifest must match the
-    // runtime definition. Drift here would mean the model sees a different
-    // schema than the executor actually supports.
-    expect(manifestTool.input_schema).toEqual(runtimeDef.input_schema);
-  });
-
-  test("TOOLS.json description matches claudeCodeTool.getDefinition()", () => {
-    const manifestPath = path.join(SKILL_DIR, "TOOLS.json");
-    const raw = fs.readFileSync(manifestPath, "utf-8");
-    const manifest = JSON.parse(raw);
-
-    const manifestTool = manifest.tools.find(
-      (t: { name: string }) => t.name === "claude_code",
-    );
-    expect(manifestTool).toBeDefined();
-
-    const runtimeDef = claudeCodeTool.getDefinition();
-
-    // Description parity guards against a manifest edit that diverges from
-    // the canonical tool description.
-    expect(manifestTool.description).toBe(runtimeDef.description);
-  });
-
-  test("wrapper run() delegates to claudeCodeTool.execute()", async () => {
-    // Verifies the wrapper is not a stale stub but actually calls through
-    // to the canonical execute method with the exact input and context.
-    const spy = spyOn(claudeCodeTool, "execute");
-
-    const wrapperPath = path.join(SKILL_DIR, "tools/claude-code.ts");
-    const mod = await import(wrapperPath);
-
-    const input = { prompt: "hello" };
-    const ctx = {
-      conversationId: "test",
-      workingDir: "/tmp",
-      onOutput: () => {},
-    };
-
-    const result = await mod.run(input, ctx);
-    expect(result.isError).toBeFalsy();
-
-    // The wrapper must delegate to the canonical execute method
-    expect(spy).toHaveBeenCalledTimes(1);
-    expect(spy).toHaveBeenCalledWith(input, ctx);
-
-    spy.mockRestore();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Bundled skill shared guidance — CES tools instead of token-reveal
-// ---------------------------------------------------------------------------
-
-describe("CLI_RETRIEVAL_PATTERN.md CES guidance", () => {
-  const patternPath = path.join(SHARED_DIR, "CLI_RETRIEVAL_PATTERN.md");
-  const content = fs.readFileSync(patternPath, "utf-8");
-
-  test("teaches handle discovery via assistant credentials list", () => {
-    expect(content).toContain("assistant credentials list");
-  });
-
-  test("teaches handle discovery via assistant oauth connections list", () => {
-    expect(content).toContain("assistant oauth connections list");
-  });
-
-  test("teaches make_authenticated_request CES tool", () => {
-    expect(content).toContain("make_authenticated_request");
-  });
-
-  test("teaches run_authenticated_command CES tool", () => {
-    expect(content).toContain("run_authenticated_command");
-  });
-
-  test("warns that host_bash is outside CES secrecy boundary", () => {
-    expect(content).toContain("outside the CES secrecy boundary");
-  });
-
-  // -- Deprecated patterns must NOT appear --
-
-  test("does not teach proxied bash with credential_ids", () => {
-    expect(content).not.toContain("credential_ids");
-    expect(content).not.toContain("network_mode: proxied");
-  });
-
-  test("does not teach oauth connections token for raw token extraction", () => {
-    expect(content).not.toContain("oauth connections token");
-  });
-});