gm-plugkit 2.0.1633 → 2.0.1635

package/instructions/browser.md

@@ -44,9 +44,13 @@ dom=<css-selector>\n
 
 **`dom=<css-selector>\n` is the zero-boilerplate element probe.** Returns `{selector, match_count, elements:[{tag, text, attrs, visible, rect}]}` for up to 20 matches -- the fastest answer to "is this element there and what does it say." An invalid selector returns `result.error` (no crash). Composes with `url=`.
 
+**One session per run -- reuse it, then close it.** A browser session is keyed by its spool `sessionId`; every dispatch carrying the SAME sessionId reuses the SAME chromium. A DIFFERENT sessionId opens its OWN chromium -- so a run that invents `probe`/`w2`/`w3`/... names leaks one browser per name. Pick one sessionId, use it for every dispatch, and end with `session close` so nothing is left open; the eval envelope carries a `multi_session_warning` the moment a second distinct session opens. The idle reaper (closes sessions unused past the idle window) and the OS-orphan reaper (kills managed chromiums no live session owns, sparing in-use ones and your own Chrome) are backstops for crashes, not a license to leave sessions open -- close yours.
+
+**The session closes when YOU expect it to, not under you.** A session stays open across turns and think-gaps -- the idle window is generous (15 min of no use), measured from the END of your last dispatch, so a long read or a slow eval never shortens it. A dispatch in flight is never closed mid-run: the idle reaper and the orphan reaper both skip a session while its eval is executing, and a just-launched browser has a grace period before any reaper can touch it. An explicit `session close` is immediate. If the idle/orphan backstop did close a session and you dispatch to it again, it transparently re-launches and the envelope carries `session_relaunched: true` with a `relaunch_note` -- your in-page `window.*` state was reset, so re-establish it; you are told, never silently surprised.
+
 ## Envelope
 
-`{ok, stdout, stderr, exit_code, session_id?, navigation_requested, landed_on_blank?, hint?}`. `stdout` = stringified eval result; `stderr` = page errors + launch diagnostics; `exit_code` non-zero = the dispatch did not land -- read `stderr` and re-dispatch, never blind. `navigation_requested` reflects whether the dispatch carried a `url=`/bare-URL navigation; `landed_on_blank: true` with a `hint` means the expression ran against `about:blank` -- prefix `url=<target>` and re-dispatch.
+`{ok, stdout, stderr, exit_code, session_id?, navigation_requested, landed_on_blank?, hint?, multi_session_warning?}`. `stdout` = stringified eval result; `stderr` = page errors + launch diagnostics; `exit_code` non-zero = the dispatch did not land -- read `stderr` and re-dispatch, never blind. `navigation_requested` reflects whether the dispatch carried a `url=`/bare-URL navigation; `landed_on_blank: true` with a `hint` means the expression ran against `about:blank` -- prefix `url=<target>` and re-dispatch.
 
 ## Headed by default
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-plugkit",
-  "version": "2.0.1633",
+  "version": "2.0.1635",
   "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/plugkit-wasm-wrapper.js

@@ -873,6 +873,97 @@ function reapOrphanBrowserSessions(pw, cwd, claudeSessionId, reason) {
   }
 }
 
+const __openedSessionIds = new Set();
+const __idleClosedSessions = new Set();
+const __inflightDispatch = new Map();
+const __launchingPids = new Map();
+const INFLIGHT_MAX_MS = 130000;
+const LAUNCH_GRACE_MS = 30000;
+function markInflight(sessionId, pid) {
+  __inflightDispatch.set(sessionId, { pid: pid || null, ts: Date.now() });
+}
+function clearInflight(sessionId) {
+  __inflightDispatch.delete(sessionId);
+}
+function inflightPids() {
+  const now = Date.now();
+  const pids = new Set();
+  const sids = new Set();
+  for (const [sid, v] of __inflightDispatch) {
+    if (now - v.ts > INFLIGHT_MAX_MS) { __inflightDispatch.delete(sid); continue; }
+    sids.add(sid);
+    if (Number.isFinite(v.pid)) pids.add(v.pid);
+  }
+  return { pids, sids };
+}
+function markLaunching(pid) { if (Number.isFinite(pid)) __launchingPids.set(pid, Date.now()); }
+function clearLaunching(pid) { __launchingPids.delete(pid); }
+function launchingPidsFresh() {
+  const now = Date.now();
+  const pids = new Set();
+  for (const [pid, ts] of __launchingPids) {
+    if (now - ts > LAUNCH_GRACE_MS) { __launchingPids.delete(pid); continue; }
+    pids.add(pid);
+  }
+  return pids;
+}
+function enumerateManagedChromiums(profileRootMarker) {
+  const marker = String(profileRootMarker || '').toLowerCase().replace(/\\/g, '/');
+  const out = [];
+  try {
+    if (process.platform === 'win32') {
+      const ps = `Get-CimInstance Win32_Process -Filter "Name='chrome.exe'" | Where-Object { $_.CommandLine -like '*--remote-debugging-port*' -and $_.CommandLine -like '*browser-profile*' -and $_.CommandLine -notlike '*--type=*' } | ForEach-Object { $_.ProcessId.ToString() + '|' + $_.CommandLine }`;
+      const r = spawnSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', ps], { encoding: 'utf-8', windowsHide: true, timeout: 10000 });
+      if (r.status === 0 && r.stdout) {
+        for (const line of r.stdout.split(/\r?\n/).filter(Boolean)) {
+          const bar = line.indexOf('|');
+          if (bar < 0) continue;
+          const pid = parseInt(line.slice(0, bar), 10);
+          const cmd = line.slice(bar + 1);
+          if (/--type=/.test(cmd)) continue;
+          if (Number.isFinite(pid) && cmd.toLowerCase().replace(/\\/g, '/').includes(marker)) out.push({ pid, cmd });
+        }
+      }
+    } else {
+      const r = spawnSync('ps', ['-eo', 'pid,command'], { encoding: 'utf-8', timeout: 10000 });
+      if (r.status === 0 && r.stdout) {
+        for (const line of r.stdout.split('\n').slice(1)) {
+          if (!/--remote-debugging-port/.test(line) || !/browser-profile/.test(line)) continue;
+          if (/--type=/.test(line)) continue;
+          const m = line.match(/^\s*(\d+)\s+(.+)$/);
+          if (!m) continue;
+          const pid = parseInt(m[1], 10);
+          if (Number.isFinite(pid) && m[2].toLowerCase().replace(/\\/g, '/').includes(marker)) out.push({ pid, cmd: m[2] });
+        }
+      }
+    }
+  } catch (_) {}
+  return out;
+}
+function reapOrphanChromiums(cwd, reason) {
+  try {
+    const root = browserRootDir(cwd);
+    const marker = path.join(root, '.gm', 'browser-profile').toLowerCase().replace(/\\/g, '/');
+    const procs = enumerateManagedChromiums(marker);
+    if (procs.length === 0) return { reaped: 0 };
+    const ports = readJsonFile(browserPortsFile(cwd), {});
+    const livePids = new Set();
+    for (const ent of Object.values(ports)) {
+      if (ent && Number.isFinite(ent.pid) && isProcessAliveSync(ent.pid)) livePids.add(ent.pid);
+    }
+    const { pids: protectedInflight } = inflightPids();
+    const launching = launchingPidsFresh();
+    let reaped = 0;
+    for (const { pid } of procs) {
+      if (livePids.has(pid) || protectedInflight.has(pid) || launching.has(pid)) continue;
+      try { killPidQuiet(pid); reaped++; logEvent('plugkit', 'browser.os-orphan-reaped', { pid, reason: reason || 'sweep' }); } catch (_) {}
+    }
+    return { reaped };
+  } catch (_) {
+    return { reaped: 0 };
+  }
+}
+
 function resolveWindowsExeLocal(cmd) {
   if (process.platform !== 'win32') return cmd;
   try {
@@ -1292,6 +1383,7 @@ function getOrCreateBrowserSession(cwd, claudeSessionId, pw) {
     logEvent('plugkit', 'browser.start', { profileDir });
     ({ pid: browserPid, port, wsEndpoint } = startManagedBrowser(pw, profileDir));
   }
+  markLaunching(browserPid);
   const r = runBrowserRunner(pw, ['session', 'new', '--direct', wsEndpoint], 30000, cwd, claudeSessionId);
   if (!r || r.status !== 0) {
     const errTxt = scrubBrowserRunnerText((r && (r.stderr || r.stdout)) || 'unknown');
@@ -1307,6 +1399,11 @@ function getOrCreateBrowserSession(cwd, claudeSessionId, pw) {
   sessions[claudeSessionId] = [pwSessionId];
   writeJsonFile(portsFile, ports);
   writeJsonFile(sessionsFile, sessions);
+  clearLaunching(browserPid);
+  if (!__openedSessionIds.has(claudeSessionId) && __openedSessionIds.size >= 1) {
+    logEvent('hook', 'deviation.browser-multi-session', { sid: claudeSessionId, already_open: Array.from(__openedSessionIds), reason: 'a 2nd distinct browser sessionId launched its own chromium this run -- reuse one session per run and close it when done' });
+  }
+  __openedSessionIds.add(claudeSessionId);
   logEvent('plugkit', 'browser.attached', { pwSessionId, pid: browserPid, port });
   return pwSessionId;
   } finally { releaseSpawnLock(); }
@@ -2187,6 +2284,7 @@ function makeHostFunctions(instanceRef) {
             stderr: '',
             exit_code: 0,
             session_id: pwSessionId,
+            hint: 'Reuse this same session for every browser dispatch this run (the spool sessionId selects it); a different sessionId opens its OWN chromium. Close it with `session close` when done -- the idle/orphan reaper is only a backstop.',
           });
         }
 
@@ -2220,8 +2318,13 @@ function makeHostFunctions(instanceRef) {
           });
         }
 
+        const wasIdleClosed = __idleClosedSessions.has(sessionId);
         const pwSessionId = getOrCreateBrowserSession(cwd, sessionId, pw);
+        const curPid = (() => { try { const e = readJsonFile(browserPortsFile(cwd), {})[sessionId]; return e && e.pid; } catch (_) { return null; } })();
+        const wasRelaunched = wasIdleClosed;
+        __idleClosedSessions.delete(sessionId);
         stampBrowserLastUse(cwd, sessionId);
+        markInflight(sessionId, curPid);
         let evalBody = body;
         let timeoutMs = 120000;
         const timeoutMatch = body.match(/^timeout=(\d+)\s*\n([\s\S]*)$/);
@@ -2348,7 +2451,13 @@ function makeHostFunctions(instanceRef) {
           evalBody = `const __RET=await (async()=>{${evalBody}})();\n` + emitResult + `return __RET;`;
         }
         const outerTimeoutMs = Math.min(timeoutMs + 6000, 126000);
-        const r = runBrowserRunner(pw, ['-s', pwSessionId, '--timeout', String(timeoutMs), '-e', evalBody], outerTimeoutMs, cwd, sessionId);
+        let r;
+        try {
+          r = runBrowserRunner(pw, ['-s', pwSessionId, '--timeout', String(timeoutMs), '-e', evalBody], outerTimeoutMs, cwd, sessionId);
+        } finally {
+          clearInflight(sessionId);
+          stampBrowserLastUse(cwd, sessionId);
+        }
         const ok = r.status === 0;
         if (!ok && r.status === null) {
           logEvent('plugkit', 'browser.runner-timeout', { session_id: pwSessionId, timeout_ms: timeoutMs, body_bytes: evalBody.length });
@@ -2375,7 +2484,14 @@ function makeHostFunctions(instanceRef) {
           timeout_ms_used: timeoutMs,
         };
         if (resultParsed) envelope.result = parsedResult;
+        if (wasRelaunched) {
+          envelope.session_relaunched = true;
+          envelope.relaunch_note = 'This session was closed (idle/orphan reaper) and re-launched fresh -- any window.* globals or in-page state from earlier dispatches are gone. Re-establish them before relying on them.';
+        }
         envelope.navigation_requested = !!startUrl;
+        if (__openedSessionIds.size > 1) {
+          envelope.multi_session_warning = `${__openedSessionIds.size} distinct browser sessions opened this run, each its own chromium -- reuse ONE sessionId per run and 'session close' it when done to avoid leaking browsers.`;
+        }
         if (landedOnBlank) {
           envelope.landed_on_blank = true;
           envelope.hint = "page is about:blank: this dispatch did not navigate, so the expression evaluated against an empty page. Prefix the body with 'url=<target>' (or send a bare 'https://...' URL) to open the page you want before evaluating.";
@@ -2488,6 +2604,7 @@ async function runSpoolWatcher(instance, spoolDir) {
   } catch (_) {}
 
   try { reapOrphanBrowserSessions(findBrowserRunner(), process.cwd(), process.env.CLAUDE_SESSION_ID || 'claude-loop-iter', 'watcher-boot'); } catch (_) {}
+  try { reapOrphanChromiums(process.cwd(), 'watcher-boot'); } catch (_) {}
 
 
   const LOCK_PATH = path.join(spoolDir, '.watcher.lock');
@@ -2759,6 +2876,7 @@ async function runSpoolWatcher(instance, spoolDir) {
       }
       try { fs.unlinkSync(portsFile); } catch (_) {}
       try { fs.unlinkSync(sessionsFile); } catch (_) {}
+      try { __inflightDispatch.clear(); __launchingPids.clear(); reapOrphanChromiums(process.cwd(), `teardown:${reason}`); } catch (_) {}
     } catch (_) {}
 
     try {
@@ -3124,7 +3242,7 @@ async function runSpoolWatcher(instance, spoolDir) {
     }
   }, 60_000);
 
-  const BROWSER_IDLE_LIMIT_MS = parseInt(process.env.PLUGKIT_BROWSER_IDLE_LIMIT_MS, 10) || 10 * 60 * 1000;
+  const BROWSER_IDLE_LIMIT_MS = parseInt(process.env.PLUGKIT_BROWSER_IDLE_LIMIT_MS, 10) || 15 * 60 * 1000;
   setInterval(() => {
     try {
       const portsFile = browserPortsFile(process.cwd());
@@ -3132,13 +3250,15 @@ async function runSpoolWatcher(instance, spoolDir) {
       const ports = readJsonFile(portsFile, {});
       const sessions = readJsonFile(sessionsFile, {});
       const now = Date.now();
-      const idle = selectIdleBrowserSessions(ports, now, BROWSER_IDLE_LIMIT_MS);
+      const { sids: inflightSids } = inflightPids();
+      const idle = selectIdleBrowserSessions(ports, now, BROWSER_IDLE_LIMIT_MS).filter((x) => !inflightSids.has(x.sid));
       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 (_) {}
         }
+        try { __idleClosedSessions.add(sid); } catch (_) {}
         delete ports[sid];
         delete sessions[sid];
         mutated = true;
@@ -3168,6 +3288,7 @@ async function runSpoolWatcher(instance, spoolDir) {
         try { writeJsonFile(sessionsFile, sessions); } catch (_) {}
       }
       try { reapOrphanBrowserSessions(findBrowserRunner(), process.cwd(), process.env.CLAUDE_SESSION_ID || 'claude-loop-iter', 'idle-sweep'); } catch (_) {}
+      try { reapOrphanChromiums(process.cwd(), 'idle-sweep'); } catch (_) {}
     } catch (e) {
       console.error(`[browser-idle] error: ${e.message}`);
     }