gm-skill 2.0.1502 → 2.0.1504

package/gm-plugkit/browser-idle.js

@@ -0,0 +1,13 @@
+function selectIdleBrowserSessions(ports, now, limitMs) {
+  const idle = [];
+  if (!ports || typeof ports !== 'object') return idle;
+  for (const [sid, entry] of Object.entries(ports)) {
+    if (!entry || typeof entry !== 'object') continue;
+    const lastUse = Number.isFinite(entry.lastUse) ? entry.lastUse : 0;
+    const idleMs = now - lastUse;
+    if (idleMs >= limitMs) idle.push({ sid, entry, idleMs });
+  }
+  return idle;
+}
+
+module.exports = { selectIdleBrowserSessions };

package/gm-plugkit/browser-idle.test.js

@@ -0,0 +1,46 @@
+const assert = require('assert');
+const { selectIdleBrowserSessions } = require('./browser-idle.js');
+
+const NOW = 1_000_000;
+const LIMIT = 10 * 60 * 1000;
+
+(function onlyPastLimitSelected() {
+  const ports = {
+    active: { pid: 1, lastUse: NOW - 1000 },
+    idle: { pid: 2, lastUse: NOW - (LIMIT + 5000) },
+  };
+  const idle = selectIdleBrowserSessions(ports, NOW, LIMIT);
+  assert.strictEqual(idle.length, 1, 'exactly one idle session selected');
+  assert.strictEqual(idle[0].sid, 'idle', 'the idle session is selected, active untouched');
+})();
+
+(function boundaryIsInclusive() {
+  const ports = { edge: { pid: 1, lastUse: NOW - LIMIT } };
+  const idle = selectIdleBrowserSessions(ports, NOW, LIMIT);
+  assert.strictEqual(idle.length, 1, 'idleMs == limit closes (>=)');
+})();
+
+(function missingLastUseReapedAsStale() {
+  const ports = { orphan: { pid: 1 } };
+  const idle = selectIdleBrowserSessions(ports, NOW, LIMIT);
+  assert.strictEqual(idle.length, 1, 'entry with no lastUse is treated as stale (epoch 0) and reaped');
+  assert.strictEqual(idle[0].sid, 'orphan');
+})();
+
+(function concurrentIsolation() {
+  const ports = {
+    sessA: { pid: 1, lastUse: NOW - 2000 },
+    sessB: { pid: 2, lastUse: NOW - (LIMIT + 1) },
+    sessC: { pid: 3, lastUse: NOW - (LIMIT + 999999) },
+  };
+  const idle = selectIdleBrowserSessions(ports, NOW, LIMIT).map(x => x.sid).sort();
+  assert.deepStrictEqual(idle, ['sessB', 'sessC'], 'only the idle sessions, active sessA preserved');
+})();
+
+(function emptyAndMalformed() {
+  assert.deepStrictEqual(selectIdleBrowserSessions({}, NOW, LIMIT), [], 'empty ports');
+  assert.deepStrictEqual(selectIdleBrowserSessions(null, NOW, LIMIT), [], 'null ports');
+  assert.deepStrictEqual(selectIdleBrowserSessions({ bad: null, str: 'x' }, NOW, LIMIT), [], 'malformed entries skipped');
+})();
+
+console.log('browser-idle.test.js: all assertions passed');

package/gm-plugkit/package.json

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

@@ -563,6 +563,21 @@ function browserStateDir(cwd) {
 function browserPortsFile(cwd) { return path.join(browserStateDir(cwd), 'browser-ports.json'); }
 function browserSessionsFile(cwd) { return path.join(browserStateDir(cwd), 'browser-sessions.json'); }
 
+const { selectIdleBrowserSessions } = require('./browser-idle.js');
+
+function stampBrowserLastUse(cwd, claudeSessionId) {
+  try {
+    const portsFile = browserPortsFile(cwd);
+    const ports = readJsonFile(portsFile, {});
+    const entry = ports[claudeSessionId];
+    if (entry && typeof entry === 'object') {
+      entry.lastUse = Date.now();
+      ports[claudeSessionId] = entry;
+      writeJsonFile(portsFile, ports);
+    }
+  } catch (_) {}
+}
+
 function atomicWriteJson(filePath, obj) {
   const tmp = filePath + '.tmp.' + process.pid + '.' + Date.now() + '.' + Math.random().toString(36).slice(2, 8);
   fs.writeFileSync(tmp, JSON.stringify(obj, null, 2));
@@ -1020,6 +1035,7 @@ function getOrCreateBrowserSession(cwd, claudeSessionId, pw) {
         const sid = parseSessionId(r.stdout || '');
         if (sid) {
           existing.pwSessionId = sid;
+          existing.lastUse = Date.now();
           ports[claudeSessionId] = existing;
           sessions[claudeSessionId] = [sid];
           writeJsonFile(portsFile, ports);
@@ -1092,7 +1108,7 @@ function getOrCreateBrowserSession(cwd, claudeSessionId, pw) {
     logEvent('plugkit', 'browser.launch-failed', { reason: 'session-id-unparseable', stdout: r.stdout });
     throw new Error(`could not parse managed browser session id from: ${scrubBrowserRunnerText(r.stdout || '')}`);
   }
-  ports[claudeSessionId] = { profileDir, pid: browserPid, port, wsEndpoint, pwSessionId };
+  ports[claudeSessionId] = { profileDir, pid: browserPid, port, wsEndpoint, pwSessionId, lastUse: Date.now() };
   sessions[claudeSessionId] = [pwSessionId];
   writeJsonFile(portsFile, ports);
   writeJsonFile(sessionsFile, sessions);
@@ -1833,7 +1849,7 @@ function makeHostFunctions(instanceRef) {
 
         if (trimmed === 'session new' || trimmed === '') {
           const pwSessionId = getOrCreateBrowserSession(cwd, sessionId, pw);
-          try { lastBrowserActivityMs = Date.now(); } catch (_) {}
+          stampBrowserLastUse(cwd, sessionId);
           return writeWasmJson(instanceRef.value, {
             ok: true,
             stdout: `Session ${pwSessionId} attached to locally-profiled chromium at ${path.join(cwd, '.gm', 'browser-profile')}`,
@@ -1845,12 +1861,26 @@ function makeHostFunctions(instanceRef) {
 
         if (trimmed.startsWith('session ')) {
           const parts = trimmed.slice(8).trim().split(/\s+/);
-          // playwriter's actual session subcommands are list|new|delete|reset.
-          // Map the legacy close/kill aliases (recognized here historically) to delete,
-          // and pass list/new/delete/reset through verbatim. Anything else is rejected
-          // by playwriter with its own usage text, which is the correct surface.
           if (parts[0] === 'close' || parts[0] === 'kill') parts[0] = 'delete';
           const r = runBrowserRunner(pw, ['session', ...parts], 30000, cwd, sessionId);
+          if (r.status === 0 && (parts[0] === 'delete' || parts[0] === 'reset')) {
+            try {
+              const portsFile = browserPortsFile(cwd);
+              const sessionsFile = browserSessionsFile(cwd);
+              const ports = readJsonFile(portsFile, {});
+              const sessions = readJsonFile(sessionsFile, {});
+              const entry = ports[sessionId];
+              if (entry && typeof entry === 'object') {
+                if (Number.isFinite(entry.pid) && isProcessAliveSync(entry.pid)) {
+                  gracefulCloseBrowser(entry, `session-${parts[0]}`);
+                }
+                delete ports[sessionId];
+                delete sessions[sessionId];
+                writeJsonFile(portsFile, ports);
+                writeJsonFile(sessionsFile, sessions);
+              }
+            } catch (_) {}
+          }
           return writeWasmJson(instanceRef.value, {
             ok: r.status === 0,
             stdout: scrubBrowserRunnerText(r.stdout || ''),
@@ -1860,7 +1890,7 @@ function makeHostFunctions(instanceRef) {
         }
 
         const pwSessionId = getOrCreateBrowserSession(cwd, sessionId, pw);
-        try { lastBrowserActivityMs = Date.now(); } catch (_) {}
+        stampBrowserLastUse(cwd, sessionId);
         let evalBody = body;
         let timeoutMs = 14000;
         const timeoutMatch = body.match(/^timeout=(\d+)\s*\n([\s\S]*)$/);
@@ -2304,7 +2334,30 @@ async function runSpoolWatcher(instance, spoolDir) {
                 child.unref();
                 try { logEvent('plugkit', 'gm-plugkit.self-stale-respawn', { running_version: own, latest_version: latest }); } catch (_) {}
                 try { fs.writeFileSync(path.join(spoolDir, '.shutdown-reason.json'), JSON.stringify({ reason: 'gm-plugkit-self-stale', ts: Date.now(), pid: process.pid, running_version: own, latest_version: latest })); } catch (_) {}
-                setTimeout(() => process.exit(0), 2000);
+                // Wait for the replacement's fresh heartbeat before exiting (mirror the
+                // version-drift path) instead of a blind 2s exit: the gm-plugkit download can
+                // take many seconds, and exiting early lets the supervisor relaunch the SAME
+                // stale version before the new one lands, so the update never sticks.
+                const myPid = process.pid;
+                const respawnDeadline = Date.now() + 90000;
+                const exitSelfStale = () => { try { process.exit(0); } catch (_) {} };
+                const pollSelfStaleReplacement = () => {
+                  try {
+                    const st = JSON.parse(fs.readFileSync(STATUS_PATH_FOR_TEARDOWN, 'utf8'));
+                    const freshHeartbeat = st && st.ts && (Date.now() - st.ts) < 15000;
+                    const differentProc = st && st.pid && st.pid !== myPid;
+                    if (freshHeartbeat && differentProc) {
+                      try { logEvent('plugkit', 'gm-plugkit.self-stale-respawn-confirmed', { old_pid: myPid, new_pid: st.pid, new_version: st.version, latest_version: latest }); } catch (_) {}
+                      return exitSelfStale();
+                    }
+                  } catch (_) {}
+                  if (Date.now() > respawnDeadline) {
+                    try { logEvent('plugkit', 'gm-plugkit.self-stale-respawn-timeout', { old_pid: myPid, waited_ms: 90000 }); } catch (_) {}
+                    return exitSelfStale();
+                  }
+                  setTimeout(pollSelfStaleReplacement, 1500);
+                };
+                setTimeout(pollSelfStaleReplacement, 3000);
               } catch (e) {
                 console.error(`[plugkit-wasm] failed to spawn replacement on self-stale: ${e.message}`);
               }
@@ -2515,27 +2568,49 @@ async function runSpoolWatcher(instance, spoolDir) {
     }
   }, 60_000);
 
-  const BROWSER_IDLE_LIMIT_MS = parseInt(process.env.PLUGKIT_BROWSER_IDLE_LIMIT_MS, 10) || 60 * 60 * 1000;
-  let lastBrowserActivityMs = Date.now();
+  const BROWSER_IDLE_LIMIT_MS = parseInt(process.env.PLUGKIT_BROWSER_IDLE_LIMIT_MS, 10) || 10 * 60 * 1000;
   setInterval(() => {
     try {
-      const browserIdleMs = Date.now() - lastBrowserActivityMs;
-      if (browserIdleMs < BROWSER_IDLE_LIMIT_MS) return;
       const portsFile = browserPortsFile(process.cwd());
       const sessionsFile = browserSessionsFile(process.cwd());
       const ports = readJsonFile(portsFile, {});
-      let closed = 0;
+      const sessions = readJsonFile(sessionsFile, {});
+      const now = Date.now();
+      const idle = selectIdleBrowserSessions(ports, now, BROWSER_IDLE_LIMIT_MS);
+      const idleSids = new Set(idle.map((x) => x.sid));
+      let mutated = false;
+      for (const { sid, entry, idleMs } of idle) {
+        if (Number.isFinite(entry.pid) && isProcessAliveSync(entry.pid)) {
+          try { gracefulCloseBrowser(entry, 'browser-idle'); } catch (_) {}
+        }
+        delete ports[sid];
+        delete sessions[sid];
+        mutated = true;
+        logEvent('plugkit', 'browser.idle-closed', { sid, pid: entry.pid || null, idle_ms: idleMs });
+      }
       for (const [sid, entry] of Object.entries(ports)) {
-        if (entry && Number.isFinite(entry.pid) && isProcessAliveSync(entry.pid)) {
-          try { gracefulCloseBrowser(entry, 'browser-idle'); closed++; } catch (_) {}
+        if (idleSids.has(sid) || !entry || typeof entry !== 'object') continue;
+        const pidAlive = Number.isFinite(entry.pid) && isProcessAliveSync(entry.pid);
+        if (!pidAlive) {
+          delete ports[sid];
+          delete sessions[sid];
+          mutated = true;
+          logEvent('plugkit', 'browser.stale-reclaimed', { sid, pid: entry.pid || null, reason: 'pid-dead' });
+          continue;
+        }
+        const cdpOk = !!fetchJsonSync(`http://127.0.0.1:${entry.port}/json/version`, 1000);
+        if (!cdpOk) {
+          try { gracefulCloseBrowser(entry, 'orphan-cdp-dead'); } catch (_) {}
+          delete ports[sid];
+          delete sessions[sid];
+          mutated = true;
+          logEvent('plugkit', 'browser.stale-reclaimed', { sid, pid: entry.pid || null, reason: 'cdp-dead' });
         }
       }
-      if (closed > 0) {
-        try { fs.unlinkSync(portsFile); } catch (_) {}
-        try { fs.unlinkSync(sessionsFile); } catch (_) {}
-        logEvent('plugkit', 'browser.idle-closed', { count: closed, idle_ms: browserIdleMs });
+      if (mutated) {
+        try { writeJsonFile(portsFile, ports); } catch (_) {}
+        try { writeJsonFile(sessionsFile, sessions); } catch (_) {}
       }
-      lastBrowserActivityMs = Date.now();
     } catch (e) {
       console.error(`[browser-idle] error: ${e.message}`);
     }

package/gm.json

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

package/lib/browser.js

@@ -115,17 +115,22 @@ async function closeSession(sessionId) {
   return { ok: true, sessionId };
 }
 
-async function closeAllSessions(excludeSessionId = null) {
+async function closeAllSessions(opts = {}) {
   if (!fs.existsSync(SESSION_STATE_DIR)) return { ok: true, closed: 0 };
+  const all = opts && opts.all === true;
+  const only = opts && typeof opts.sessionId === 'string' ? opts.sessionId : null;
+  if (!all && !only) {
+    return { ok: false, error: 'closeAllSessions is session-scoped: pass {sessionId} to close one, or {all:true} to close every session in this state dir. The per-session idle timer auto-closes idle browsers and they re-open seamlessly on next use, so a blanket close-all is no longer routine cleanup.', closed: 0 };
+  }
   const files = fs.readdirSync(SESSION_STATE_DIR);
   let closed = 0;
   for (const file of files) {
     if (!file.endsWith('.json')) continue;
     const sessionId = file.replace('.json', '');
-    if (excludeSessionId && sessionId === excludeSessionId) continue;
+    if (only && sessionId !== only) continue;
     try { await closeSession(sessionId); closed++; } catch (e) {}
   }
-  return { ok: true, closed };
+  return { ok: true, closed, scope: only ? 'session' : 'all' };
 }
 
 module.exports = { createSession, sendCommand, executeScript, getScreenshot, closeSession, closeAllSessions, isBrowserAvailable, loadSessionState, saveSessionState };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-skill",
-  "version": "2.0.1502",
+  "version": "2.0.1504",
   "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",