gm-kilo 2.0.882 → 2.0.884

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/bin/plugkit.sha256

@@ -1,6 +1,6 @@
-d4a4df030be84d1863a5230b2657e69765c16f69faf65d62bc56dfda68686faf  plugkit-win32-x64.exe
-2c1c978d7fd89898bd8f35ebbcf6d36cee533751113d9d45ad72fce95e9921ed  plugkit-win32-arm64.exe
-6a11f3f4fc819dde5993eb4621f056c18ad07ee7b08cf77f6f59a07fd5c1a7c7  plugkit-darwin-x64
-fb33de6f0823825989eae54e683904f618daa14a0c3c2ee91acd9b2bd297d699  plugkit-darwin-arm64
-eed7f62527acd4a8c9f02daf20150c4e5c62a9922abf377cec3b78bc5e845641  plugkit-linux-x64
-fbe7d87c3c6569b4b461d89998cafce836c7107dcb2f8cdd38740920c8e5bd13  plugkit-linux-arm64
+f0a217d24261d6fee31b3f09347da19e2eda76f9b558adf607240cefcc131d01  plugkit-win32-x64.exe
+24bfc958f0b0682c56f5531a8e8c42f047f228bf9592405ff6802a0371620379  plugkit-win32-arm64.exe
+004d0ea64c0d20e0fc15005be2934995a9f21b5faf2d6f3e46815f1f56a3ea2f  plugkit-darwin-x64
+8281cc89e37d683cb798de88ede8214946b4d87d08209a06f5af3d00aff3ab37  plugkit-darwin-arm64
+60c0f7d606bdb7fc38c8d62919204eacc736782223d5775a3329c3a788e50a67  plugkit-linux-x64
+07bfac610e89a4923aa43479ce14e2d060bf95762d2144a32787ee3698aa902d  plugkit-linux-arm64

package/bin/rtk.sha256

@@ -1,5 +1,5 @@
-fce18ddef3a71ecfd3870f3f96d92c385dc7734ba7ea20f76cb2c4ba8537f3c8  rtk-win32-x64.exe
-cd367f741b8bb9806420eda69dddd7b056769a32f1f2fb738e4b0826cf68746c  rtk-win32-arm64.exe
+45001a4384331c752b20937d2918867717655e1f836a7da626cfd813abd6b828  rtk-win32-x64.exe
+043a0438b9b28e50db56187d0e2e8e1833be674f45db24398cf3892f48f26004  rtk-win32-arm64.exe
 e89fdf402c28796b510587a8b0fe046438b5b24d49533d1a2339a48aecae35e9  rtk-darwin-x64
 2b203fd380f5782b5489eb016e34e3dbf848272a7fadf36b39bce6cfd9a3005c  rtk-darwin-arm64
 0da9950b859c7a2693aaf6c169f05f9b8965508ba1f23f1547e63d5fa988749e  rtk-linux-x64

package/package.json

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