gm-plugkit 2.0.1221 → 2.0.1223

package/package.json

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

@@ -78,6 +78,17 @@ function isBrowserRunningFileLocal(rel) {
   return false;
 }
 
+function hashFileShortLocal(cwd, rel) {
+  try {
+    const fs = require('fs');
+    const path = require('path');
+    const crypto = require('crypto');
+    const abs = path.isAbsolute(rel) ? rel : path.join(cwd, rel);
+    const buf = fs.readFileSync(abs);
+    return crypto.createHash('sha256').update(buf).digest('hex').slice(0, 12);
+  } catch (_) { return ''; }
+}
+
 function recordBrowserEditLocal(cwd, filePath) {
   try {
     const fs = require('fs');
@@ -89,8 +100,11 @@ function recordBrowserEditLocal(cwd, filePath) {
     fs.mkdirSync(path.dirname(editsFile), { recursive: true });
     let list = [];
     try { list = JSON.parse(fs.readFileSync(editsFile, 'utf8')); if (!Array.isArray(list)) list = []; } catch (_) {}
-    const entry = { file: rel.replace(/\\\\/g, '/'), ts: Date.now() };
-    if (!list.some(e => e && e.file === entry.file)) list.push(entry);
+    const relPath = rel.replace(/\\\\/g, '/');
+    const hash = hashFileShortLocal(cwd, relPath);
+    const idx = list.findIndex(e => e && e.file === relPath);
+    const entry = { file: relPath, ts: Date.now(), hash };
+    if (idx === -1) list.push(entry); else list[idx] = entry;
     fs.writeFileSync(editsFile, JSON.stringify(list));
     return true;
   } catch (_) { return false; }
@@ -322,9 +336,24 @@ function dispatchAutoRecall(instance, queryPrompt) {
 function tryAutoRecallForTurnEntry(instance, sess, cwd) {
   try {
     const prompt = readUserPromptForRecall(cwd);
-    if (!prompt) return null;
-    const primary = dispatchAutoRecall(instance, prompt);
-    const fallbackQuery = deriveFallbackQuery(prompt);
+    let emptyPromptFallback = false;
+    let effectivePrompt = prompt;
+    if (!prompt || !String(prompt).trim()) {
+      emptyPromptFallback = true;
+      const key = sess || '(no-session)';
+      const t = _turns.get(key);
+      const phase = (t && t.lastPhase) || 'PLAN';
+      const phaseQueryMap = {
+        PLAN: 'PLAN orient',
+        EXECUTE: 'EXECUTE work',
+        EMIT: 'EMIT closure',
+        VERIFY: 'VERIFY trajectory',
+        COMPLETE: 'COMPLETE residual',
+      };
+      effectivePrompt = phaseQueryMap[phase] || 'PLAN orient';
+    }
+    const primary = dispatchAutoRecall(instance, effectivePrompt);
+    const fallbackQuery = deriveFallbackQuery(effectivePrompt);
     let fallback = null;
     if (fallbackQuery && fallbackQuery !== (primary && primary.query)) {
       fallback = dispatchAutoRecall(instance, fallbackQuery);
@@ -344,12 +373,16 @@ function tryAutoRecallForTurnEntry(instance, sess, cwd) {
     if (primary && primary.query) queries.push(primary.query);
     if (fallback && fallback.query && !queries.includes(fallback.query)) queries.push(fallback.query);
     const payload = {
-      query: (primary && primary.query) || '',
+      query: (primary && primary.query) || effectivePrompt || '',
       queries,
       hits: merged.slice(0, 20),
       fired_at: new Date().toISOString(),
       turn_entry: true,
     };
+    if (emptyPromptFallback) {
+      payload.fallback_reason = 'empty-prompt';
+      if (!payload.query) payload.query = effectivePrompt;
+    }
     logEvent('plugkit', 'auto_recall.turn-entry', { sess, queries, count: merged.length });
     return payload;
   } catch (e) {
@@ -618,9 +651,48 @@ function ensureGitignored(cwd, entry) {
   } catch (_) {}
 }
 
+function isProcessAliveSync(pid) {
+  if (!pid || typeof pid !== 'number' || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e && e.code === 'EPERM';
+  }
+}
+
+function readSingletonLockPid(profileDir) {
+  const lock = path.join(profileDir, 'SingletonLock');
+  try {
+    let target;
+    try {
+      target = fs.readlinkSync(lock);
+    } catch (_) {
+      try { target = fs.readFileSync(lock, 'utf-8'); } catch (__) { return null; }
+    }
+    if (!target) return null;
+    const m = String(target).match(/-(\d+)\s*$/);
+    if (m) return parseInt(m[1], 10);
+    const m2 = String(target).match(/(\d+)/);
+    if (m2) return parseInt(m2[1], 10);
+  } catch (_) {}
+  return null;
+}
+
 function isProfileLocked(profileDir) {
   const lock = path.join(profileDir, 'SingletonLock');
-  return fs.existsSync(lock);
+  if (!fs.existsSync(lock)) return false;
+  const holderPid = readSingletonLockPid(profileDir);
+  if (holderPid != null && !isProcessAliveSync(holderPid)) {
+    try { fs.unlinkSync(lock); } catch (_) {}
+    try { fs.unlinkSync(path.join(profileDir, 'SingletonCookie')); } catch (_) {}
+    try { fs.unlinkSync(path.join(profileDir, 'SingletonSocket')); } catch (_) {}
+    logEvent('bootstrap', 'browser-profile.lock-cleared', {
+      profileDir, dead_pid: holderPid,
+    });
+    return false;
+  }
+  return true;
 }
 
 function acquireProfileDir(cwd) {
@@ -636,6 +708,31 @@ function acquireProfileDir(cwd) {
   return fallback;
 }
 
+function cleanDeadProfileFragments(cwd) {
+  try {
+    const gmDir = path.join(cwd, '.gm');
+    if (!fs.existsSync(gmDir)) return { cleaned: 0 };
+    let cleaned = 0;
+    for (const name of fs.readdirSync(gmDir)) {
+      const m = name.match(/^browser-profile-(\d+)$/);
+      if (!m) continue;
+      const pid = parseInt(m[1], 10);
+      if (!isProcessAliveSync(pid)) {
+        try {
+          fs.rmSync(path.join(gmDir, name), { recursive: true, force: true });
+          cleaned++;
+        } catch (_) {}
+      }
+    }
+    if (cleaned > 0) {
+      logEvent('bootstrap', 'browser-profile.hygiene', { cwd, cleaned });
+    }
+    return { cleaned };
+  } catch (_) {
+    return { cleaned: 0 };
+  }
+}
+
 function findFreePortSync() {
   const r = spawnSync(process.execPath, ['-e', `
     const net = require('net');
@@ -689,10 +786,31 @@ function getOrCreateBrowserSession(cwd, claudeSessionId, pw) {
   const ports = readJsonFile(portsFile, {});
   const sessions = readJsonFile(sessionsFile, {});
   const existing = ports[claudeSessionId];
-  if (existing && existing.port && isPortAliveSync(existing.port)) {
-    const pwIds = sessions[claudeSessionId] || [];
-    if (pwIds.length > 0) return pwIds[0];
+  if (existing && existing.port) {
+    const wantProfile = path.join(cwd, '.gm', 'browser-profile');
+    const pidOk = existing.pid && isProcessAliveSync(existing.pid);
+    const profileOk = !existing.profileDir || existing.profileDir === wantProfile || existing.profileDir.startsWith(path.join(cwd, '.gm', 'browser-profile'));
+    const portOk = isPortAliveSync(existing.port);
+    if (pidOk && profileOk && portOk) {
+      const pwIds = sessions[claudeSessionId] || [];
+      if (pwIds.length > 0) return pwIds[0];
+    } else {
+      const reason = !pidOk ? 'pid-dead' : !profileOk ? 'profile-drift' : 'port-dead';
+      logEvent('hook', 'deviation.browser-profile-collision', {
+        sid: claudeSessionId,
+        stale_pid: existing.pid || null,
+        stale_port: existing.port || null,
+        stale_profile: existing.profileDir || null,
+        want_profile: wantProfile,
+        reason,
+      });
+      delete ports[claudeSessionId];
+      delete sessions[claudeSessionId];
+      try { writeJsonFile(portsFile, ports); } catch (_) {}
+      try { writeJsonFile(sessionsFile, sessions); } catch (_) {}
+    }
   }
+  cleanDeadProfileFragments(cwd);
   const chrome = findChrome();
   if (!chrome) throw new Error('Chrome not found. Please install Google Chrome.');
   const profileDir = acquireProfileDir(cwd);
@@ -1276,6 +1394,7 @@ function makeHostFunctions(instanceRef) {
         const lang = opts.lang || 'nodejs';
         const cwd = opts.cwd || process.cwd();
         const rawTimeout = opts.timeoutMs;
+        const MIN_TIMEOUT_MS = 100;
         if (rawTimeout === undefined || rawTimeout === null || typeof rawTimeout !== 'number' || !Number.isFinite(rawTimeout) || rawTimeout <= 0 || !Number.isInteger(rawTimeout)) {
           return writeWasmJson(instanceRef.value, {
             ok: false,
@@ -1285,6 +1404,15 @@ function makeHostFunctions(instanceRef) {
             received: rawTimeout === undefined ? null : rawTimeout,
           });
         }
+        if (rawTimeout < MIN_TIMEOUT_MS) {
+          return writeWasmJson(instanceRef.value, {
+            ok: false,
+            error: 'timeoutMs below floor',
+            min: MIN_TIMEOUT_MS,
+            received: rawTimeout,
+            paper_ref: '§20',
+          });
+        }
         const timeoutMs = rawTimeout;
         let cmd, args;
         if (lang === 'nodejs' || lang === 'js') { cmd = process.execPath; args = ['-e', code]; }
@@ -1342,7 +1470,12 @@ function makeHostFunctions(instanceRef) {
           });
         }
         const pwSessionId = getOrCreateBrowserSession(cwd, sessionId, pw);
-        const r = runPlaywriter(pw, ['-s', pwSessionId, '--timeout', '14000', '-e', body], 60000);
+        const portsAfter = readJsonFile(browserPortsFile(cwd), {});
+        const livePort = portsAfter[sessionId] && portsAfter[sessionId].port;
+        const directArgs = (livePort && isPortAliveSync(livePort))
+          ? [`--direct=localhost:${livePort}`]
+          : [];
+        const r = runPlaywriter(pw, ['-s', pwSessionId, '--timeout', '14000', ...directArgs, '-e', body], 60000);
         return writeWasmJson(instanceRef.value, {
           ok: r.status === 0,
           stdout: scrubBrowserRunnerText(r.stdout || ''),
@@ -1852,10 +1985,23 @@ async function runSpoolWatcher(instance, spoolDir) {
 
       if (verb === 'browser') {
         try {
-          const witnessFile = path.join(process.cwd(), '.gm', 'exec-spool', '.turn-browser-witnessed');
+          const cwd_ = process.cwd();
+          const editsFile = path.join(cwd_, '.gm', 'exec-spool', '.turn-browser-edits.json');
+          const witnessFile = path.join(cwd_, '.gm', 'exec-spool', '.turn-browser-witnessed');
           fs.mkdirSync(path.dirname(witnessFile), { recursive: true });
-          fs.writeFileSync(witnessFile, JSON.stringify({ ts: Date.now(), task: taskBase, dur_ms }));
-          logEvent('plugkit', 'browser.witness-marked', { task: taskBase });
+          let edits = [];
+          try { edits = JSON.parse(fs.readFileSync(editsFile, 'utf8')); if (!Array.isArray(edits)) edits = []; } catch (_) {}
+          const witnessed_hashes = {};
+          for (const e of edits) {
+            if (!e || !e.file) continue;
+            try {
+              const abs = path.isAbsolute(e.file) ? e.file : path.join(cwd_, e.file);
+              const buf = fs.readFileSync(abs);
+              witnessed_hashes[e.file] = crypto.createHash('sha256').update(buf).digest('hex').slice(0, 12);
+            } catch (_) { witnessed_hashes[e.file] = ''; }
+          }
+          fs.writeFileSync(witnessFile, JSON.stringify({ ts: Date.now(), task: taskBase, dur_ms, witnessed_hashes }));
+          logEvent('plugkit', 'browser.witness-marked', { task: taskBase, files: Object.keys(witnessed_hashes) });
         } catch (_) {}
       }
 

package/plugkit.sha256

@@ -1 +1 @@
-{"plugkit.wasm":"9bafe43d985cebd33c63433b532a7f396599905fa1d90c9f411ea292f10fd7c1"}
+{"plugkit.wasm":"0cac0a48e7346d2f75779c9972efe47c3f4ab38063a077660906a53028d2e70a"}

package/plugkit.version

@@ -1 +1 @@
-0.1.448
+0.1.449