gm-kilo 2.0.883 → 2.0.885

package/bin/bootstrap.js

@@ -9,11 +9,16 @@ const crypto = require('crypto');
 const { URL } = require('url');
 
 const RELEASE_REPO = 'AnEntrypoint/plugkit-bin';
-const ATTEMPT_TIMEOUT_MS = 60 * 1000;
-const STALL_TIMEOUT_MS = 20 * 1000;
+const ATTEMPT_TIMEOUT_MS = 5 * 60 * 1000;
+const STALL_TIMEOUT_MS = 60 * 1000;
 const MAX_ATTEMPTS = 5;
 const BACKOFF_MS = [2000, 5000, 15000, 30000];
-const LOCK_STALE_MS = 5 * 60 * 1000;
+// Worst case: a slow link downloading 140MB at 1MB/s = ~140s. Allow 30 minutes
+// before another bootstrap process treats this lock as abandoned. Below this,
+// concurrent bootstrap calls would wipe an in-progress download mid-stream
+// (see the v0.1.294 incident where a race between two wrappers blew away the
+// .partial during a 10-minute fetch).
+const LOCK_STALE_MS = 30 * 60 * 1000;
 
 function log(msg) {
   try { process.stderr.write(`[plugkit-bootstrap] ${msg}\n`); } catch (_) {}
@@ -170,6 +175,10 @@ function fetchToFile(url, destPath, expectedTotal) {
         return reject(new Error(`HTTP ${res.statusCode} for ${url}`));
       }
       const append = res.statusCode === 206 && existing > 0;
+      // Ensure parent dir exists — a concurrent prune may have removed it
+      // between lock-acquire and now. Recreating is cheap and avoids a
+      // confusing ENOENT later.
+      try { ensureDir(path.dirname(destPath)); } catch (_) {}
       const out = fs.createWriteStream(destPath, { flags: append ? 'a' : 'w' });
       let bytes = append ? existing : 0;
       let lastStderr = Date.now();
@@ -402,7 +411,65 @@ function resolveCachedBinary(opts) {
   return null;
 }
 
-module.exports = { bootstrap, resolveCachedBinary, resolveCachedRtk, platformKey, binaryName, rtkBinaryName, cacheRoot, obsEvent };
+// ---------------------------------------------------------------------------
+// Daemon kill on version change.
+//
+// The plugin tarball pins `plugkit.version`. When that pin advances and we
+// install a newer cached binary, any long-running daemon (the runner) holds
+// stale code and serves stale RPCs until killed. We track which version the
+// daemon was last started under via `.daemon-version`; on every wrapper
+// invocation, if the wrapper-pinned version differs, we kill the daemon so
+// the next exec spawns it fresh under the new binary.
+// ---------------------------------------------------------------------------
+
+function daemonVersionSentinel() {
+  const root = (() => {
+    try { const r = cacheRoot(); ensureDir(r); return r; }
+    catch (_) { const r = fallbackCacheRoot(); ensureDir(r); return r; }
+  })();
+  return path.join(root, '.daemon-version');
+}
+
+function readDaemonVersion() {
+  try { return fs.readFileSync(daemonVersionSentinel(), 'utf8').trim(); }
+  catch (_) { return null; }
+}
+
+function writeDaemonVersion(v) {
+  try { fs.writeFileSync(daemonVersionSentinel(), String(v)); } catch (_) {}
+}
+
+function killRunningDaemons(reason) {
+  const tmp = os.tmpdir();
+  let killed = 0;
+  for (const pidFile of ['glootie-runner.pid', 'plugkit-runner.pid']) {
+    const pidPath = path.join(tmp, pidFile);
+    if (!fs.existsSync(pidPath)) continue;
+    try {
+      const pid = parseInt(fs.readFileSync(pidPath, 'utf8').trim(), 10);
+      if (Number.isFinite(pid) && pid !== process.pid && pidAlive(pid)) {
+        try { process.kill(pid, 'SIGTERM'); killed++; }
+        catch (_) { try { process.kill(pid); killed++; } catch (_) {} }
+        obsEvent('bootstrap', 'daemon.killed', { pid, pidFile, reason });
+      }
+      try { fs.unlinkSync(pidPath); } catch (_) {}
+    } catch (_) {}
+  }
+  return killed;
+}
+
+// Compare wrapper-pinned version against last-recorded daemon version. If
+// they differ, kill the daemon so it respawns under the new binary.
+function killStaleDaemonIfVersionChanged(wrapperDir) {
+  let currentVersion;
+  try { currentVersion = readVersionFile(wrapperDir); } catch (_) { return; }
+  const recorded = readDaemonVersion();
+  if (recorded === currentVersion) return;
+  if (recorded) killRunningDaemons(`version_change:${recorded}->${currentVersion}`);
+  writeDaemonVersion(currentVersion);
+}
+
+module.exports = { bootstrap, resolveCachedBinary, resolveCachedRtk, platformKey, binaryName, rtkBinaryName, cacheRoot, obsEvent, killRunningDaemons, killStaleDaemonIfVersionChanged };
 
 if (require.main === module) {
   bootstrap({ silent: false })

package/bin/plugkit.js

@@ -3,7 +3,7 @@
 const { spawn, spawnSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
-const { bootstrap, resolveCachedBinary, resolveCachedRtk, obsEvent } = require('./bootstrap');
+const { bootstrap, resolveCachedBinary, resolveCachedRtk, obsEvent, killStaleDaemonIfVersionChanged } = require('./bootstrap');
 
 const dir = __dirname;
 
@@ -26,21 +26,31 @@ async function main() {
   const isHook = args[0] === 'hook';
   const startedAt = Date.now();
   obsEvent('plugkit_wrapper', 'invoke', { argv: args.slice(0, 4), is_hook: isHook });
+  // If the plugin tarball updated `plugkit.version` since the runner daemon
+  // was last started, kill the daemon so the next `runner start` picks up
+  // the freshly-installed binary instead of serving stale RPCs.
+  try { killStaleDaemonIfVersionChanged(dir); } catch (_) {}
   let bin;
   try {
-    if (isHook) {
+    const hookSubcmd = isHook ? (args[1] || '') : '';
+    // session-start ALWAYS bootstraps: this is the once-per-session moment
+    // where we guarantee the cached binary matches the wrapper-pinned version.
+    // If the bootstrap fails (offline) we fall through to whatever the cache
+    // currently has — the hook itself isn't blocking, just refreshing.
+    if (isHook && hookSubcmd === 'session-start') {
+      obsEvent('plugkit_wrapper', 'hook_bootstrap_session_start', { argv: args.slice(0, 4) });
+      try {
+        bin = await bootstrap({ wrapperDir: dir, silent: true });
+      } catch (e) {
+        process.stderr.write(`[plugkit] session-start bootstrap failed: ${e.message}\n`);
+        bin = resolveCachedBinary({ wrapperDir: dir }) || legacyFallback();
+      }
+      // session-start hook itself runs in the freshly-bootstrapped binary
+      // below — fall through to the spawn path so the actual handler runs.
+      if (!bin) process.exit(0);
+    } else if (isHook) {
       bin = resolveCachedBinary({ wrapperDir: dir }) || legacyFallback();
       if (!bin) {
-        const hookSubcmd = args[1] || '';
-        if (hookSubcmd === 'session-start') {
-          obsEvent('plugkit_wrapper', 'hook_bootstrap_session_start', { argv: args.slice(0, 4) });
-          try {
-            await bootstrap({ wrapperDir: dir });
-          } catch (e) {
-            process.stderr.write(`[plugkit] session-start bootstrap failed: ${e.message}\n`);
-          }
-          process.exit(0);
-        }
         process.stderr.write(`[plugkit] hook ${hookSubcmd} skipped: binary not yet installed. Bootstrap will run on session-start.\n`);
         obsEvent('plugkit_wrapper', 'hook_skip_uncached', { argv: args.slice(0, 4), dur_ms: Date.now() - startedAt });
         process.exit(0);
@@ -76,16 +86,18 @@ async function main() {
   }
 }
 
+// legacyFallback only returns a binary that lives next to the wrapper. We
+// never reach across to ~/.claude/gm-tools/plugkit.exe or other ambient
+// install dirs — those have proven to mask bootstrap failures by serving a
+// stale version whose hooks silently mismatch the active wrapper code (see
+// the v0.1.292-vs-v0.1.294 incident).
 function legacyFallback() {
   const os = require('os');
   const p = os.platform();
   const a = os.arch();
   let candidates = [];
   if (p === 'win32') {
-    candidates = [
-      path.join(dir, a === 'arm64' ? 'plugkit-win32-arm64.exe' : 'plugkit-win32-x64.exe'),
-      path.join(dir, 'plugkit.exe'),
-    ];
+    candidates = [path.join(dir, a === 'arm64' ? 'plugkit-win32-arm64.exe' : 'plugkit-win32-x64.exe')];
   } else if (p === 'darwin') {
     candidates = [path.join(dir, a === 'arm64' ? 'plugkit-darwin-arm64' : 'plugkit-darwin-x64')];
   } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-kilo",
-  "version": "2.0.883",
+  "version": "2.0.885",
   "description": "State machine agent with hooks, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",