gm-plugkit 2.0.1516 → 2.0.1518

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-plugkit",
-  "version": "2.0.1516",
+  "version": "2.0.1518",
   "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/supervisor.js

@@ -23,6 +23,7 @@ fs.mkdirSync(spoolDir, { recursive: true });
 const STATUS_PATH = path.join(spoolDir, '.status.json');
 const SHUTDOWN_REASON_PATH = path.join(spoolDir, '.shutdown-reason.json');
 const SUPERVISOR_PATH = path.join(spoolDir, '.supervisor.json');
+const SUPERVISOR_PID_PATH = path.join(spoolDir, '.supervisor.pid');
 const LOG_PATH = path.join(spoolDir, '.watcher.log');
 const GM_LOG_ROOT = process.env.GM_LOG_DIR || path.join(os.homedir(), '.claude', 'gm-log');
 
@@ -66,6 +67,47 @@ function pidAlive(pid) {
   try { process.kill(pid, 0); return true; } catch (_) { return false; }
 }
 
+// Single-instance guard. findSupervisorPid (skill-bootstrap.js) reads .supervisor.pid to early-return
+// when a supervisor is already running; without it every bootstrap spawns a duplicate supervisor,
+// and duplicates spawn duplicate watchers that lock-fight in an endless spawn-reject churn. Write the
+// pid file on startup and refuse to start if a live peer already holds it.
+function acquireSingleInstance() {
+  // Atomic via O_EXCL ('wx'): exclusive-create fails if the file exists, so when N supervisors
+  // race to start in the same instant exactly one wins. A plain existsSync->write is TOCTOU and
+  // lets a concurrent burst all pass, which is the duplicate-supervisor churn this guards against.
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const fd = fs.openSync(SUPERVISOR_PID_PATH, 'wx');
+      try { fs.writeSync(fd, String(process.pid)); } finally { fs.closeSync(fd); }
+      return true;
+    } catch (e) {
+      if (e && e.code === 'EEXIST') {
+        let other = NaN;
+        try { other = parseInt(fs.readFileSync(SUPERVISOR_PID_PATH, 'utf-8').trim(), 10); } catch (_) {}
+        if (Number.isFinite(other) && other !== process.pid && pidAlive(other)) {
+          logEvent('supervisor.refused-duplicate', { existing_pid: other, severity: 'warn' });
+          return false;
+        }
+        // Holder is dead/stale: remove and retry the exclusive create once.
+        try { fs.unlinkSync(SUPERVISOR_PID_PATH); } catch (_) {}
+        continue;
+      }
+      logEvent('supervisor.pid-write-failed', { error: e && e.message, severity: 'warn' });
+      return true;
+    }
+  }
+  return true;
+}
+
+function releaseSingleInstance() {
+  try {
+    if (fs.existsSync(SUPERVISOR_PID_PATH)) {
+      const raw = fs.readFileSync(SUPERVISOR_PID_PATH, 'utf-8').trim();
+      if (parseInt(raw, 10) === process.pid) fs.unlinkSync(SUPERVISOR_PID_PATH);
+    }
+  } catch (_) {}
+}
+
 function readStatus() {
   try { return JSON.parse(fs.readFileSync(STATUS_PATH, 'utf-8')); } catch (_) { return null; }
 }
@@ -273,9 +315,15 @@ process.on('SIGTERM', () => {
   if (currentChildPid && pidAlive(currentChildPid)) {
     try { process.kill(currentChildPid, 'SIGTERM'); } catch (_) {}
   }
+  releaseSingleInstance();
   process.exit(0);
 });
+process.on('exit', () => { releaseSingleInstance(); });
 
+if (!acquireSingleInstance()) {
+  process.stderr.write('[plugkit-supervisor] another supervisor is alive; exiting\n');
+  process.exit(0);
+}
 writeSupervisorStatus('starting', {});
 logEvent('supervisor.starting', { spool_dir: spoolDir });
 try { fs.unlinkSync(path.join(spoolDir, '.pre-supervised-watcher.json')); } catch (_) {}