gm-cc 2.0.695 → 2.0.699

package/.claude-plugin/marketplace.json

@@ -4,7 +4,7 @@
     "name": "AnEntrypoint"
   },
   "description": "State machine agent with hooks, skills, and automated git enforcement",
-  "version": "2.0.695",
+  "version": "2.0.699",
   "metadata": {
     "description": "State machine agent with hooks, skills, and automated git enforcement"
   },

package/bin/bootstrap.js

@@ -0,0 +1,295 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const https = require('https');
+const crypto = require('crypto');
+const { URL } = require('url');
+
+const RELEASE_REPO = 'AnEntrypoint/plugkit-bin';
+const ATTEMPT_TIMEOUT_MS = 30 * 60 * 1000;
+const MAX_ATTEMPTS = 3;
+const BACKOFF_MS = [5000, 30000, 120000];
+const LOCK_STALE_MS = 45 * 60 * 1000;
+
+function log(msg) {
+  try { process.stderr.write(`[plugkit-bootstrap] ${msg}\n`); } catch (_) {}
+}
+
+function platformKey() {
+  const p = os.platform();
+  const a = os.arch();
+  if (p === 'win32') return a === 'arm64' ? 'win32-arm64' : 'win32-x64';
+  if (p === 'darwin') return a === 'arm64' ? 'darwin-arm64' : 'darwin-x64';
+  return (a === 'arm64' || a === 'aarch64') ? 'linux-arm64' : 'linux-x64';
+}
+
+function binaryName() {
+  const key = platformKey();
+  return key.startsWith('win32') ? `plugkit-${key}.exe` : `plugkit-${key}`;
+}
+
+function cacheRoot() {
+  const home = os.homedir();
+  if (process.env.PLUGKIT_CACHE_DIR) return process.env.PLUGKIT_CACHE_DIR;
+  if (os.platform() === 'win32') {
+    const base = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
+    return path.join(base, 'plugkit', 'bin');
+  }
+  if (os.platform() === 'darwin') return path.join(home, 'Library', 'Caches', 'plugkit', 'bin');
+  const xdg = process.env.XDG_CACHE_HOME || path.join(home, '.cache');
+  return path.join(xdg, 'plugkit', 'bin');
+}
+
+function fallbackCacheRoot() {
+  return path.join(os.tmpdir(), 'plugkit-cache', 'bin');
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function readVersionFile(wrapperDir) {
+  const p = path.join(wrapperDir, 'plugkit.version');
+  if (!fs.existsSync(p)) throw new Error(`plugkit.version not found at ${p}`);
+  return fs.readFileSync(p, 'utf8').trim();
+}
+
+function readShaManifest(wrapperDir) {
+  const p = path.join(wrapperDir, 'plugkit.sha256');
+  if (!fs.existsSync(p)) return null;
+  const out = {};
+  for (const line of fs.readFileSync(p, 'utf8').split(/\r?\n/)) {
+    const m = line.match(/^([0-9a-f]{64})\s+(\S+)\s*$/i);
+    if (m) out[m[2]] = m[1].toLowerCase();
+  }
+  return out;
+}
+
+function pidAlive(pid) {
+  try { process.kill(pid, 0); return true; } catch (e) { return e.code === 'EPERM'; }
+}
+
+function acquireLock(lockPath) {
+  const start = Date.now();
+  for (;;) {
+    try {
+      const fd = fs.openSync(lockPath, 'wx');
+      fs.writeSync(fd, String(process.pid));
+      fs.closeSync(fd);
+      return true;
+    } catch (err) {
+      if (err.code !== 'EEXIST') throw err;
+      let stale = false;
+      try {
+        const st = fs.statSync(lockPath);
+        if (Date.now() - st.mtimeMs > LOCK_STALE_MS) stale = true;
+        const owner = parseInt(fs.readFileSync(lockPath, 'utf8').trim(), 10);
+        if (Number.isFinite(owner) && owner !== process.pid && !pidAlive(owner)) stale = true;
+      } catch (_) { stale = true; }
+      if (stale) {
+        try { fs.unlinkSync(lockPath); } catch (_) {}
+        continue;
+      }
+      if (Date.now() - start > ATTEMPT_TIMEOUT_MS) throw new Error(`lock wait timeout: ${lockPath}`);
+      const waitMs = 2000;
+      const deadline = Date.now() + waitMs;
+      while (Date.now() < deadline) {}
+    }
+  }
+}
+
+function releaseLock(lockPath) {
+  try { fs.unlinkSync(lockPath); } catch (_) {}
+}
+
+function sha256OfFile(filePath) {
+  return new Promise((resolve, reject) => {
+    const h = crypto.createHash('sha256');
+    const s = fs.createReadStream(filePath);
+    s.on('data', c => h.update(c));
+    s.on('end', () => resolve(h.digest('hex')));
+    s.on('error', reject);
+  });
+}
+
+function fetchToFile(url, destPath, expectedTotal) {
+  return new Promise((resolve, reject) => {
+    let existing = 0;
+    try { existing = fs.statSync(destPath).size; } catch (_) {}
+    const headers = { 'User-Agent': 'plugkit-bootstrap', 'Accept': '*/*' };
+    if (existing > 0) headers['Range'] = `bytes=${existing}-`;
+
+    const u = new URL(url);
+    const req = https.request({
+      method: 'GET',
+      hostname: u.hostname,
+      path: u.pathname + u.search,
+      headers,
+      timeout: ATTEMPT_TIMEOUT_MS,
+    }, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302 || res.statusCode === 307 || res.statusCode === 308) {
+        res.resume();
+        return resolve(fetchToFile(res.headers.location, destPath, expectedTotal));
+      }
+      if (res.statusCode === 416) {
+        res.resume();
+        try { fs.unlinkSync(destPath); } catch (_) {}
+        return reject(new Error('range-not-satisfiable: cleared partial, retry'));
+      }
+      if (!(res.statusCode === 200 || res.statusCode === 206)) {
+        res.resume();
+        return reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+      }
+      const append = res.statusCode === 206 && existing > 0;
+      const out = fs.createWriteStream(destPath, { flags: append ? 'a' : 'w' });
+      let bytes = append ? existing : 0;
+      let lastLog = Date.now();
+      res.on('data', c => {
+        bytes += c.length;
+        if (Date.now() - lastLog > 5000) {
+          const pct = expectedTotal ? ` ${Math.floor(bytes / expectedTotal * 100)}%` : '';
+          log(`downloading: ${(bytes / 1048576).toFixed(1)} MiB${pct}`);
+          lastLog = Date.now();
+        }
+      });
+      res.pipe(out);
+      out.on('finish', () => out.close(() => resolve(bytes)));
+      out.on('error', reject);
+      res.on('error', reject);
+    });
+    req.on('timeout', () => { req.destroy(new Error(`timeout after ${ATTEMPT_TIMEOUT_MS}ms`)); });
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+async function downloadWithRetry(url, destPath) {
+  let lastErr;
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    try {
+      log(`fetch attempt ${attempt}/${MAX_ATTEMPTS}: ${url}`);
+      await fetchToFile(url, destPath);
+      return;
+    } catch (err) {
+      lastErr = err;
+      log(`attempt ${attempt} failed: ${err.message}`);
+      if (attempt < MAX_ATTEMPTS) {
+        const wait = BACKOFF_MS[attempt - 1] || 120000;
+        log(`backing off ${wait}ms`);
+        await new Promise(r => setTimeout(r, wait));
+      }
+    }
+  }
+  throw lastErr;
+}
+
+function pruneOldVersions(root, keepVersion) {
+  try {
+    const entries = fs.readdirSync(root);
+    for (const e of entries) {
+      if (!e.startsWith('v')) continue;
+      if (e === `v${keepVersion}`) continue;
+      const dir = path.join(root, e);
+      const lock = path.join(dir, '.lock');
+      if (fs.existsSync(lock)) continue;
+      try {
+        fs.rmSync(dir, { recursive: true, force: true });
+        log(`pruned ${dir}`);
+      } catch (err) { log(`prune skip ${dir}: ${err.message}`); }
+    }
+  } catch (_) {}
+}
+
+async function bootstrap(opts) {
+  opts = opts || {};
+  const wrapperDir = opts.wrapperDir || __dirname;
+  const version = opts.version || readVersionFile(wrapperDir);
+  const shaManifest = readShaManifest(wrapperDir);
+  const binName = binaryName();
+  const expectedSha = shaManifest ? shaManifest[binName] : null;
+
+  let root = cacheRoot();
+  try { ensureDir(root); }
+  catch (_) { root = fallbackCacheRoot(); ensureDir(root); }
+
+  const verDir = path.join(root, `v${version}`);
+  ensureDir(verDir);
+
+  const finalPath = path.join(verDir, binName);
+  const okSentinel = path.join(verDir, '.ok');
+
+  if (fs.existsSync(finalPath) && fs.existsSync(okSentinel)) {
+    if (!opts.silent) log(`cache hit: ${finalPath}`);
+    pruneOldVersions(root, version);
+    return finalPath;
+  }
+
+  const lockPath = path.join(verDir, '.lock');
+  acquireLock(lockPath);
+  try {
+    if (fs.existsSync(finalPath) && fs.existsSync(okSentinel)) {
+      pruneOldVersions(root, version);
+      return finalPath;
+    }
+
+    const tmpPath = `${finalPath}.partial`;
+    const url = `https://github.com/${RELEASE_REPO}/releases/download/v${version}/${binName}`;
+    await downloadWithRetry(url, tmpPath);
+
+    if (expectedSha) {
+      const got = await sha256OfFile(tmpPath);
+      if (got !== expectedSha) {
+        try { fs.unlinkSync(tmpPath); } catch (_) {}
+        throw new Error(`sha256 mismatch for ${binName}: expected ${expectedSha}, got ${got}`);
+      }
+      log('sha256 verified');
+    } else {
+      log('no sha256 manifest — skipping verify');
+    }
+
+    try { fs.renameSync(tmpPath, finalPath); }
+    catch (err) {
+      if (err.code === 'EEXIST' || err.code === 'EPERM') {
+        try { fs.unlinkSync(finalPath); } catch (_) {}
+        fs.renameSync(tmpPath, finalPath);
+      } else throw err;
+    }
+
+    if (os.platform() !== 'win32') {
+      try { fs.chmodSync(finalPath, 0o755); } catch (_) {}
+    }
+
+    fs.writeFileSync(okSentinel, new Date().toISOString());
+    log(`installed ${finalPath}`);
+    pruneOldVersions(root, version);
+    return finalPath;
+  } finally {
+    releaseLock(lockPath);
+  }
+}
+
+function resolveCachedBinary(opts) {
+  opts = opts || {};
+  const wrapperDir = opts.wrapperDir || __dirname;
+  const version = opts.version || readVersionFile(wrapperDir);
+  const root = (() => {
+    try { const r = cacheRoot(); ensureDir(r); return r; }
+    catch (_) { const r = fallbackCacheRoot(); ensureDir(r); return r; }
+  })();
+  const verDir = path.join(root, `v${version}`);
+  const finalPath = path.join(verDir, binaryName());
+  const okSentinel = path.join(verDir, '.ok');
+  if (fs.existsSync(finalPath) && fs.existsSync(okSentinel)) return finalPath;
+  return null;
+}
+
+module.exports = { bootstrap, resolveCachedBinary, platformKey, binaryName, cacheRoot };
+
+if (require.main === module) {
+  bootstrap({ silent: false })
+    .then(p => { process.stdout.write(p + '\n'); process.exit(0); })
+    .catch(err => { log(`FATAL: ${err.message}`); process.exit(1); });
+}

package/bin/plugkit.js

@@ -2,41 +2,67 @@
 'use strict';
 const { spawn, spawnSync } = require('child_process');
 const path = require('path');
-const os = require('os');
 const fs = require('fs');
+const { bootstrap, resolveCachedBinary } = require('./bootstrap');
 
 const dir = __dirname;
-const platform = os.platform();
-const arch = os.arch();
 
-let bin;
-if (platform === 'win32') {
-  bin = path.join(dir, arch === 'arm64' ? 'plugkit-win32-arm64.exe' : 'plugkit-win32-x64.exe');
-  if (!fs.existsSync(bin)) bin = path.join(dir, 'plugkit.exe');
-} else if (platform === 'darwin') {
-  bin = path.join(dir, arch === 'arm64' ? 'plugkit-darwin-arm64' : 'plugkit-darwin-x64');
-} else {
-  bin = path.join(dir, arch === 'arm64' || arch === 'aarch64' ? 'plugkit-linux-arm64' : 'plugkit-linux-x64');
+async function resolveBinary() {
+  const cached = resolveCachedBinary({ wrapperDir: dir });
+  if (cached) return cached;
+  return await bootstrap({ wrapperDir: dir });
 }
 
-const args = process.argv.slice(2);
-const isHook = args[0] === 'hook';
+async function main() {
+  let bin;
+  try {
+    bin = await resolveBinary();
+  } catch (err) {
+    process.stderr.write(`[plugkit] bootstrap failed: ${err.message}\n`);
+    const legacy = legacyFallback();
+    if (legacy) { bin = legacy; }
+    else process.exit(1);
+  }
 
-if (isHook && !process.stdin.isTTY) {
-  // Claude Code pipes JSON to the wrapper's stdin. On Windows, spawnSync with
-  // stdio:'inherit' does NOT reliably forward a piped stdin to the native child
-  // (the child sees EOF immediately and the hook treats tool_name as empty →
-  // silently allows every command). Read stdin ourselves and write it explicitly.
-  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 });
-    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 });
-  process.exit(result.status ?? 1);
+  const args = process.argv.slice(2);
+  const isHook = args[0] === 'hook';
+
+  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 });
+      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 });
+    process.exit(result.status ?? 1);
+  }
+}
+
+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'),
+    ];
+  } 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;
 }
+
+main().catch(err => {
+  process.stderr.write(`[plugkit] fatal: ${err.message}\n`);
+  process.exit(1);
+});

package/bin/plugkit.sha256

@@ -0,0 +1,6 @@
+a68c00135cba98e20cf36f087987b2d487d9288451543bcf7ce628663e6fc728  plugkit-win32-x64.exe
+7688f1b182af9b9c588ee1f4b10b05a5fcf40765a380a74f9e8b0e20a156d010  plugkit-win32-arm64.exe
+1fb0e30c75d1911552ec55f6e73bc96ac30aafa0a72bf4a90d39c25ce2deb336  plugkit-darwin-x64
+060ace93778d92db280ecd0b81ef079092a8e184407902d10f9ebf02e6b199b6  plugkit-darwin-arm64
+a680e43872feb324f387e873714041c0fe9668dd9202d451d645f95118e4233d  plugkit-linux-x64
+f59bbf825f618e512e939a7bcb3824d6a3bf214f2359df78b37e998956b39fc2  plugkit-linux-arm64

package/bin/plugkit.version

@@ -0,0 +1 @@
+0.1.227

package/package.json

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

package/plugin.json

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

package/bin/plugkit

@@ -1,16 +0,0 @@
-#!/bin/sh
-DIR="$(cd "$(dirname "$0")" && pwd)"
-case "$(uname -s)" in
-  Darwin) OS=darwin ;;
-  MINGW*|MSYS*|CYGWIN*)
-    case "$(uname -m)" in
-      arm64|aarch64) exec "$DIR/plugkit-win32-arm64.exe" "$@" ;;
-      *)             exec "$DIR/plugkit-win32-x64.exe" "$@" ;;
-    esac ;;
-  *) OS=linux ;;
-esac
-case "$(uname -m)" in
-  arm64|aarch64) ARCH=arm64 ;;
-  *)             ARCH=x64   ;;
-esac
-exec "$DIR/plugkit-$OS-$ARCH" "$@"