@yemi33/minions 0.1.2064 → 0.1.2065

package/bin/minions.js

@@ -75,6 +75,58 @@ function killByPort(port) {
 
 const isPortListening = (port) => getListeningPids(port).length > 0;
 
+/**
+ * Wait until no process is listening on `port`, retrying a kill on each tick
+ * for any stragglers that re-appeared (e.g. orphan child the original kill
+ * missed, or a process that respawned itself). Returns true when the port is
+ * free, false on timeout.
+ *
+ * Rationale: `taskkill /F` and `SIGKILL` return immediately while the OS does
+ * the actual termination asynchronously, and the port doesn't transition to
+ * available until the kernel finalises the socket close. Without this wait,
+ * the new dashboard race-spawned just after `killByPort` can hit EADDRINUSE
+ * and exit silently — the bug pattern that surfaced as "Dashboard failed
+ * health check, port=7331 listening=no" while the OLD dashboard PID was
+ * still bound to the port.
+ */
+function waitForPortRelease(port, timeoutMs = 10000, pollMs = 200) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const pids = getListeningPids(port);
+    if (pids.length === 0) return { ok: true, waitedMs: Date.now() - start };
+    // Retry the kill — covers the case where the original killByPort missed a
+    // sibling listener or a new orphan appeared mid-wait.
+    killByPort(port);
+    const sleepUntil = Date.now() + pollMs;
+    while (Date.now() < sleepUntil) { /* spin */ }
+  }
+  return { ok: false, waitedMs: timeoutMs, stillBound: getListeningPids(port) };
+}
+
+/**
+ * Wait until `pid` no longer exists. Returns true when the PID is dead, false
+ * on timeout. Used to confirm the old engine actually exited before the new
+ * one starts writing to control.json — otherwise control.json can flap
+ * between "old engine alive (state=stopping)" and "new engine alive
+ * (state=running)" and the health check reads the wrong snapshot.
+ */
+function waitForPidDeath(pid, timeoutMs = 5000, pollMs = 100) {
+  if (!pid) return { ok: true, waitedMs: 0 };
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      // process.kill(pid, 0) throws if the PID doesn't exist; succeeds (no-op)
+      // if it does. Works on both Windows and POSIX.
+      process.kill(pid, 0);
+    } catch {
+      return { ok: true, waitedMs: Date.now() - start };
+    }
+    const sleepUntil = Date.now() + pollMs;
+    while (Date.now() < sleepUntil) { /* spin */ }
+  }
+  return { ok: false, waitedMs: timeoutMs };
+}
+
 // Pre-restart beacons can outlive the browser window that produced them
 // (closed Edge, locked-screen RDP session) and falsely tell restart to skip
 // the auto-open. We wipe the file during restart so the post-restart probe
@@ -780,6 +832,28 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
   killPidOnly(oldEnginePid);
   killByPort(DASH_PORT);
   killMinionsProcesses(['engine.js', 'dashboard.js']);
+  // Confirm the OS finished the asynchronous termination before we spawn new
+  // processes. Without this, `taskkill /F` returns immediately while the
+  // kernel is still releasing the dashboard's port; the new dashboard spawned
+  // ~10ms later hits EADDRINUSE and exits, producing the "Restart verification
+  // failed, port=7331 listening=no" symptom against an orphan PID that's
+  // STILL bound to the port a heartbeat later.
+  if (oldEnginePid) {
+    const engineDead = waitForPidDeath(oldEnginePid, 5000);
+    if (!engineDead.ok) {
+      console.error(`\n  ERROR: Old engine (PID ${oldEnginePid}) did not exit within 5s after kill.`);
+      console.error(`  The new engine cannot safely take over control.json. Aborting restart.`);
+      process.exit(1);
+    }
+  }
+  const portFree = waitForPortRelease(DASH_PORT, 10000);
+  if (!portFree.ok) {
+    console.error(`\n  ERROR: Port ${DASH_PORT} still in use after 10s — killing failed.`);
+    console.error(`  Bound by PID(s): ${portFree.stillBound.join(', ')}`);
+    console.error(`  Manually free the port: taskkill /F /PID ${portFree.stillBound.join(' /PID ')}`);
+    console.error(`  Then retry: minions restart`);
+    process.exit(1);
+  }
   // Clear stale beacons AFTER the kill so the old dashboard's last writes
   // can't repopulate the file in the gap between clear and shutdown.
   _clearDashboardBrowserState(MINIONS_HOME);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2064",
+  "version": "0.1.2065",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"