@kurrent/kcap 0.11.11 → 0.11.12

package/bin/kcap.js

@@ -5,28 +5,11 @@
 const { execFileSync, spawnSync } = require("child_process");
 const path = require("path");
 const fs = require("fs");
-
-function isMusl() {
-  if (process.platform !== "linux") return false;
-  try {
-    return fs.readFileSync("/usr/bin/ldd", "utf8").includes("musl");
-  } catch {
-    try {
-      return fs.readdirSync("/lib").some((f) => f.startsWith("ld-musl-"));
-    } catch {
-      return false;
-    }
-  }
-}
-
-const PLATFORM_PACKAGES = {
-  "darwin-arm64":      "@kurrent/kcap-darwin-arm64",
-  "linux-x64":         "@kurrent/kcap-linux-x64",
-  "linux-arm64":       "@kurrent/kcap-linux-arm64",
-  "linux-musl-x64":    "@kurrent/kcap-linux-musl-x64",
-  "linux-musl-arm64":  "@kurrent/kcap-linux-musl-arm64",
-  "win32-x64":         "@kurrent/kcap-win-x64",
-};
+// Platform detection + native-binary resolution live in resolve.js — a
+// side-effect-free module shared with refresh.js (which must never require
+// THIS file: during `kcap update`, runUpdate executes before the final
+// module.exports below, so it would see partial exports).
+const { PLATFORM_PACKAGES, platformKey } = require("./resolve");
 
 // Resolves the npm dist-tag to install for `kcap update`, based on the
 // resolved channel reported by `kcap update --check`'s `install_tag` field.
@@ -203,12 +186,11 @@ function printLockedBinaryHelp(globalRoot, onlyIfFound = false) {
 // runs the update flow), so it's guarded to only run when this file is
 // executed directly — not when `require()`d (e.g. by the test).
 if (require.main === module) {
-  const musl = process.platform === "linux" && isMusl() ? "-musl" : "";
-  const platformKey = `${process.platform}${musl}-${process.arch}`;
-  const packageName = PLATFORM_PACKAGES[platformKey];
+  const key = platformKey();
+  const packageName = PLATFORM_PACKAGES[key];
 
   if (!packageName) {
-    console.error(`Unsupported platform: ${platformKey}`);
+    console.error(`Unsupported platform: ${key}`);
     console.error(`Supported: ${Object.keys(PLATFORM_PACKAGES).join(", ")}`);
     process.exit(1);
   }

package/bin/refresh.js

@@ -7,8 +7,14 @@
 //   when the package manager allows install scripts to run.
 // - kcap.js `update` — runs after a user-initiated `kcap update`, which works
 //   even when the package manager blocks postinstall scripts.
+//
+// This file must never require kcap.js: during `kcap update`, runUpdate executes
+// before kcap.js's final module.exports assignment, so it would observe partial
+// exports. Shared platform/binary resolution lives in resolve.js instead.
 
 const { spawnSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
 
 // One entry per agent. Order is independent — each refresh is gated by its own
 // marker via `--if-installed`, which no-ops unless the user has previously
@@ -28,6 +34,11 @@ const REFRESHES = [
 // from one never prevents the others and never throws to the caller — a failed
 // refresh must never break `npm install` or report `kcap update` as failed.
 function runRefreshes(launcherPath) {
+  // Point the shipped Claude plugin's MCP entries at the native binary. Runs
+  // here because runRefreshes fires at exactly the two moments the plugin dir
+  // has just been (re)written by npm: postinstall and `kcap update`.
+  patchPluginMcpConfig(launcherPath);
+
   for (const argv of REFRESHES) {
     try {
       spawnSync(process.execPath, [launcherPath, ...argv], {
@@ -44,4 +55,96 @@ function runRefreshes(launcherPath) {
   }
 }
 
-module.exports = { runRefreshes };
+// ── Claude plugin .mcp.json patch ───────────────────────────────────────────
+//
+// The plugin ships `"command": "kcap"`, which resolves to the node wrapper —
+// one resident Node runtime per MCP server per open Claude session (~25 MB
+// idle each). Rewriting the command to the resolved native binary makes Claude
+// spawn the binary directly. Best-effort: on any failure the shipped value
+// stays in place, which still works via the wrapper.
+
+// The servers shipped in the plugin's .mcp.json, keyed by canonical
+// `["mcp", <suffix>]` args. Only these exact name/args pairs are patched —
+// anything else in the file is preserved verbatim.
+const PLUGIN_MCP_SERVERS = {
+  "kcap-review":    "review",
+  "kcap-sessions":  "sessions",
+  "kcap-flows":     "flows",
+  "kcap-memory":    "memory",
+  "kcap-workitems": "workitems",
+  "kcap-analytics": "analytics",
+};
+
+// A command this patcher may rewrite: the shipped literal "kcap", or an
+// absolute path whose basename is the kcap binary (a previous patch that has
+// gone stale after an npm re-layout). Handles both path flavors so a stale
+// Windows path is still recognized. Anything else is a customization → keep.
+function isPatchableKcapCommand(command) {
+  if (command === "kcap") return true;
+  if (typeof command !== "string") return false;
+  if (!path.posix.isAbsolute(command) && !path.win32.isAbsolute(command)) return false;
+  const base = command.split(/[\\/]/).pop().toLowerCase();
+  return base === "kcap" || base === "kcap.exe";
+}
+
+// Pure: rewrites in place the canonical plugin entries of `cfg` whose command
+// is patchable, returning whether anything changed. Throws on a shape that
+// isn't the plugin config (caller turns that into the single warning).
+function patchPluginMcpServers(cfg, binaryPath) {
+  if (!cfg || typeof cfg !== "object" || Array.isArray(cfg)) {
+    throw new Error("config is not an object");
+  }
+  const servers = cfg.mcpServers;
+  if (!servers || typeof servers !== "object" || Array.isArray(servers)) {
+    throw new Error("mcpServers is not an object");
+  }
+
+  let changed = false;
+  for (const [name, suffix] of Object.entries(PLUGIN_MCP_SERVERS)) {
+    const entry = servers[name];
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+    if (!Array.isArray(entry.args) || entry.args.length !== 2 ||
+        entry.args[0] !== "mcp" || entry.args[1] !== suffix) continue; // customized args → keep
+    if (!isPatchableKcapCommand(entry.command)) continue;              // customized command → keep
+    if (entry.command === binaryPath) continue;                        // already current
+    entry.command = binaryPath;
+    changed = true;
+  }
+  return changed;
+}
+
+// Rewrites the plugin's shipped .mcp.json (a sibling `kcap/` dir of the
+// launcher's `bin/`) so Claude spawns the native binary directly. Validates
+// before writing, writes a sibling temp file, then renames atomically — the
+// original survives any pre-rename failure. Never throws; on failure it emits
+// ONE concise warning and leaves the shipped `"command": "kcap"` in place.
+// `binaryPath` is a test seam; real callers let it resolve.
+function patchPluginMcpConfig(launcherPath, binaryPath) {
+  let mcpJsonPath;
+  try {
+    binaryPath = binaryPath || require("./resolve").resolveNativeBinary();
+    if (!binaryPath) return; // unsupported platform / package missing — wrapper keeps working
+
+    mcpJsonPath = path.join(path.dirname(launcherPath), "..", "kcap", ".mcp.json");
+    if (!fs.existsSync(mcpJsonPath)) return; // dev checkout / plugin not shipped
+
+    const cfg = JSON.parse(fs.readFileSync(mcpJsonPath, "utf8"));
+    if (!patchPluginMcpServers(cfg, binaryPath)) return; // already patched / nothing canonical
+
+    const tmp = `${mcpJsonPath}.tmp-${process.pid}-${Date.now()}`;
+    try {
+      fs.writeFileSync(tmp, JSON.stringify(cfg, null, 2) + "\n");
+      fs.renameSync(tmp, mcpJsonPath);
+    } catch (e) {
+      try { fs.unlinkSync(tmp); } catch {}
+      throw e;
+    }
+  } catch (e) {
+    console.warn(
+      `kcap: could not point the Claude plugin MCP entries at the native binary` +
+      ` (${e && e.message ? e.message : e}); they will keep launching via the node wrapper.`,
+    );
+  }
+}
+
+module.exports = { runRefreshes, patchPluginMcpConfig, patchPluginMcpServers, isPatchableKcapCommand };

package/bin/resolve.js

@@ -0,0 +1,61 @@
+// Side-effect-free platform/native-binary resolution, shared by kcap.js (the
+// launcher) and refresh.js (postinstall / `kcap update` refresh).
+//
+// This lives in its OWN module — refresh.js must never require kcap.js: during
+// `kcap update`, runUpdate executes BEFORE kcap.js's final module.exports
+// assignment, so a refresh.js → kcap.js require would observe partial exports
+// exactly on that path. Requiring this module has no side effects.
+
+const path = require("path");
+const fs = require("fs");
+
+function isMusl() {
+  if (process.platform !== "linux") return false;
+  try {
+    return fs.readFileSync("/usr/bin/ldd", "utf8").includes("musl");
+  } catch {
+    try {
+      return fs.readdirSync("/lib").some((f) => f.startsWith("ld-musl-"));
+    } catch {
+      return false;
+    }
+  }
+}
+
+const PLATFORM_PACKAGES = {
+  "darwin-arm64":      "@kurrent/kcap-darwin-arm64",
+  "linux-x64":         "@kurrent/kcap-linux-x64",
+  "linux-arm64":       "@kurrent/kcap-linux-arm64",
+  "linux-musl-x64":    "@kurrent/kcap-linux-musl-x64",
+  "linux-musl-arm64":  "@kurrent/kcap-linux-musl-arm64",
+  "win32-x64":         "@kurrent/kcap-win-x64",
+};
+
+function platformKey() {
+  const musl = process.platform === "linux" && isMusl() ? "-musl" : "";
+  return `${process.platform}${musl}-${process.arch}`;
+}
+
+// Absolute path to the native kcap binary for the current platform, or null
+// when the platform is unsupported, the platform package isn't installed, or
+// the binary file is missing. `basedir` (optional) overrides where module
+// resolution starts — tests point it at a fake package layout; callers inside
+// the real install tree omit it (resolution then starts from this file).
+function resolveNativeBinary(basedir) {
+  const packageName = PLATFORM_PACKAGES[platformKey()];
+  if (!packageName) return null;
+
+  let binaryDir;
+  try {
+    const opts = basedir ? { paths: [basedir] } : undefined;
+    binaryDir = path.dirname(require.resolve(`${packageName}/package.json`, opts));
+  } catch {
+    return null;
+  }
+
+  const ext = process.platform === "win32" ? ".exe" : "";
+  const binaryPath = path.join(binaryDir, "bin", `kcap${ext}`);
+  return fs.existsSync(binaryPath) ? binaryPath : null;
+}
+
+module.exports = { PLATFORM_PACKAGES, isMusl, platformKey, resolveNativeBinary };

package/kcap/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "kcap",
-  "version": "0.11.11",
+  "version": "0.11.12",
   "description": "Records and visualizes Claude Code sessions via kcap CLI hooks"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kurrent/kcap",
-  "version": "0.11.11",
+  "version": "0.11.12",
   "description": "CLI companion for Kurrent Capacitor — records and visualizes Claude Code sessions",
   "license": "SEE LICENSE IN LICENSE.md",
   "repository": {
@@ -14,17 +14,17 @@
     "postinstall": "node bin/postinstall.js"
   },
   "optionalDependencies": {
-    "@kurrent/kcap-darwin-arm64": "0.11.11",
-    "@kurrent/kcap-linux-arm64": "0.11.11",
-    "@kurrent/kcap-linux-musl-arm64": "0.11.11",
-    "@kurrent/kcap-linux-musl-x64": "0.11.11",
-    "@kurrent/kcap-linux-x64": "0.11.11",
-    "@kurrent/kcap-win-x64": "0.11.11"
+    "@kurrent/kcap-darwin-arm64": "0.11.12",
+    "@kurrent/kcap-linux-arm64": "0.11.12",
+    "@kurrent/kcap-linux-musl-arm64": "0.11.12",
+    "@kurrent/kcap-linux-musl-x64": "0.11.12",
+    "@kurrent/kcap-linux-x64": "0.11.12",
+    "@kurrent/kcap-win-x64": "0.11.12"
   },
   "files": [
     "bin/",
     "kcap/"
   ],
-  "kcapReleaseCommit": "fe912ddfe994812f7679dc518dbaddf3967da374",
-  "kcapReleaseTag": "v0.11.11"
+  "kcapReleaseCommit": "b02e5f0a0e20700edd6787f61704419b78556f30",
+  "kcapReleaseTag": "v0.11.12"
 }