context-mode 1.0.112 → 1.0.114

package/openclaw.plugin.json

@@ -3,7 +3,7 @@
   "name": "Context Mode",
   "kind": "tool",
   "description": "OpenClaw plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
-  "version": "1.0.112",
+  "version": "1.0.114",
   "sandbox": {
     "mode": "permissive",
     "filesystem_access": "full",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.112",
+  "version": "1.0.114",
   "type": "module",
   "description": "MCP plugin that saves 98% of your context window. Works with Claude Code, Gemini CLI, VS Code Copilot, OpenCode, and Codex CLI. Sandboxed code execution, FTS5 knowledge base, and intent-driven search.",
   "author": "Mert Koseoğlu",
@@ -79,6 +79,7 @@
     "start.mjs",
     "scripts/postinstall.mjs",
     "scripts/heal-better-sqlite3.mjs",
+    "scripts/heal-installed-plugins.mjs",
     "README.md",
     "LICENSE"
   ],

package/scripts/heal-installed-plugins.mjs

@@ -0,0 +1,129 @@
+/**
+ * Self-heal `~/.claude/plugins/installed_plugins.json` (#46915 follow-up).
+ *
+ * v1.0.113's `/ctx-upgrade` poisoned this file in two ways:
+ *   1. Per-entry `version` drifted from the actual cache directory's
+ *      `plugin.json` version.
+ *   2. The top-level `enabledPlugins[<key>]` was emptied (or never set)
+ *      so Claude Code's plugin loader skipped context-mode → MCP died.
+ *
+ * Single source of truth shared by:
+ *   - `start.mjs` HEAL 3+4 (every MCP boot)
+ *   - `scripts/postinstall.mjs` (every `npm install -g context-mode`)
+ *
+ * Pure Node.js (built-ins only). Best-effort: never throws, always
+ * returns a plain result object so callers can log a one-liner.
+ *
+ * @see https://github.com/anthropics/claude-code/issues/46915
+ */
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve, sep } from "node:path";
+
+/**
+ * @typedef {Object} HealResult
+ * @property {string[]} healed - one of: "entry-version", "enabled-plugins"
+ * @property {string} [skipped] - reason if no work performed
+ * @property {string} [error] - error message if heal aborted
+ */
+
+/**
+ * Heal a single plugin entry inside installed_plugins.json.
+ *
+ * @param {{
+ *   registryPath: string,
+ *   pluginCacheRoot: string,
+ *   pluginKey: string,
+ * }} opts
+ * @returns {HealResult}
+ */
+export function healInstalledPlugins({ registryPath, pluginCacheRoot, pluginKey }) {
+  if (!registryPath || !existsSync(registryPath)) {
+    return { healed: [], skipped: "no-registry" };
+  }
+
+  let raw;
+  try {
+    raw = readFileSync(registryPath, "utf-8");
+  } catch (err) {
+    return { healed: [], error: `read-failed: ${(err && err.message) || err}` };
+  }
+
+  let ip;
+  try {
+    ip = JSON.parse(raw);
+  } catch (err) {
+    return { healed: [], error: `parse-failed: ${(err && err.message) || err}` };
+  }
+  if (!ip || typeof ip !== "object") {
+    return { healed: [], error: "bad-shape" };
+  }
+
+  const entries = (ip.plugins && ip.plugins[pluginKey]) || [];
+  if (!Array.isArray(entries) || entries.length === 0) {
+    return { healed: [], skipped: "no-entry" };
+  }
+
+  /** @type {string[]} */
+  const healed = [];
+  let syncedVersion = null;
+
+  // ── HEAL 3: per-entry version <- cache plugin.json version ──
+  // We trust the cache directory because that's what start.mjs actually
+  // boots from; the registry is just a stale label.
+  for (const entry of entries) {
+    if (!entry || typeof entry !== "object") continue;
+    const installPath = entry.installPath;
+    if (!installPath || typeof installPath !== "string") continue;
+
+    // Path-traversal guard: only consult plugin.json files inside the
+    // declared plugin cache root.
+    const resolvedInstall = resolve(installPath);
+    const cacheRootWithSep = resolve(pluginCacheRoot) + sep;
+    if (!resolvedInstall.startsWith(cacheRootWithSep)) continue;
+
+    const cachePluginJson = resolve(installPath, ".claude-plugin", "plugin.json");
+    if (!existsSync(cachePluginJson)) continue;
+    let actualVersion = null;
+    try {
+      const pj = JSON.parse(readFileSync(cachePluginJson, "utf-8"));
+      if (pj && typeof pj.version === "string" && pj.version) {
+        actualVersion = pj.version;
+      }
+    } catch {
+      continue;
+    }
+    if (!actualVersion) continue;
+
+    syncedVersion = actualVersion;
+    if (entry.version !== actualVersion) {
+      entry.version = actualVersion;
+      if (!healed.includes("entry-version")) healed.push("entry-version");
+    }
+  }
+
+  // ── HEAL 4: top-level enabledPlugins[key] presence ──
+  // Claude Code's plugin loader checks enabledPlugins. When /ctx-upgrade
+  // emptied it, our plugin was silently disabled. Set it to `true` (the
+  // simplest enabled-flag form) when missing or falsy.
+  if (syncedVersion) {
+    if (!ip.enabledPlugins || typeof ip.enabledPlugins !== "object" || Array.isArray(ip.enabledPlugins)) {
+      ip.enabledPlugins = {};
+    }
+    const current = ip.enabledPlugins[pluginKey];
+    if (current === undefined || current === null || current === false || current === "") {
+      ip.enabledPlugins[pluginKey] = true;
+      healed.push("enabled-plugins");
+    }
+  }
+
+  if (healed.length > 0) {
+    try {
+      writeFileSync(registryPath, JSON.stringify(ip, null, 2) + "\n", "utf-8");
+    } catch (err) {
+      return { healed: [], error: `write-failed: ${(err && err.message) || err}` };
+    }
+  }
+
+  return { healed };
+}

package/scripts/postinstall.mjs

@@ -14,10 +14,33 @@ import { dirname, resolve, join, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
 import { healBetterSqlite3Binding } from "./heal-better-sqlite3.mjs";
+import { healInstalledPlugins } from "./heal-installed-plugins.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkgRoot = resolve(__dirname, "..");
 
+/**
+ * True when running as a real `npm install -g context-mode`. We use this
+ * to keep contributors' local `npm install` runs from rewriting their HOME's
+ * Claude Code registry (would be very surprising during dev).
+ *
+ * Heuristic: npm sets `npm_config_global=true` for global installs AND the
+ * package directory has no nearby `.git` (a contributor's clone always
+ * does). Both signals must agree.
+ */
+function isGlobalInstall() {
+  if (process.env.npm_config_global !== "true") return false;
+  // Walk up a few levels looking for .git — contributors always have one.
+  let dir = pkgRoot;
+  for (let i = 0; i < 4; i++) {
+    if (existsSync(join(dir, ".git"))) return false;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return true;
+}
+
 /**
  * Validate that a path is safe to interpolate into a cmd.exe command.
  * Rejects characters that could enable command injection via cmd.exe.
@@ -26,6 +49,41 @@ function isSafeWindowsPath(p) {
   return !/[&|<>"^%\r\n]/.test(p);
 }
 
+// ── -1. v1.0.114 hotfix — installed_plugins.json registry repair ─────
+// /ctx-upgrade in v1.0.113 poisoned the registry (entry.version drifted
+// + enabledPlugins emptied), making Claude Code's plugin loader skip
+// context-mode entirely. start.mjs HEAL 3+4 fix this on every MCP boot,
+// but already-broken users have no MCP to boot — they need the heal to
+// run from npm postinstall. Shared module so both call sites stay in
+// sync. Only runs in real `npm install -g` to avoid surprising
+// contributors. Best effort, never blocks install. (#46915 follow-up.)
+if (isGlobalInstall()) {
+  try {
+    const registryPath = resolve(homedir(), ".claude", "plugins", "installed_plugins.json");
+    const pluginCacheRoot = resolve(homedir(), ".claude", "plugins", "cache");
+    const result = healInstalledPlugins({
+      registryPath,
+      pluginCacheRoot,
+      pluginKey: "context-mode@context-mode",
+    });
+    if (result.skipped === "no-registry") {
+      // Standalone npm user (no Claude Code) — silent success.
+      process.stderr.write("context-mode: install OK, no Claude Code registry found\n");
+    } else if (result.error) {
+      process.stderr.write(`context-mode: install OK, registry heal skipped (${result.error})\n`);
+    } else if (result.healed && result.healed.length > 0) {
+      process.stderr.write(`context-mode: healed installed_plugins.json (${result.healed.join(", ")})\n`);
+    } else {
+      process.stderr.write("context-mode: install OK, no heal needed\n");
+    }
+  } catch (err) {
+    // Never block install on a heal failure.
+    try {
+      process.stderr.write(`context-mode: install OK, heal aborted (${(err && err.message) || err})\n`);
+    } catch { /* truly best effort */ }
+  }
+}
+
 // ── 0. Self-heal Layer 3: Backward symlink for stale registry (anthropics/claude-code#46915) ──
 // When this install completes, installed_plugins.json may still point to an old
 // non-existent path. Create a symlink from that old path → our new directory.