gm-qwen 2.0.981 → 2.0.982

package/bin/bootstrap.js

@@ -99,6 +99,42 @@ function fallbackCacheRoot() {
   return path.join(os.tmpdir(), 'plugkit-cache', 'bin');
 }
 
+function gmToolsDir() {
+  const home = process.env.USERPROFILE || process.env.HOME || os.homedir();
+  return path.join(home, '.claude', 'gm-tools');
+}
+
+// Copy the freshly-resolved plugkit binary + its version+sha manifests to
+// ~/.claude/gm-tools so hooks.json can invoke plugkit directly without going
+// through node. Self-update inside the Rust binary keeps gm-tools fresh from
+// here on. Skipped silently on any error — the next session-start hook will
+// retry via ensure_tools_current.
+function copyToGmTools(finalPath, wrapperDir, version) {
+  try {
+    const dst = gmToolsDir();
+    fs.mkdirSync(dst, { recursive: true });
+    const exeName = process.platform === 'win32' ? 'plugkit.exe' : 'plugkit';
+    const target = path.join(dst, exeName);
+    const targetTmp = target + '.new';
+    fs.copyFileSync(finalPath, targetTmp);
+    try { fs.renameSync(targetTmp, target); }
+    catch (err) {
+      if (err.code === 'EEXIST' || err.code === 'EPERM' || err.code === 'EBUSY') {
+        // target may be locked by a running plugkit; the .new file persists
+        // and the in-Rust self-update will eventually swap it. Leave it.
+      } else { throw err; }
+    }
+    if (process.platform !== 'win32') {
+      try { fs.chmodSync(target, 0o755); } catch (_) {}
+    }
+    fs.writeFileSync(path.join(dst, 'plugkit.version'), version);
+    try {
+      const srcSha = path.join(wrapperDir, 'plugkit.sha256');
+      if (fs.existsSync(srcSha)) fs.copyFileSync(srcSha, path.join(dst, 'plugkit.sha256'));
+    } catch (_) {}
+  } catch (_) {}
+}
+
 function ensureDir(dir) {
   fs.mkdirSync(dir, { recursive: true });
 }
@@ -349,6 +385,7 @@ async function bootstrap(opts) {
       const actualSha = sha256OfFileSync(finalPath);
       if (actualSha === expectedSha) {
         if (!opts.silent) log(`decision: hit reason: sha-match v${version} (${finalPath})`);
+        copyToGmTools(finalPath, wrapperDir, version);
         return finalPath;
       }
       log(`decision: fetch reason: cache-hit-sha-mismatch (dir=v${version} expected ${expectedSha.slice(0,12)}… got ${(actualSha||'').slice(0,12)}…)`);
@@ -362,6 +399,7 @@ async function bootstrap(opts) {
       try { fs.unlinkSync(okSentinel); } catch (_) {}
     } else {
       if (!opts.silent) log(`decision: hit reason: sentinel+no-sha-manifest (${finalPath})`);
+      copyToGmTools(finalPath, wrapperDir, version);
       return finalPath;
     }
   }
@@ -369,6 +407,7 @@ async function bootstrap(opts) {
   if (healIfShaMatches(finalPath, expectedSha, okSentinel, partialPath, 'plugkit')) {
     if (!opts.silent) log(`decision: heal reason: sha-match (${finalPath})`);
     spawnDetachedRtkFetch(wrapperDir);
+    copyToGmTools(finalPath, wrapperDir, version);
     return finalPath;
   }
 
@@ -377,11 +416,13 @@ async function bootstrap(opts) {
   try {
     if (fs.existsSync(finalPath) && fs.existsSync(okSentinel)) {
       log(`decision: hit reason: lock-race-resolved (${finalPath})`);
+      copyToGmTools(finalPath, wrapperDir, version);
       return finalPath;
     }
     if (healIfShaMatches(finalPath, expectedSha, okSentinel, partialPath, 'plugkit')) {
       log(`decision: heal reason: sha-match-under-lock (${finalPath})`);
       spawnDetachedRtkFetch(wrapperDir);
+      copyToGmTools(finalPath, wrapperDir, version);
       return finalPath;
     }
 
@@ -442,6 +483,7 @@ async function bootstrap(opts) {
     proactiveKillForNewInstall(version, finalPath);
     pruneOldVersions(root, version, readRtkVersion(wrapperDir));
     spawnDetachedRtkFetch(wrapperDir);
+    copyToGmTools(finalPath, wrapperDir, version);
     return finalPath;
   } finally {
     releaseLock(lockPath);

package/bin/plugkit.js

@@ -1,159 +1,50 @@
 #!/usr/bin/env node
 'use strict';
-const { spawn, spawnSync } = require('child_process');
+// Minimal exec wrapper. ZERO bootstrap, ZERO version-probe, ZERO async work.
+// Just shell out to ~/.claude/gm-tools/plugkit{.exe} with inherited stdio.
+// The Rust binary handles its own self-update at startup (detached); first-time
+// bootstrap is done by gm-cc postinstall.js. Hot path is one spawnSync, ~150ms
+// of node startup overhead.
+
+const { spawnSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
-const { bootstrap, resolveCachedBinary, resolveCachedRtk, obsEvent, killStaleDaemonIfVersionChanged } = require('./bootstrap');
-
-const dir = __dirname;
-
-function readPinnedVersion() {
-  try { return fs.readFileSync(path.join(dir, 'plugkit.version'), 'utf8').trim(); } catch (_) { return null; }
-}
+const os = require('os');
 
-function probeCachedVersion(binPath) {
-  try {
-    const r = spawnSync(binPath, ['--version'], { timeout: 3000, encoding: 'utf8', windowsHide: true });
-    if (r.error) return null;
-    const text = `${r.stdout || ''} ${r.stderr || ''}`.trim();
-    const m = text.match(/(\d+\.\d+\.\d+)/);
-    return m ? m[1] : null;
-  } catch (_) { return null; }
+function toolsBin() {
+  const home = process.env.USERPROFILE || process.env.HOME || os.homedir();
+  const exe = process.platform === 'win32' ? 'plugkit.exe' : 'plugkit';
+  return path.join(home, '.claude', 'gm-tools', exe);
 }
 
-async function resolveBinaryWithPinCheck() {
-  const cached = resolveCachedBinary({ wrapperDir: dir });
-  if (!cached) return null;
-  const pin = readPinnedVersion();
-  if (!pin) return cached;
-  const got = probeCachedVersion(cached);
-  if (got && got === pin) return cached;
-  try { return await bootstrap({ wrapperDir: dir, silent: true }); } catch (_) { return cached; }
-}
-
-function envWithRtkOnPath() {
-  const rtkPath = resolveCachedRtk({ wrapperDir: dir });
-  if (!rtkPath) return process.env;
-  const rtkDir = path.dirname(rtkPath);
-  const sep = process.platform === 'win32' ? ';' : ':';
-  return { ...process.env, PATH: `${rtkDir}${sep}${process.env.PATH || ''}` };
-}
-
-async function resolveBinary() {
-  const cached = resolveCachedBinary({ wrapperDir: dir });
-  if (cached) return cached;
-  return await bootstrap({ wrapperDir: dir });
+function legacyBesideWrapper() {
+  const dir = __dirname;
+  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')];
+  else if (p === 'darwin') candidates = [path.join(dir, a === 'arm64' ? 'plugkit-darwin-arm64' : 'plugkit-darwin-x64')];
+  else candidates = [path.join(dir, (a === 'arm64' || a === 'aarch64') ? 'plugkit-linux-arm64' : 'plugkit-linux-x64')];
+  for (const c of candidates) if (fs.existsSync(c)) return c;
+  return null;
 }
 
-async function main() {
+function main() {
   const args = process.argv.slice(2);
-  // Detached bootstrap entry: just run bootstrap() and exit. Used by session-start
-  // to avoid blocking CC startup on a slow GitHub download.
-  if (args[0] === '__rtk_only__') {
-    try { await bootstrap({ wrapperDir: dir, silent: false }); }
-    catch (e) { try { process.stderr.write(`[plugkit-bootstrap-detached] ${e.message}\n`); } catch (_) {} }
-    process.exit(0);
-  }
   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 {
-    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) });
-      // Bootstrap can stall 60s+ on a slow GitHub mirror — never block CC startup
-      // on it. Detach into a background child; this hook returns immediately
-      // with whatever cached binary exists. Subsequent hooks pick up the new
-      // binary once the detached bootstrap completes.
-      bin = resolveCachedBinary({ wrapperDir: dir }) || legacyFallback();
-      try {
-        const child = spawn(process.execPath, [__filename, '__rtk_only__'], {
-          detached: true,
-          stdio: 'ignore',
-          windowsHide: true,
-          env: { ...process.env, PLUGKIT_BOOTSTRAP_DETACHED: '1' },
-        });
-        child.unref();
-        obsEvent('plugkit_wrapper', 'session_start_bootstrap_detached', { pid: child.pid });
-      } catch (e) {
-        process.stderr.write(`[plugkit] detached bootstrap spawn failed: ${e.message}\n`);
-      }
-      // If no cached binary yet (fresh install with bootstrap still downloading),
-      // skip running the session-start handler this turn — it will fire next
-      // session-start once binary is in place.
-      if (!bin) {
-        process.stderr.write(`[plugkit] session-start skipped: binary not yet installed (bootstrap running in background).\n`);
-        process.exit(0);
-      }
-    } else if (isHook) {
-      bin = (await resolveBinaryWithPinCheck()) || legacyFallback();
-      if (!bin) {
-        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);
-      }
-    } else {
-      bin = await resolveBinary();
+  let bin = toolsBin();
+  if (!fs.existsSync(bin)) {
+    bin = legacyBesideWrapper();
+    if (!bin) {
+      // Binary not yet installed. If this is a hook, exit cleanly so CC doesn't
+      // see an error; postinstall will populate gm-tools on /plugin install.
+      if (isHook) process.exit(0);
+      process.stderr.write('[plugkit] binary not found at ~/.claude/gm-tools/plugkit — run postinstall\n');
+      process.exit(1);
     }
-  } catch (err) {
-    process.stderr.write(`[plugkit] bootstrap failed: ${err.message}\n`);
-    obsEvent('plugkit_wrapper', 'bootstrap_failed', { err: err.message, dur_ms: Date.now() - startedAt, argv: args.slice(0, 4), is_hook: isHook });
-    const legacy = legacyFallback();
-    if (legacy) { bin = legacy; }
-    else if (isHook) { process.exit(0); }
-    else process.exit(1);
-  }
-
-  const env = envWithRtkOnPath();
-
-  if (isHook && !process.stdin.isTTY) {
-    const chunks = [];
-    process.stdin.on('data', c => chunks.push(c));
-    process.stdin.on('end', () => {
-      const child = spawn(bin, args, { stdio: ['pipe', 'inherit', 'inherit'], windowsHide: true, env });
-      child.stdin.end(Buffer.concat(chunks));
-      child.on('close', code => process.exit(code ?? 1));
-      child.on('error', () => process.exit(1));
-    });
-    process.stdin.on('error', () => process.exit(1));
-  } else {
-    const result = spawnSync(bin, args, { stdio: 'inherit', windowsHide: true, env });
-    obsEvent('plugkit_wrapper', 'exit', { dur_ms: Date.now() - startedAt, code: result.status ?? -1 });
-    process.exit(result.status ?? 1);
-  }
-}
-
-// 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')];
-  } else if (p === 'darwin') {
-    candidates = [path.join(dir, a === 'arm64' ? 'plugkit-darwin-arm64' : 'plugkit-darwin-x64')];
-  } else {
-    candidates = [path.join(dir, (a === 'arm64' || a === 'aarch64') ? 'plugkit-linux-arm64' : 'plugkit-linux-x64')];
   }
-  for (const c of candidates) if (fs.existsSync(c)) return c;
-  return null;
+  const r = spawnSync(bin, args, { stdio: 'inherit', windowsHide: true });
+  process.exit(r.status ?? 1);
 }
 
-main().catch(err => {
-  process.stderr.write(`[plugkit] fatal: ${err.message}\n`);
-  process.exit(1);
-});
+main();

package/gm.json

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

package/package.json

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