@vellumai/assistant 0.5.16 → 0.6.0

package/src/workspace/migrations/026-backfill-install-meta.ts

@@ -0,0 +1,325 @@
+/**
+ * Workspace migration 026: Backfill install-meta.json for existing skills
+ *
+ * Scans ~/.vellum/workspace/skills/ for installed skill directories and writes
+ * an install-meta.json for each skill that lacks one, inferring the origin
+ * from legacy version.json and .integrity.json files.
+ *
+ * Idempotent: safe to re-run after interruption at any point.
+ */
+
+import { randomUUID } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const INSTALL_META_FILENAME = "install-meta.json";
+const VERSION_JSON_FILENAME = "version.json";
+const INTEGRITY_JSON_FILENAME = ".integrity.json";
+const SKILL_MD_FILENAME = "SKILL.md";
+
+// ---------------------------------------------------------------------------
+// Inlined helpers (self-contained per migrations/AGENTS.md)
+// ---------------------------------------------------------------------------
+
+interface SkillInstallMeta {
+  origin: "vellum" | "clawhub" | "skillssh" | "custom";
+  installedAt: string;
+  installedBy?: string;
+  backfilledBy?: string;
+  version?: string;
+  slug?: string;
+  sourceRepo?: string;
+  contentHash?: string;
+}
+
+/**
+ * Atomically write a file: write to a temp file, then rename.
+ */
+function atomicWriteFile(filePath: string, content: string): void {
+  const dir = dirname(filePath);
+  mkdirSync(dir, { recursive: true });
+  const tmpPath = join(dir, `.tmp-${randomUUID()}`);
+  writeFileSync(tmpPath, content, "utf-8");
+  renameSync(tmpPath, filePath);
+}
+
+/**
+ * Write install-meta.json into a skill directory.
+ */
+function writeInstallMeta(skillDir: string, meta: SkillInstallMeta): void {
+  const filePath = join(skillDir, INSTALL_META_FILENAME);
+  atomicWriteFile(filePath, JSON.stringify(meta, null, 2) + "\n");
+}
+
+/**
+ * Metadata files excluded from content hashing.
+ */
+const METADATA_FILENAMES = new Set([
+  INSTALL_META_FILENAME,
+  VERSION_JSON_FILENAME,
+]);
+
+/**
+ * Collect all file contents in a directory tree, sorted by relative path.
+ * Metadata files at root level are excluded.
+ */
+function collectFileContents(
+  dir: string,
+  prefix = "",
+): Array<{ relPath: string; content: Buffer }> {
+  const results: Array<{ relPath: string; content: Buffer }> = [];
+  if (!existsSync(dir)) return results;
+
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!prefix && METADATA_FILENAMES.has(entry.name)) continue;
+
+    const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...collectFileContents(fullPath, relPath));
+    } else if (entry.isFile()) {
+      results.push({ relPath, content: readFileSync(fullPath) });
+    }
+  }
+  return results.sort((a, b) => a.relPath.localeCompare(b.relPath));
+}
+
+/**
+ * Compute SHA-256 content hash over all non-metadata files in a skill dir.
+ * Returns format: "v2:sha256hex".
+ */
+function computeSkillHash(skillDir: string): string | null {
+  if (!existsSync(skillDir) || !statSync(skillDir).isDirectory()) return null;
+
+  const files = collectFileContents(skillDir);
+  if (files.length === 0) return null;
+
+  const hasher = new Bun.CryptoHasher("sha256");
+  for (const file of files) {
+    const pathBuf = Buffer.from(file.relPath, "utf-8");
+    hasher.update(`${pathBuf.length}:`);
+    hasher.update(pathBuf);
+    hasher.update(`${file.content.length}:`);
+    hasher.update(file.content);
+  }
+  return `v2:${hasher.digest("hex")}`;
+}
+
+// ---------------------------------------------------------------------------
+// Integrity manifest helpers
+// ---------------------------------------------------------------------------
+
+interface IntegrityRecord {
+  sha256: string;
+  installedAt: string;
+}
+
+type IntegrityManifest = Record<string, IntegrityRecord>;
+
+function loadIntegrityManifest(skillsDir: string): IntegrityManifest {
+  const path = join(skillsDir, INTEGRITY_JSON_FILENAME);
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf-8")) as IntegrityManifest;
+  } catch {
+    return {};
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Origin inference
+// ---------------------------------------------------------------------------
+
+/**
+ * Infer SkillInstallMeta for a skill directory that has no install-meta.json.
+ *
+ * Decision tree:
+ * 1. version.json with `origin: "skills.sh"` -> skillssh
+ * 2. version.json with `version` but no `origin` field:
+ *    - Has entry in .integrity.json -> clawhub
+ *    - Otherwise -> vellum
+ * 3. version.json exists but doesn't match above -> custom
+ * 4. No version.json:
+ *    - Has entry in .integrity.json -> clawhub
+ *    - Otherwise -> custom
+ */
+function inferInstallMeta(
+  skillDir: string,
+  skillId: string,
+  integrityManifest: IntegrityManifest,
+): SkillInstallMeta {
+  const versionJsonPath = join(skillDir, VERSION_JSON_FILENAME);
+  const hasIntegrityEntry = skillId in integrityManifest;
+
+  if (existsSync(versionJsonPath)) {
+    let raw: Record<string, unknown>;
+    try {
+      raw = JSON.parse(readFileSync(versionJsonPath, "utf-8")) as Record<
+        string,
+        unknown
+      >;
+    } catch {
+      // Malformed version.json — treat as if it doesn't exist
+      return buildFallbackMeta(skillDir, skillId, hasIntegrityEntry);
+    }
+
+    // Case 1: skills.sh origin
+    if (raw.origin === "skills.sh") {
+      return {
+        origin: "skillssh",
+        installedAt:
+          typeof raw.installedAt === "string"
+            ? raw.installedAt
+            : getDirectoryMtime(skillDir),
+        sourceRepo: typeof raw.source === "string" ? raw.source : undefined,
+        slug: typeof raw.skillSlug === "string" ? raw.skillSlug : undefined,
+        contentHash: computeSkillHash(skillDir) ?? undefined,
+      };
+    }
+
+    // Case 2: has version but no origin field
+    if (typeof raw.version === "string" && !("origin" in raw)) {
+      return {
+        origin: hasIntegrityEntry ? "clawhub" : "vellum",
+        installedAt:
+          typeof raw.installedAt === "string"
+            ? raw.installedAt
+            : getDirectoryMtime(skillDir),
+        version: raw.version,
+        contentHash: computeSkillHash(skillDir) ?? undefined,
+      };
+    }
+
+    // Case 3: version.json exists but doesn't match known patterns
+    return {
+      origin: "custom",
+      installedAt:
+        typeof raw.installedAt === "string"
+          ? raw.installedAt
+          : getDirectoryMtime(skillDir),
+      contentHash: computeSkillHash(skillDir) ?? undefined,
+    };
+  }
+
+  // Case 4: no version.json
+  return buildFallbackMeta(skillDir, skillId, hasIntegrityEntry);
+}
+
+function buildFallbackMeta(
+  skillDir: string,
+  _skillId: string,
+  hasIntegrityEntry: boolean,
+): SkillInstallMeta {
+  return {
+    origin: hasIntegrityEntry ? "clawhub" : "custom",
+    installedAt: getDirectoryMtime(skillDir),
+    contentHash: computeSkillHash(skillDir) ?? undefined,
+  };
+}
+
+/**
+ * Get directory mtime as ISO 8601 string. Falls back to current time.
+ */
+function getDirectoryMtime(dir: string): string {
+  try {
+    return statSync(dir).mtime.toISOString();
+  } catch {
+    return new Date().toISOString();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Migration
+// ---------------------------------------------------------------------------
+
+export const backfillInstallMetaMigration: WorkspaceMigration = {
+  id: "026-backfill-install-meta",
+  description:
+    "Backfill install-meta.json with origin field for existing skill directories",
+
+  run(workspaceDir: string): void {
+    const skillsDir = join(workspaceDir, "skills");
+    if (!existsSync(skillsDir)) return;
+
+    // Load the integrity manifest once — shared across all skills
+    const integrityManifest = loadIntegrityManifest(skillsDir);
+
+    // Enumerate skill directories (each subdirectory containing a SKILL.md)
+    let dirNames: string[];
+    try {
+      dirNames = readdirSync(skillsDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name);
+    } catch {
+      return;
+    }
+
+    for (const name of dirNames) {
+      const skillDir = join(skillsDir, name);
+      const skillMdPath = join(skillDir, SKILL_MD_FILENAME);
+      const installMetaPath = join(skillDir, INSTALL_META_FILENAME);
+
+      // Only process directories that contain SKILL.md
+      if (!existsSync(skillMdPath)) continue;
+
+      // Skip if install-meta.json already exists (idempotency)
+      if (existsSync(installMetaPath)) continue;
+
+      const meta = inferInstallMeta(skillDir, name, integrityManifest);
+
+      // Mark as backfilled so down() can safely identify and remove only
+      // migration-created files without touching CLI-installed ones.
+      writeInstallMeta(skillDir, { ...meta, backfilledBy: "migration-026" });
+    }
+  },
+
+  down(workspaceDir: string): void {
+    const skillsDir = join(workspaceDir, "skills");
+    if (!existsSync(skillsDir)) return;
+
+    let dirNames: string[];
+    try {
+      dirNames = readdirSync(skillsDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name);
+    } catch {
+      return;
+    }
+
+    for (const name of dirNames) {
+      const installMetaPath = join(skillsDir, name, INSTALL_META_FILENAME);
+      if (existsSync(installMetaPath)) {
+        try {
+          const meta = JSON.parse(
+            readFileSync(installMetaPath, "utf-8"),
+          ) as SkillInstallMeta;
+
+          // Only remove install-meta.json that were backfilled by this migration.
+          // Files written by the normal install flow (CLI, daemon, etc.) won't
+          // have backfilledBy set and are safely preserved on rollback.
+          if (meta.backfilledBy === "migration-026") {
+            unlinkSync(installMetaPath);
+          }
+        } catch {
+          // Malformed file — skip
+        }
+      }
+    }
+  },
+};

package/src/workspace/migrations/027-remove-orphaned-optimized-images-cache.ts

@@ -0,0 +1,42 @@
+/**
+ * Workspace migration 027: Remove orphaned optimized-images cache directory.
+ *
+ * The optimized image cache was moved from `workspace/cache/optimized-images/`
+ * to `os.tmpdir()/vellum-optimized-images/`. This migration cleans up the old
+ * directory and removes the parent `cache/` directory if it is now empty.
+ *
+ * Idempotent: safe to re-run after interruption at any point.
+ */
+
+import { existsSync, readdirSync, rmdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+export const removeOrphanedOptimizedImagesCacheMigration: WorkspaceMigration = {
+  id: "027-remove-orphaned-optimized-images-cache",
+  description:
+    "Remove orphaned cache/optimized-images/ directory after cache moved to tmpdir",
+
+  run(workspaceDir: string): void {
+    const cacheDir = join(workspaceDir, "cache");
+    const optimizedImagesDir = join(cacheDir, "optimized-images");
+
+    if (existsSync(optimizedImagesDir)) {
+      rmSync(optimizedImagesDir, { recursive: true, force: true });
+    }
+
+    // Remove the parent cache/ directory if it is now empty
+    if (existsSync(cacheDir)) {
+      const remaining = readdirSync(cacheDir);
+      if (remaining.length === 0) {
+        rmdirSync(cacheDir);
+      }
+    }
+  },
+
+  down(_workspaceDir: string): void {
+    // The old cache directory contained ephemeral cached data that does not
+    // need to be restored. The cache will be rebuilt in tmpdir on next use.
+  },
+};

package/src/workspace/migrations/registry.ts

@@ -21,6 +21,9 @@ import { moveSignalsToWorkspaceMigration } from "./021-move-signals-to-workspace
 import { moveHooksToWorkspaceMigration } from "./022-move-hooks-to-workspace.js";
 import { moveConfigFilesToWorkspaceMigration } from "./023-move-config-files-to-workspace.js";
 import { moveRuntimeFilesToWorkspaceMigration } from "./024-move-runtime-files-to-workspace.js";
+import { removeOauthAppSetupSkillsMigration } from "./025-remove-oauth-app-setup-skills.js";
+import { backfillInstallMetaMigration } from "./026-backfill-install-meta.js";
+import { removeOrphanedOptimizedImagesCacheMigration } from "./027-remove-orphaned-optimized-images-cache.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -53,4 +56,7 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   moveHooksToWorkspaceMigration,
   moveConfigFilesToWorkspaceMigration,
   moveRuntimeFilesToWorkspaceMigration,
+  removeOauthAppSetupSkillsMigration,
+  backfillInstallMetaMigration,
+  removeOrphanedOptimizedImagesCacheMigration,
 ];