gm-skill 2.0.1915 → 2.0.1917

package/gm-plugkit/cli.js

@@ -5,7 +5,43 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const cp = require('child_process');
-const { ensureReady, startSpoolDaemon, gmToolsDir, readVersionFile, ensureGmPlugkitVersionFresh, ensureSkillMdFresh, ensureWrapperFresh } = require('./bootstrap');
+const { ensureReady, startSpoolDaemon, gmToolsDir, readVersionFile, ensureGmPlugkitVersionFresh, ensureSkillMdFresh, ensureWrapperFresh, isReady, getWasmPath } = require('./bootstrap');
+
+function getWasmPathSafe() {
+  try { return getWasmPath(); } catch (_) { return null; }
+}
+
+function spawnBackgroundFreshnessCheck(reason) {
+  try {
+    const child = cp.spawn(process.execPath, [__filename.replace(/cli\.js$/, 'bootstrap.js')], {
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true,
+      env: { ...process.env, GM_PLUGKIT_BACKGROUND_REFRESH: reason },
+    });
+    child.unref();
+  } catch (_) {}
+}
+
+function spawnDaemonOrExit(version, binaryPath, message) {
+  let daemon;
+  try {
+    daemon = startSpoolDaemon();
+  } catch (err) {
+    writeCliError('start-daemon', err);
+    console.error('Daemon start failed:', err.message);
+    process.exit(1);
+  }
+  if (!daemon || !daemon.ok) {
+    const errMsg = (daemon && daemon.error) || 'startSpoolDaemon returned non-ok';
+    writeCliError('start-daemon', new Error(errMsg));
+    console.error('Daemon start failed:', errMsg);
+    process.exit(1);
+  }
+  writeCliStatus({ phase: 'daemon-spawned', version, daemon_pid: daemon.pid, log: daemon.logPath });
+  console.log(JSON.stringify({ ok: true, binary: binaryPath, daemon, message }));
+  process.exit(0);
+}
 
 function readUpdateAvailableMarker(dir) {
   try {
@@ -237,6 +273,19 @@ function writeCliError(phase, err) {
     } catch (_) {}
   }
 
+  const wrapperPath = path.join(gmToolsDir(), 'plugkit-wasm-wrapper.js');
+  if (isReady() && fs.existsSync(wrapperPath)) {
+    let installedVersion = null;
+    try { installedVersion = readVersionFile(); } catch (_) { installedVersion = null; }
+    writeCliStatus({ phase: 'bootstrapped', version: installedVersion, binary: getWasmPathSafe() });
+    spawnBackgroundFreshnessCheck(versionDrifted ? 'version-drift-respawn' : 'fast-path-spawn');
+    spawnDaemonOrExit(
+      installedVersion,
+      getWasmPathSafe(),
+      'plugkit daemon spawned from existing local install, not yet confirmed serving -- check .gm/exec-spool/.status.json for heartbeat freshness; remote freshness check running in background'
+    );
+  }
+
   let bootstrapResult;
   try {
     bootstrapResult = await ensureReady();
@@ -254,40 +303,11 @@ function writeCliError(phase, err) {
   }
 
   writeCliStatus({ phase: 'bootstrapped', version: bootstrapResult.version, binary: bootstrapResult.binaryPath });
-
-  let daemon;
-  try {
-    daemon = startSpoolDaemon();
-  } catch (err) {
-    writeCliError('start-daemon', err);
-    console.error('Daemon start failed:', err.message);
-    process.exit(1);
-  }
-
-  if (!daemon || !daemon.ok) {
-    const errMsg = (daemon && daemon.error) || 'startSpoolDaemon returned non-ok';
-    writeCliError('start-daemon', new Error(errMsg));
-    console.error('Daemon start failed:', errMsg);
-    process.exit(1);
-  }
-
-  // Fire-and-forget: the daemon child is already detached+unref'd by
-  // startSpoolDaemon(), so the CLI process itself has nothing left to do.
-  // Waiting here for a heartbeat confirmation (removed) used to block the
-  // calling shell for the full bootstrap+first-heartbeat duration -- up to
-  // 30s on a healthy boot, worse on a slow/degraded one -- holding up every
-  // caller even though the daemon spawn itself is near-instant. A caller
-  // that needs serving-confirmation reads .gm/exec-spool/.status.json
-  // directly (ts freshness) rather than blocking this call on it.
-  writeCliStatus({ phase: 'daemon-spawned', version: bootstrapResult.version, daemon_pid: daemon.pid, log: daemon.logPath });
-
-  console.log(JSON.stringify({
-    ok: true,
-    binary: bootstrapResult.binaryPath,
-    daemon,
-    message: 'plugkit daemon spawned, not yet confirmed serving -- check .gm/exec-spool/.status.json for heartbeat freshness'
-  }));
-  process.exit(0);
+  spawnDaemonOrExit(
+    bootstrapResult.version,
+    bootstrapResult.binaryPath,
+    'plugkit daemon spawned, not yet confirmed serving -- check .gm/exec-spool/.status.json for heartbeat freshness'
+  );
 })().catch((err) => {
   writeCliError('uncaught', err);
   console.error('gm-plugkit failed:', err && err.message ? err.message : err);

package/gm-plugkit/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-plugkit",
-  "version": "2.0.1915",
+  "version": "2.0.1917",
   "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

@@ -790,29 +790,40 @@ function findCachedBunRunnerVersion() {
 const _patchedPlaywriterDistDirs = new Set();
 function patchPlaywriterTimeoutBug(binJs) {
   try {
-    const distDir = path.dirname(binJs);
-    if (_patchedPlaywriterDistDirs.has(distDir)) return;
-    _patchedPlaywriterDistDirs.add(distDir);
-    const executorPath = path.join(distDir, 'executor.js');
-    if (fs.existsSync(executorPath)) {
-      const src = fs.readFileSync(executorPath, 'utf-8');
-      if (/async execute\(code, timeout = 10000\) \{(?!\s*timeout = Number)/.test(src)) {
-        const patched = src.replace(
-          /(async execute\(code, timeout = 10000\) \{)/,
-          '$1\n        timeout = Number(timeout) || 10000;'
-        );
-        fs.writeFileSync(executorPath, patched);
+    const pkgDir = path.dirname(binJs);
+    if (_patchedPlaywriterDistDirs.has(pkgDir)) return;
+    _patchedPlaywriterDistDirs.add(pkgDir);
+    // executor.js/cli.js live under <pkg-dir>/dist/ in the real published package layout, not
+    // directly alongside bin.js -- the prior version of this function joined path.dirname(binJs)
+    // straight onto 'executor.js'/'cli.js', which never matched any real file (fs.existsSync was
+    // always false), so the timeout-coercion patch silently never applied and every managed
+    // browser session with an explicit timeout= prefix threw
+    // `TypeError [ERR_INVALID_ARG_TYPE]: The "options.timeout" property must be of type number`.
+    // Check both the dist/ subfolder (the real layout) and the flat pkg-dir (defensive fallback
+    // for a differently-laid-out future version) so this keeps working either way.
+    const candidateDirs = [path.join(pkgDir, 'dist'), pkgDir];
+    for (const distDir of candidateDirs) {
+      const executorPath = path.join(distDir, 'executor.js');
+      if (fs.existsSync(executorPath)) {
+        const src = fs.readFileSync(executorPath, 'utf-8');
+        if (/async execute\(code, timeout = 10000\) \{(?!\s*timeout = Number)/.test(src)) {
+          const patched = src.replace(
+            /(async execute\(code, timeout = 10000\) \{)/,
+            '$1\n        timeout = Number(timeout) || 10000;'
+          );
+          fs.writeFileSync(executorPath, patched);
+        }
       }
-    }
-    const cliPath = path.join(distDir, 'cli.js');
-    if (fs.existsSync(cliPath)) {
-      const src = fs.readFileSync(cliPath, 'utf-8');
-      if (src.includes('timeout: options.timeout || 10000') && !src.includes('timeout: Number(options.timeout)')) {
-        const patched = src.replace(
-          'timeout: options.timeout || 10000',
-          'timeout: Number(options.timeout) || 10000'
-        );
-        fs.writeFileSync(cliPath, patched);
+      const cliPath = path.join(distDir, 'cli.js');
+      if (fs.existsSync(cliPath)) {
+        const src = fs.readFileSync(cliPath, 'utf-8');
+        if (src.includes('timeout: options.timeout || 10000') && !src.includes('timeout: Number(options.timeout)')) {
+          const patched = src.replace(
+            'timeout: options.timeout || 10000',
+            'timeout: Number(options.timeout) || 10000'
+          );
+          fs.writeFileSync(cliPath, patched);
+        }
       }
     }
   } catch (_) {}
@@ -3116,15 +3127,25 @@ function makeHostFunctions(instanceRef) {
         const __topNM = modeOpts.match(/topN=(\d+)/);
         const sampleIntervalUs = __intervalM && parseInt(__intervalM[1], 10) > 0 ? parseInt(__intervalM[1], 10) : 100;
         const profileTopNBrowser = __topNM && parseInt(__topNM[1], 10) > 0 ? parseInt(__topNM[1], 10) : 20;
+        // Real, pre-existing bug fixed here: this block previously called `page.evaluateOnNewDocument`,
+        // which is a PUPPETEER method name -- playwriter's `page` object is a real Playwright Page,
+        // whose equivalent is `page.addInitScript`. evaluateOnNewDocument does not exist on a
+        // Playwright page, so both calls threw `TypeError: page.evaluateOnNewDocument is not a
+        // function` on every single dispatch, silently swallowed by the enclosing try/catch -- meaning
+        // window.__gmErrors (window.onerror/onunhandledrejection capture) was NEVER actually installed,
+        // for as long as this code has existed, independent of the new GL-instrumentation block added
+        // alongside it (which inherited the same wrong method name by copying the existing pattern).
+        // Verified live: window.HTMLCanvasElement.prototype.getContext.toString() did not contain the
+        // patch marker before this fix, confirming the pre-navigation init script never ran.
         const debugSetup = `const __logs=[],__errs=[],__net=[];\n`
           + `try{page.on('console',m=>{try{__logs.push({type:m.type(),text:m.text()});}catch(_){}});`
           + `page.on('pageerror',e=>{try{__errs.push({type:'pageerror',msg:String(e&&e.message||e)});}catch(_){}});`
           + `page.on('error',e=>{try{__errs.push({type:'uncaught',msg:String(e&&e.message||e),stack:String(e&&e.stack||'')});}catch(_){}});`
           + `page.on('requestfinished',r=>{try{const t=r.timing();let __st=0,__sz=0;try{__st=(r.response()&&r.response().status())||0;}catch(_){}__net.push({url:String(r.url()).slice(0,120),method:r.method(),status:__st,dur_ms:Math.round(t.responseEnd),ttfb_ms:Math.round(t.responseStart)});}catch(_){}});`
           + `page.on('requestfailed',r=>{try{const err=r.failure();__errs.push({type:'fetch',msg:String(err&&err.errorText||'request failed'),url:String(r.url()).slice(0,120)});}catch(_){}});`
-          + `page.evaluateOnNewDocument(()=>{window.__gmErrors=[];window.onerror=(msg,src,line,col,err)=>{try{window.__gmErrors.push({type:'error',msg:String(msg),src:String(src).slice(0,80),line,col,stack:String(err&&err.stack||'')});}catch(_){};return false;};window.onunhandledrejection=(e)=>{try{window.__gmErrors.push({type:'unhandledRejection',msg:String(e.reason&&e.reason.message||e.reason),stack:String(e.reason&&e.reason.stack||'')});}catch(_){}};});`
+          + `await page.addInitScript(()=>{window.__gmErrors=[];window.onerror=(msg,src,line,col,err)=>{try{window.__gmErrors.push({type:'error',msg:String(msg),src:String(src).slice(0,80),line,col,stack:String(err&&err.stack||'')});}catch(_){};return false;};window.onunhandledrejection=(e)=>{try{window.__gmErrors.push({type:'unhandledRejection',msg:String(e.reason&&e.reason.message||e.reason),stack:String(e.reason&&e.reason.stack||'')});}catch(_){}};});`
           // Auto-instrument every canvas's WebGL/WebGL2 context: patch getContext once (idempotent,
-          // pre-navigation via evaluateOnNewDocument so it is in place before the page's own first
+          // pre-navigation via page.addInitScript so it is in place before the page's own first
           // getContext call) to wrap every draw call (drawArrays/drawElements and their -Instanced
           // variants) with a post-call gl.getError() drain. This is exactly the manual
           // gl.*=function(){...gl.getError()...} monkeypatch pattern used ad hoc to root-cause GPU
@@ -3134,7 +3155,7 @@ function makeHostFunctions(instanceRef) {
           // window.__gmGlErrors accumulates {fn,mode,count,offset,type,error,errorName,ctxLabel} for
           // up to 40 distinct GL errors per page load (capped to bound memory on a runaway-error page);
           // window.__gmGlDrawCalls is a running total per draw-fn name for volume context.
-          + `page.evaluateOnNewDocument(()=>{`
+          + `await page.addInitScript(()=>{`
           +   `window.__gmGlErrors=[];window.__gmGlDrawCalls={};`
           +   `const __glErrName=(gl,code)=>{for(const k of ['NO_ERROR','INVALID_ENUM','INVALID_VALUE','INVALID_OPERATION','INVALID_FRAMEBUFFER_OPERATION','OUT_OF_MEMORY','CONTEXT_LOST_WEBGL']){try{if(gl[k]===code)return k;}catch(_){}}return 'UNKNOWN_'+code;};`
           +   `const __wrapDraw=(gl,ctxLabel)=>{`

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1915",
+  "version": "2.0.1917",
   "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.1915",
+  "version": "2.0.1917",
   "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",