gm-skill 2.0.1849 → 2.0.1851

package/gm-plugkit/bootstrap.js

@@ -1047,13 +1047,12 @@ function probeUnsupervisedWatcher(spoolDir) {
 }
 
 function resolveNodeRuntime() {
-  const isNodeExe = (p) => /(^|[\\/])node(\.exe)?$/i.test(String(p || ''));
   const candidates = [];
-  if (isNodeExe(process.env.GM_NODE_PATH)) candidates.push(process.env.GM_NODE_PATH);
-  if (isNodeExe(process.execPath)) candidates.push(process.execPath);
+  if (process.env.PLUGKIT_RUNTIME) candidates.push(process.env.PLUGKIT_RUNTIME);
+  candidates.push('bun');
   try {
     const which = process.platform === 'win32' ? 'where' : 'which';
-    const out = require('child_process').spawnSync(which, ['node'], { encoding: 'utf8', windowsHide: true });
+    const out = require('child_process').spawnSync(which, ['bun'], { encoding: 'utf8', windowsHide: true });
     if (out && out.stdout) {
       const first = out.stdout.split(/\r?\n/).map((s) => s.trim()).filter(Boolean)[0];
       if (first) candidates.push(first);
@@ -1062,6 +1061,21 @@ function resolveNodeRuntime() {
   for (const c of candidates) {
     try { const r = require('child_process').spawnSync(c, ['--version'], { stdio: 'ignore', windowsHide: true }); if (r && r.status === 0) return c; } catch (_) {}
   }
+  const isNodeExe = (p) => /(^|[\\/])node(\.exe)?$/i.test(String(p || ''));
+  const nodeCandidates = [];
+  if (isNodeExe(process.env.GM_NODE_PATH)) nodeCandidates.push(process.env.GM_NODE_PATH);
+  if (isNodeExe(process.execPath)) nodeCandidates.push(process.execPath);
+  try {
+    const which = process.platform === 'win32' ? 'where' : 'which';
+    const out = require('child_process').spawnSync(which, ['node'], { encoding: 'utf8', windowsHide: true });
+    if (out && out.stdout) {
+      const first = out.stdout.split(/\r?\n/).map((s) => s.trim()).filter(Boolean)[0];
+      if (first) nodeCandidates.push(first);
+    }
+  } catch (_) {}
+  for (const c of nodeCandidates) {
+    try { const r = require('child_process').spawnSync(c, ['--version'], { stdio: 'ignore', windowsHide: true }); if (r && r.status === 0) return c; } catch (_) {}
+  }
   return process.execPath;
 }
 

package/gm-plugkit/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-plugkit",
-  "version": "2.0.1849",
+  "version": "2.0.1851",
   "description": "Bootstrap and daemon-spawn tool for gm plugkit binary. Downloads the correct platform binary, verifies SHA256, and starts the spool watcher daemon. Includes plugkit-wasm-wrapper for WASM-based spool watching.",
   "main": "index.js",
   "bin": {

package/gm-plugkit/plugkit-wasm-wrapper.js

@@ -117,12 +117,14 @@ function clearVerbActive() {
 
 process.on('uncaughtException', (err) => {
   try { console.error('[plugkit-wasm] uncaught:', err && err.stack || err); } catch (_) {}
+  try { killAllTasks('crash:uncaughtException'); } catch (_) {}
   emitShutdownReason('uncaughtException', err);
   process.exit(1);
 });
 
 process.on('unhandledRejection', (reason) => {
   try { console.error('[plugkit-wasm] unhandled rejection:', reason && reason.stack || reason); } catch (_) {}
+  try { killAllTasks('crash:unhandledRejection'); } catch (_) {}
   emitShutdownReason('unhandledRejection', reason instanceof Error ? reason : new Error(String(reason)));
   process.exit(1);
 });
@@ -744,24 +746,38 @@ function aggregateCpuProfile(profile, topN) {
 
 const BROWSER_RUNNER_BIN = process.env.GM_BROWSER_RUNNER_BIN || 'playwriter';
 
+function findCachedBunRunnerBin() {
+  try {
+    const cacheDir = path.join(os.homedir(), '.bun', 'install', 'cache');
+    const entries = fs.readdirSync(cacheDir).filter(n => n.startsWith(`${BROWSER_RUNNER_BIN}@`));
+    for (const name of entries) {
+      const binJs = path.join(cacheDir, name, 'bin.js');
+      if (fs.existsSync(binJs)) return binJs;
+    }
+  } catch (_) {}
+  return null;
+}
+
 function findBrowserRunner() {
-  const npmR = spawnSync('npm', ['root', '-g'], { encoding: 'utf-8', shell: true });
-  if (npmR.status === 0 && npmR.stdout.trim()) {
-    const root = npmR.stdout.trim().split(/\r?\n/).pop();
-    const binJs = path.join(root, BROWSER_RUNNER_BIN, 'bin.js');
+  const bunGlobalRoots = [
+    path.join(os.homedir(), '.bun', 'install', 'global', 'node_modules', BROWSER_RUNNER_BIN, 'bin.js'),
+  ];
+  for (const binJs of bunGlobalRoots) {
     if (fs.existsSync(binJs)) return { cmd: process.execPath, baseArgs: [binJs], shell: false };
   }
+  const cachedBin = findCachedBunRunnerBin();
+  if (cachedBin) return { cmd: process.execPath, baseArgs: [cachedBin], shell: false };
   const whichCmd = process.platform === 'win32' ? 'where' : 'which';
+  const bunR = spawnSync(whichCmd, ['bun'], { encoding: 'utf-8', shell: true });
+  if (bunR.status === 0 && bunR.stdout.trim()) {
+    return { cmd: 'bun', baseArgs: ['x', `${BROWSER_RUNNER_BIN}@latest`], shell: true };
+  }
   const r = spawnSync(whichCmd, [BROWSER_RUNNER_BIN], { encoding: 'utf-8', shell: true });
   if (r.status === 0 && r.stdout.trim()) {
     const candidates = r.stdout.split(/\r?\n/).map(l => l.trim()).filter(Boolean);
     const cmd = candidates.find(c => c.toLowerCase().endsWith('.cmd')) || candidates.find(c => !c.toLowerCase().endsWith('.ps1')) || candidates[0];
     if (cmd) return { cmd, baseArgs: [], shell: process.platform === 'win32' };
   }
-  const bunR = spawnSync(whichCmd, ['bun'], { encoding: 'utf-8', shell: true });
-  if (bunR.status === 0 && bunR.stdout.trim()) {
-    return { cmd: 'bun', baseArgs: ['x', `${BROWSER_RUNNER_BIN}@latest`], shell: true };
-  }
   const npxR = spawnSync(whichCmd, ['npx'], { encoding: 'utf-8', shell: true });
   if (npxR.status === 0 && npxR.stdout.trim()) {
     return { cmd: 'npx', baseArgs: ['-y', BROWSER_RUNNER_BIN], shell: true };
@@ -827,8 +843,7 @@ function isProfileLocked(profileDir) {
 }
 
 function sessionProfileSlug(claudeSessionId) {
-  const s = String(claudeSessionId || 'default').replace(/[^a-zA-Z0-9_-]/g, '-').slice(0, 64);
-  return s || 'default';
+  return 'default';
 }
 
 function sessionProfileDir(cwd, claudeSessionId) {
@@ -864,6 +879,7 @@ function cleanDeadProfileFragments(cwd) {
         }
         continue;
       }
+      if (name === 'browser-profile-default') continue;
       try {
         if (fs.existsSync(dir) && !isProfileLocked(dir)) {
           fs.rmSync(dir, { recursive: true, force: true });
@@ -2116,8 +2132,25 @@ function nextTaskId(cwd) {
   return `t${n}`;
 }
 
+let _jsRuntimeCmd = null;
+function resolveJsRuntimeCmd() {
+  if (_jsRuntimeCmd) return _jsRuntimeCmd;
+  if (!/(^|[\\/])node(\.exe)?$/i.test(String(process.execPath || ''))) {
+    _jsRuntimeCmd = process.execPath;
+    return _jsRuntimeCmd;
+  }
+  try {
+    const which = process.platform === 'win32' ? 'where' : 'which';
+    const out = spawnSync(which, ['bun'], { encoding: 'utf-8', windowsHide: true });
+    const first = (out && out.stdout || '').split(/\r?\n/).map((s) => s.trim()).filter(Boolean)[0];
+    if (first) { _jsRuntimeCmd = first; return _jsRuntimeCmd; }
+  } catch (_) {}
+  _jsRuntimeCmd = process.execPath;
+  return _jsRuntimeCmd;
+}
+
 function langToCmd(lang, code) {
-  if (lang === 'nodejs' || lang === 'js' || lang === 'javascript' || lang === 'node') return { cmd: process.execPath, args: ['-e', code], stdinCode: null };
+  if (lang === 'nodejs' || lang === 'js' || lang === 'javascript' || lang === 'node') return { cmd: resolveJsRuntimeCmd(), args: ['-e', code], stdinCode: null };
   if (lang === 'python' || lang === 'py') return { cmd: 'python', args: ['-c', code], stdinCode: null };
   if (lang === 'bash' || lang === 'sh' || lang === 'shell' || lang === 'zsh') return { cmd: 'bash', args: ['-c', code], stdinCode: null };
   if (lang === 'powershell' || lang === 'ps1') return { cmd: 'powershell', args: ['-NoProfile', '-NonInteractive', '-Command', code], stdinCode: null };
@@ -2125,10 +2158,15 @@ function langToCmd(lang, code) {
   return null;
 }
 
+const TASK_MAX_TIMEOUT_MS = 10 * 60 * 1000;
+
 function spawnTask({ cwd, lang, code, timeoutMs }) {
   const id = nextTaskId(cwd);
   const built = langToCmd(lang, code);
   if (!built) return { ok: false, error: `unsupported lang: ${lang}` };
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > TASK_MAX_TIMEOUT_MS) {
+    timeoutMs = TASK_MAX_TIMEOUT_MS;
+  }
   const outLog = taskOutPath(cwd, id, 'stdout');
   const errLog = taskOutPath(cwd, id, 'stderr');
   let outFd = null, errFd = null;
@@ -2261,6 +2299,43 @@ function killAllTasks(reason) {
   return killed;
 }
 
+function pidAliveLocal(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try { process.kill(pid, 0); return true; } catch (_) { return false; }
+}
+
+function sweepOrphanedTaskMetaOnBoot(cwd) {
+  let swept = 0;
+  try {
+    const dir = tasksDir(cwd);
+    const now = Date.now();
+    for (const name of fs.readdirSync(dir)) {
+      if (!/^t\d+\.json$/.test(name)) continue;
+      const metaPath = path.join(dir, name);
+      let meta = null;
+      try { meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8')); } catch (_) { continue; }
+      if (!meta || meta.status !== 'running') continue;
+      const stale = !pidAliveLocal(meta.pid) || (meta.deadline_ms && now > meta.deadline_ms);
+      if (!stale) continue;
+      if (pidAliveLocal(meta.pid)) {
+        try {
+          if (process.platform === 'win32') {
+            spawnSync('taskkill', ['/F', '/T', '/PID', String(meta.pid)], { stdio: 'ignore', windowsHide: true, timeout: 3000 });
+          } else {
+            try { process.kill(-meta.pid, 'SIGKILL'); } catch (_) { try { process.kill(meta.pid, 'SIGKILL'); } catch (_) {} }
+          }
+        } catch (_) {}
+      }
+      meta.status = 'reaped-on-boot';
+      meta.ended_ms = now;
+      try { fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2)); } catch (_) {}
+      swept += 1;
+    }
+  } catch (_) {}
+  if (swept > 0) logEvent('plugkit', 'task.bootSweepReaped', { cwd: cwd || process.cwd(), count: swept });
+  return swept;
+}
+
 function hostTaskProc(action, params) {
   switch (action) {
     case 'spawn': return spawnTask(params);
@@ -3394,6 +3469,8 @@ async function runSpoolWatcher(instance, spoolDir) {
     process.exit(0);
   }
 
+  try { sweepOrphanedTaskMetaOnBoot(process.cwd()); } catch (_) {}
+
   setInterval(() => {
     try { reapTimedOutTasks(); } catch (_) {}
   }, 5000);
@@ -3744,7 +3821,7 @@ async function runSpoolWatcher(instance, spoolDir) {
     }
   }, 60_000);
 
-  const BROWSER_IDLE_LIMIT_MS = parseInt(process.env.PLUGKIT_BROWSER_IDLE_LIMIT_MS, 10) || 15 * 60 * 1000;
+  const BROWSER_IDLE_LIMIT_MS = parseInt(process.env.PLUGKIT_BROWSER_IDLE_LIMIT_MS, 10) || 5 * 60 * 1000;
   setInterval(() => {
     try {
       const portsFile = browserPortsFile(process.cwd());

package/gm-plugkit/supervisor.js

@@ -194,14 +194,13 @@ function spawnWatcher(bootReason) {
   }
 
   const isNodeExe = (p) => /(^|[\\/])node(\.exe)?$/i.test(String(p || ''));
-  const resolveNode = () => {
+  const resolveRuntime = () => {
     const candidates = [];
-    if (isNodeExe(process.env.PLUGKIT_RUNTIME)) candidates.push(process.env.PLUGKIT_RUNTIME);
-    if (isNodeExe(process.execPath)) candidates.push(process.execPath);
-    if (process.env.GM_NODE_PATH) candidates.push(process.env.GM_NODE_PATH);
+    if (process.env.PLUGKIT_RUNTIME) candidates.push(process.env.PLUGKIT_RUNTIME);
+    candidates.push('bun');
     try {
       const which = process.platform === 'win32' ? 'where' : 'which';
-      const out = spawnSync(which, ['node'], { encoding: 'utf8', windowsHide: true });
+      const out = spawnSync(which, ['bun'], { encoding: 'utf8', windowsHide: true });
       if (out && out.stdout) {
         const first = out.stdout.split(/\r?\n/).map((s) => s.trim()).filter(Boolean)[0];
         if (first) candidates.push(first);
@@ -210,9 +209,23 @@ function spawnWatcher(bootReason) {
     for (const c of candidates) {
       try { const r = spawnSync(c, ['--version'], { stdio: 'ignore', windowsHide: true }); if (r && r.status === 0) return c; } catch (_) {}
     }
+    const nodeCandidates = [];
+    if (isNodeExe(process.execPath)) nodeCandidates.push(process.execPath);
+    if (process.env.GM_NODE_PATH) nodeCandidates.push(process.env.GM_NODE_PATH);
+    try {
+      const which = process.platform === 'win32' ? 'where' : 'which';
+      const out = spawnSync(which, ['node'], { encoding: 'utf8', windowsHide: true });
+      if (out && out.stdout) {
+        const first = out.stdout.split(/\r?\n/).map((s) => s.trim()).filter(Boolean)[0];
+        if (first) nodeCandidates.push(first);
+      }
+    } catch (_) {}
+    for (const c of nodeCandidates) {
+      try { const r = spawnSync(c, ['--version'], { stdio: 'ignore', windowsHide: true }); if (r && r.status === 0) return c; } catch (_) {}
+    }
     return process.execPath;
   };
-  let cmd = resolveNode();
+  let cmd = resolveRuntime();
   let args = [wrapper, 'spool'];
 
   let logFd = null;

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1849",
+  "version": "2.0.1851",
   "description": "Spool-dispatch orchestration engine with unified state machine, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-skill",
-  "version": "2.0.1849",
+  "version": "2.0.1851",
   "description": "Canonical universal harness — AI-native software engineering via skill-driven orchestration; bootstraps plugkit for task execution and session isolation. Install in any AI coding agent host.",
   "author": "AnEntrypoint",
   "license": "MIT",