claude-code-arcane 2.9.2 → 2.9.4

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [2.9.4](https://github.com/SebastianLuser/claude-code-arcane/compare/v2.9.3...v2.9.4) (2026-09-07)
+
+
+### Bug Fixes
+
+* **add:** keep content_hashes instead of rebuilding the manifest ([1ecce98](https://github.com/SebastianLuser/claude-code-arcane/commit/1ecce98ebcb8a480dd4b748f41606badec9fb0fd))
+* **cache:** resolve the arcane home in one place, honouring ARCANE_HOME ([4a7a24d](https://github.com/SebastianLuser/claude-code-arcane/commit/4a7a24d6a28df1abfe94be75f590c79d8428dca5))
+
+## [2.9.3](https://github.com/SebastianLuser/claude-code-arcane/compare/v2.9.2...v2.9.3) (2026-09-07)
+
+
+### Bug Fixes
+
+* **update:** resolve the content version once per run, never fabricate it ([ef78ecf](https://github.com/SebastianLuser/claude-code-arcane/commit/ef78ecf6c5ab17f1a51ea6ae27ef9fa161594798))
+
 ## [2.9.2](https://github.com/SebastianLuser/claude-code-arcane/compare/v2.9.1...v2.9.2) (2026-09-07)
 
 

package/dist/cli.js

@@ -391,6 +391,10 @@ import path8 from "path";
 import { fileURLToPath } from "url";
 import path3 from "path";
 import fs3 from "fs";
+import os from "os";
+function arcaneHome() {
+  return process.env.ARCANE_HOME ?? path3.join(os.homedir(), ".arcane");
+}
 function getPackageRoot() {
   const thisFile = fileURLToPath(import.meta.url);
   return path3.resolve(path3.dirname(thisFile), "..");
@@ -1310,15 +1314,18 @@ import os2 from "os";
 // src/cache.ts
 import fs8 from "fs";
 import path9 from "path";
-import os from "os";
-var ARCANE_DIR = path9.join(os.homedir(), ".arcane");
-var CACHE_DIR = path9.join(ARCANE_DIR, "cache");
+function cacheDir() {
+  return path9.join(arcaneHome(), "cache");
+}
 function getCachePath(version) {
-  return path9.join(CACHE_DIR, version);
+  return path9.join(cacheDir(), version);
+}
+function isUsableContentRoot(dir) {
+  return fs8.existsSync(path9.join(dir, "profiles")) && fs8.existsSync(path9.join(dir, "skills"));
 }
 function isCached(version) {
   const versionDir = getCachePath(version);
-  return fs8.existsSync(versionDir) && fs8.existsSync(path9.join(versionDir, ".cache-meta.json"));
+  return fs8.existsSync(versionDir) && fs8.existsSync(path9.join(versionDir, ".cache-meta.json")) && isUsableContentRoot(versionDir);
 }
 function getCachedContentRoot(version) {
   if (!isCached(version)) return null;
@@ -1347,9 +1354,9 @@ function storeInCache(version, contentDir) {
   return versionDir;
 }
 function pruneCache(keepCount = 3) {
-  if (!fs8.existsSync(CACHE_DIR)) return;
-  const entries = fs8.readdirSync(CACHE_DIR, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => {
-    const metaPath = path9.join(CACHE_DIR, e.name, ".cache-meta.json");
+  if (!fs8.existsSync(cacheDir())) return;
+  const entries = fs8.readdirSync(cacheDir(), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => {
+    const metaPath = path9.join(cacheDir(), e.name, ".cache-meta.json");
     let cachedAt = 0;
     if (fs8.existsSync(metaPath)) {
       try {
@@ -1362,9 +1369,24 @@ function pruneCache(keepCount = 3) {
     return { name: e.name, cachedAt };
   }).sort((a, b) => b.cachedAt - a.cachedAt);
   for (const entry of entries.slice(keepCount)) {
-    fs8.rmSync(path9.join(CACHE_DIR, entry.name), { recursive: true, force: true });
+    fs8.rmSync(path9.join(cacheDir(), entry.name), { recursive: true, force: true });
   }
 }
+function listCachedVersions() {
+  if (!fs8.existsSync(cacheDir())) return [];
+  return fs8.readdirSync(cacheDir(), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => {
+    const metaPath = path9.join(cacheDir(), e.name, ".cache-meta.json");
+    let cachedAt = "unknown";
+    if (fs8.existsSync(metaPath)) {
+      try {
+        const meta = JSON.parse(fs8.readFileSync(metaPath, "utf-8"));
+        cachedAt = meta.cached_at;
+      } catch {
+      }
+    }
+    return { version: e.name, cachedAt };
+  });
+}
 function copyDirRecursive(src, dest) {
   fs8.mkdirSync(dest, { recursive: true });
   for (const entry of fs8.readdirSync(src, { withFileTypes: true })) {
@@ -1439,22 +1461,18 @@ var GitHubContentSource = class {
       fs9.rmSync(tmpDir, { recursive: true, force: true });
     }
   }
-  async isAvailable() {
-    try {
-      const response = await fetch(
-        `https://api.github.com/repos/${this.owner}/${this.repo}/commits/${this.branch}`,
-        {
-          method: "HEAD",
-          headers: { "User-Agent": "arcane-cli" },
-          signal: AbortSignal.timeout(5e3)
-        }
-      );
-      return response.ok;
-    } catch {
-      return false;
-    }
-  }
-  async getVersion() {
+  /**
+   * The head commit of the branch, or null when GitHub cannot answer.
+   *
+   * One request, memoized, shared by isAvailable() and getVersion(). It used to be
+   * two - a HEAD to answer "is it reachable?" and a GET to read the sha - against an
+   * endpoint that allows 60 requests an hour unauthenticated. That doubled the cost of
+   * every resolution and, worse, opened a window between the two calls: the HEAD spent
+   * the last request of the hour, the GET came back 403, and the caller had already
+   * committed to the github source. That window is where the fabricated versions came
+   * from.
+   */
+  async resolveVersion() {
     if (this.resolvedVersion) return this.resolvedVersion;
     try {
       const response = await fetch(
@@ -1467,17 +1485,36 @@ var GitHubContentSource = class {
           signal: AbortSignal.timeout(1e4)
         }
       );
-      if (!response.ok) {
-        throw new Error(`GitHub API returned ${response.status}`);
-      }
+      if (!response.ok) return null;
       const data = await response.json();
       this.resolvedVersion = data.sha.substring(0, 12);
       return this.resolvedVersion;
     } catch {
-      this.resolvedVersion = `github-${Date.now()}`;
-      return this.resolvedVersion;
+      return null;
     }
   }
+  async isAvailable() {
+    return await this.resolveVersion() !== null;
+  }
+  /**
+   * Throws when the version cannot be read, rather than inventing one.
+   *
+   * It used to answer `github-${Date.now()}` on any failure, and that string went on to
+   * be an identity: it stamped `source_version` in the manifest, named a cache directory,
+   * and made the install permanently un-diffable against any real version - it never
+   * matched again, so every later run reported an update and no run ever settled. A
+   * transient 403 became durable state on disk. Callers that cannot proceed without a
+   * version now fall back to the cache, which knows a real one.
+   */
+  async getVersion() {
+    const version = await this.resolveVersion();
+    if (!version) {
+      throw new Error(
+        "Could not read the content version from GitHub (offline, or the unauthenticated API rate limit is exhausted - it resets hourly)."
+      );
+    }
+    return version;
+  }
   async downloadAndExtract(destDir) {
     const tarballUrl = `https://api.github.com/repos/${this.owner}/${this.repo}/tarball/${this.branch}`;
     const response = await fetch(tarballUrl, {
@@ -1548,7 +1585,9 @@ async function resolveContentSource(opts = {}) {
       return github;
     }
     if (preference === "github") {
-      throw new Error("GitHub source requested but not available. Check your internet connection.");
+      throw new Error(
+        "GitHub source requested but not available. Check your internet connection, or wait for the unauthenticated API rate limit to reset (hourly)."
+      );
     }
     const cached = findLatestCache();
     if (cached) {
@@ -1578,31 +1617,16 @@ async function resolveContentSourceForVersion(version, opts = {}) {
   return source;
 }
 function findLatestCache() {
-  const cacheDir = path10.join(os2.homedir(), ".arcane", "cache");
-  if (!fs9.existsSync(cacheDir)) return null;
-  const entries = fs9.readdirSync(cacheDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => {
-    const metaPath = path10.join(cacheDir, e.name, ".cache-meta.json");
-    let cachedAt = 0;
-    if (fs9.existsSync(metaPath)) {
-      try {
-        const meta = JSON.parse(fs9.readFileSync(metaPath, "utf-8"));
-        cachedAt = new Date(meta.cached_at).getTime();
-      } catch {
-        cachedAt = 0;
-      }
-    }
-    return { name: e.name, cachedAt };
-  }).sort((a, b) => b.cachedAt - a.cachedAt);
-  return entries.length > 0 ? entries[0].name : null;
+  const usable = listCachedVersions().filter((entry) => isCached(entry.version)).map((entry) => ({
+    version: entry.version,
+    cachedAt: new Date(entry.cachedAt).getTime() || 0
+  })).sort((a, b) => b.cachedAt - a.cachedAt);
+  return usable.length > 0 ? usable[0].version : null;
 }
 
 // src/registry.ts
 import path11 from "path";
-import os3 from "os";
 var REGISTRY_VERSION = 1;
-function arcaneHome() {
-  return process.env.ARCANE_HOME ?? path11.join(os3.homedir(), ".arcane");
-}
 function registryPath() {
   return path11.join(arcaneHome(), "installations.json");
 }
@@ -1881,16 +1905,11 @@ async function addCommand(items = []) {
   manifest.installed_skills.push(...added);
   manifest.total_skills = manifest.installed_skills.length;
   manifest.total_rules = manifest.installed_rules.length;
-  const merged = {
-    loaded: manifest.profiles,
-    skills: manifest.installed_skills,
-    rules: { universal: manifest.installed_rules, gamedev: [] },
-    agents: manifest.installed_agents,
-    hooks: [],
-    output_styles: [],
-    permissions: { allow: [], deny: [] }
-  };
-  writeManifest(target, merged, manifest.profile_command, root);
+  persistAdditions(target, claudeDir, manifest, {
+    skills: added,
+    rules: addedRules,
+    agents: addedAgents
+  });
   const totalAdded = added.length + addedRules.length + addedAgents.length + (statuslineAdded ? 1 : 0);
   console.log(
     chalk3.bold(
@@ -1915,6 +1934,35 @@ Added ${totalAdded} items:`
     );
   }
 }
+function persistAdditions(target, claudeDir, manifest, addedItems) {
+  const updates = {
+    profiles: manifest.profiles,
+    profile_command: manifest.profile_command,
+    installed_skills: manifest.installed_skills,
+    installed_rules: manifest.installed_rules,
+    installed_agents: manifest.installed_agents,
+    total_skills: manifest.total_skills,
+    total_rules: manifest.total_rules,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z")
+  };
+  const hashes = manifest.content_hashes;
+  if (hashes) {
+    const fresh = computeContentHashes(claudeDir);
+    for (const skill of addedItems.skills) {
+      if (fresh.skills[skill]) hashes.skills[skill] = fresh.skills[skill];
+    }
+    for (const rule of addedItems.rules) {
+      const key = rule.endsWith(".md") ? rule : `${rule}.md`;
+      if (fresh.rules[key]) hashes.rules[key] = fresh.rules[key];
+    }
+    for (const entry of addedItems.agents) {
+      const { division } = parseAgentEntry(entry);
+      if (fresh.agents[division]) hashes.agents[division] = fresh.agents[division];
+    }
+    updates.content_hashes = hashes;
+  }
+  updateManifestFields(target, updates);
+}
 function printCatalog(root, installedProfiles, installedSkills) {
   const profiles = listProfiles(path14.join(root, "profiles")).filter(
     (pr) => !installedProfiles.includes(pr.name)
@@ -2261,7 +2309,7 @@ async function statusCommand() {
 // src/commands/update.ts
 import fs14 from "fs";
 import path17 from "path";
-import os4 from "os";
+import os3 from "os";
 import chalk7 from "chalk";
 
 // src/self-update.ts
@@ -2341,7 +2389,7 @@ async function updateCommand(opts) {
     registerInstallation(cwd);
   }
   const targets = pruneRegistry().map((e) => e.path);
-  const globalTarget = os4.homedir();
+  const globalTarget = os3.homedir();
   if (!process.env.VITEST && fs14.existsSync(manifestPath(globalTarget)) && !targets.includes(globalTarget)) {
     targets.push(globalTarget);
   }
@@ -2357,6 +2405,10 @@ async function updateCommand(opts) {
 Updating ${targets.length} installation${targets.length === 1 ? "" : "s"}...`)
     );
   }
+  const sharedSource = await resolveContentSource({
+    source: opts.source ?? "auto",
+    quiet: opts.quiet
+  });
   const results = [];
   for (const target of targets) {
     if (!opts.quiet) {
@@ -2364,7 +2416,7 @@ Updating ${targets.length} installation${targets.length === 1 ? "" : "s"}...`)
 \u2022 ${target}`));
     }
     try {
-      results.push(await updateTarget(target, opts));
+      results.push(await updateTarget(target, opts, sharedSource));
     } catch (err) {
       if (!opts.quiet) {
         console.log(chalk7.red(`  Update failed: ${err.message}`));
@@ -2382,7 +2434,7 @@ Updating ${targets.length} installation${targets.length === 1 ? "" : "s"}...`)
     printGeneralSummary(results, opts.dryRun ?? false);
   }
 }
-async function updateTarget(target, opts) {
+async function updateTarget(target, opts, sharedSource) {
   const manifest = readManifest(target);
   if (!manifest) {
     if (!opts.quiet) {
@@ -2390,7 +2442,7 @@ async function updateTarget(target, opts) {
     }
     return { target, status: "no-manifest", updated: 0, skipped: 0, removed: 0 };
   }
-  const contentSource = await resolveContentSource({
+  const contentSource = sharedSource ?? await resolveContentSource({
     source: opts.source ?? "auto",
     quiet: opts.quiet
   });
@@ -3001,9 +3053,9 @@ async function worktreeCommand(branch, opts) {
 // src/commands/global.ts
 import fs16 from "fs";
 import path19 from "path";
-import os5 from "os";
+import os4 from "os";
 import chalk10 from "chalk";
-var CLAUDE_HOME = path19.join(os5.homedir(), ".claude");
+var CLAUDE_HOME = path19.join(os4.homedir(), ".claude");
 var SCRIPTS_DIR = path19.join(CLAUDE_HOME, "scripts", "worktree-isolation");
 var SETTINGS_PATH = path19.join(CLAUDE_HOME, "settings.json");
 async function globalCommand(opts) {
@@ -3170,9 +3222,10 @@ function removeHookFromSettings() {
 // src/update-check.ts
 import fs17 from "fs";
 import path20 from "path";
-import os6 from "os";
 import chalk11 from "chalk";
-var CHECK_FILE = path20.join(os6.homedir(), ".arcane", "last-check.json");
+function checkFile() {
+  return path20.join(arcaneHome(), "last-check.json");
+}
 var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
 var GITHUB_OWNER2 = "SebastianLuser";
 var GITHUB_REPO2 = "Claude-Code-Arcane";
@@ -3297,19 +3350,21 @@ async function getLatestNpmVersion() {
 }
 function readCachedCheck() {
   try {
-    if (!fs17.existsSync(CHECK_FILE)) return null;
-    return JSON.parse(fs17.readFileSync(CHECK_FILE, "utf-8"));
+    const file = checkFile();
+    if (!fs17.existsSync(file)) return null;
+    return JSON.parse(fs17.readFileSync(file, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeCachedCheck(result) {
   try {
-    const dir = path20.dirname(CHECK_FILE);
+    const file = checkFile();
+    const dir = path20.dirname(file);
     if (!fs17.existsSync(dir)) {
       fs17.mkdirSync(dir, { recursive: true });
     }
-    fs17.writeFileSync(CHECK_FILE, JSON.stringify(result, null, 2) + "\n");
+    fs17.writeFileSync(file, JSON.stringify(result, null, 2) + "\n");
   } catch {
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-arcane",
-  "version": "2.9.2",
+  "version": "2.9.4",
   "description": "Skills, agents, hooks and rules for Claude Code — installable via npx claude-code-arcane",
   "type": "module",
   "bin": {