@yemi33/minions 0.1.1826 → 0.1.1828

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.1828 (2026-05-09)
+
+### Other
+- refactor(cli): atomic clear, soft-fail browser-open, fix stale test message
+
+## 0.1.1827 (2026-05-09)
+
+### Other
+- refactor(cli): consolidate browser-open helpers and tighten restart flow
+
 ## 0.1.1826 (2026-05-09)
 
 ### Fixes

package/bin/minions.js

@@ -40,9 +40,9 @@ const { spawn, spawnSync, execSync } = require('child_process');
 
 const PKG_ROOT = path.resolve(__dirname, '..');
 const shared = require(path.join(PKG_ROOT, 'engine', 'shared'));
+const { openUrlInBrowser } = shared;
 const { waitForRestartHealth, formatRestartHealthError } = require(path.join(PKG_ROOT, 'engine', 'restart-health'));
 const DASH_PORT = 7331;
-const DASHBOARD_BROWSER_PRESENCE_MAX_AGE_MS = 45000;
 
 /** Returns PIDs (as strings) of processes LISTENING on `port`. Empty on no match
  *  or when the platform tool (netstat/findstr/lsof) is unavailable. */
@@ -74,28 +74,16 @@ function killByPort(port) {
 
 const isPortListening = (port) => getListeningPids(port).length > 0;
 
-function hasRecentDashboardBrowserTab(minionsHome, now = Date.now()) {
-  try {
-    const fp = path.join(minionsHome, 'engine', 'dashboard-browser.json');
-    const state = JSON.parse(fs.readFileSync(fp, 'utf8'));
-    const tabs = state && state.tabs && typeof state.tabs === 'object' ? state.tabs : {};
-    return Object.values(tabs).some(tab => {
-      const lastSeen = Number(tab && tab.lastSeen);
-      return Number.isFinite(lastSeen) && now - lastSeen <= DASHBOARD_BROWSER_PRESENCE_MAX_AGE_MS;
-    });
-  } catch { return false; }
-}
-
-// Clear the browser-presence cache. Pre-restart beacons can outlive the
-// browser window that produced them (closed Edge, locked-screen RDP session,
-// stale heuristic timer) and falsely tell `restart` to skip the auto-open. We
-// wipe it during restart so the post-restart probe only counts beacons that
-// arrive AFTER the new dashboard is up — i.e. from a still-living tab.
+// 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
+// only counts beacons that arrive AFTER the new dashboard is up.
 function _clearDashboardBrowserState(minionsHome) {
-  try {
-    const fp = path.join(minionsHome, 'engine', 'dashboard-browser.json');
-    fs.writeFileSync(fp, JSON.stringify({ tabs: {}, updatedAt: new Date().toISOString() }));
-  } catch {}
+  // Atomic write so the new dashboard can't read a torn file mid-write.
+  shared.safeWrite(
+    path.join(minionsHome, 'engine', 'dashboard-browser.json'),
+    { tabs: {}, updatedAt: new Date().toISOString() },
+  );
 }
 
 async function _waitForBrowserReconnect(minionsHome, { afterMs, timeoutMs = 5000, pollMs = 500 } = {}) {
@@ -113,12 +101,9 @@ async function _waitForBrowserReconnect(minionsHome, { afterMs, timeoutMs = 5000
 }
 
 function _openInBrowser(url) {
-  try {
-    if (process.platform === 'win32') execSync(`start "" "${url}"`, { stdio: 'ignore', windowsHide: true });
-    else if (process.platform === 'darwin') execSync(`open "${url}"`, { stdio: 'ignore' });
-    else execSync(`xdg-open "${url}"`, { stdio: 'ignore' });
-  } catch (e) {
-    console.log(`  Could not auto-open browser: ${e.message}`);
+  const result = openUrlInBrowser(url);
+  if (!result.ok) {
+    console.log(`  Could not auto-open browser: ${result.error}`);
     console.log(`  Please open ${url} manually.`);
   }
 }
@@ -180,12 +165,10 @@ function killMinionsProcesses(patterns) {
   } catch {}
 }
 
-/** Spawn a detached dashboard. When `suppressOpen` is true, the new dashboard
- *  skips its auto-open of the browser — the existing tab will reconnect. */
-function spawnDashboard(suppressOpen) {
-  const env = { ...process.env };
-  if (suppressOpen) env.MINIONS_NO_AUTO_OPEN = '1';
-  else delete env.MINIONS_NO_AUTO_OPEN;
+/** Spawn a detached dashboard with self-open suppressed — the CLI decides
+ *  when to open a browser based on whether a real tab reconnects post-health. */
+function spawnDashboard() {
+  const env = { ...process.env, MINIONS_NO_AUTO_OPEN: '1' };
   const proc = spawn(process.execPath, [path.join(MINIONS_HOME, 'dashboard.js')], {
     cwd: MINIONS_HOME, stdio: 'ignore', detached: true, windowsHide: true, env
   });
@@ -451,13 +434,12 @@ function init() {
   const dashWasUp = isPortListening(DASH_PORT);
   const restartStartMs = Date.now();
   if (isUpgrade) {
-    // Clear stale beacons so the post-restart probe only counts tabs that
-    // reconnect to the NEW dashboard.
-    _clearDashboardBrowserState(MINIONS_HOME);
     try { execSync(`node "${path.join(MINIONS_HOME, 'engine.js')}" stop`, { stdio: 'ignore', cwd: MINIONS_HOME, timeout: 10000, windowsHide: true }); } catch {}
     // Free the dashboard port too — without this the new dashboard EADDRINUSE-dies
     // silently and the user keeps running stale code from the old dashboard process.
     killByPort(DASH_PORT);
+    // Clear AFTER kill so the old dashboard can't repopulate during shutdown.
+    _clearDashboardBrowserState(MINIONS_HOME);
   }
   console.log(isUpgrade
     ? `\n  Upgrade complete (${pkgVersion}). Restarting engine and dashboard...\n`
@@ -468,27 +450,20 @@ function init() {
   engineProc.unref();
   console.log(`  Engine started (PID: ${engineProc.pid})`);
 
-  // Always suppress dashboard's self-open — we decide here after the health
-  // check based on whether an existing browser tab actually reconnects.
-  const dashProc = spawnDashboard(true);
+  const dashProc = spawnDashboard();
   console.log(`  Dashboard started (PID: ${dashProc.pid})`);
   console.log(`  Dashboard: http://localhost:${DASH_PORT}`);
 
   void (async () => {
-    let shouldOpen = forceOpen || !dashWasUp;
-    if (!shouldOpen) {
-      // Hot upgrade: give an existing browser tab up to 5s to reconnect via
-      // its 4s auto-refresh poll. If nothing beacons, the tab is gone — open.
-      const reconnected = await _waitForBrowserReconnect(MINIONS_HOME, {
-        afterMs: restartStartMs, timeoutMs: 5000,
-      });
-      shouldOpen = !reconnected;
-    }
+    const shouldOpen = forceOpen || !dashWasUp ||
+      !(await _waitForBrowserReconnect(MINIONS_HOME, { afterMs: restartStartMs, timeoutMs: 5000 }));
     if (shouldOpen) {
       console.log(`  Opening dashboard in browser...`);
       _openInBrowser(`http://localhost:${DASH_PORT}`);
     }
-  })();
+  })().catch(err => {
+    console.log(`  Could not open dashboard: ${err.message}`);
+  });
 
   // Next steps guidance
   console.log(`
@@ -740,36 +715,30 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
 } else if (cmd === 'add' || cmd === 'remove' || cmd === 'list' || cmd === 'scan') {
   delegate('minions.js', [cmd, ...rest]);
 } else if (cmd === 'restart') {
-  // Start both engine and dashboard — the go-to command after a reboot.
   // `--cli` / `--model` flags forward to `engine.js start` so the runtime
   // fleet flips before the daemon spawns (P-6b3f9c2e AC: works on restart).
   ensureInstalled();
   const dashWasUp = isPortListening(DASH_PORT);
-  // Mark the restart boundary so post-restart beacon timestamps are unambiguous,
-  // and clear stale beacons (browsers that closed without notifying).
   const restartStartMs = Date.now();
-  _clearDashboardBrowserState(MINIONS_HOME);
-  // Layered kill — each step is best-effort, layered so the next still runs if
-  // one fails. Goal: the old engine is gone before we spawn a new one, even if
+  // Layered kill — each step is best-effort, so the next still runs if one
+  // fails. Goal: the old engine is gone before we spawn a new one, even if
   // PowerShell is unavailable, the engine is hung, or its cmdline doesn't match.
   const oldEnginePid = readEnginePid(MINIONS_HOME);
-  // 1. Graceful stop — short timeout so a hung engine can't block what follows.
   try { execSync(`node "${path.join(MINIONS_HOME, 'engine.js')}" stop`, { stdio: 'ignore', cwd: MINIONS_HOME, timeout: 10000, windowsHide: true }); } catch {}
-  // 2. Force-kill the recorded engine PID (NOT the tree — agent children must
-  //    survive so the new engine can re-attach them via PID files).
+  // Force-kill the recorded engine PID (NOT the tree — agent children must
+  // survive so the new engine can re-attach them via PID files).
   killPidOnly(oldEnginePid);
-  // 3. Free dashboard port (catches orphan dashboards with no recorded PID).
   killByPort(DASH_PORT);
-  // 4. Belt-and-suspenders cmdline match for anything still alive.
   killMinionsProcesses(['engine.js', 'dashboard.js']);
+  // 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);
   const engineProc = spawn(process.execPath, [path.join(MINIONS_HOME, 'engine.js'), 'start', ...rest], {
     cwd: MINIONS_HOME, stdio: 'ignore', detached: true, windowsHide: true
   });
   engineProc.unref();
   console.log(`\n  Engine started (PID: ${engineProc.pid})`);
-  // Always tell the dashboard to skip its own auto-open — we'll decide here
-  // after observing whether an existing browser tab reconnects.
-  const dashProc = spawnDashboard(true);
+  const dashProc = spawnDashboard();
   console.log(`  Dashboard started (PID: ${dashProc.pid})`);
   console.log(`  Dashboard: http://localhost:${DASH_PORT}`);
   console.log('  Verifying restart health...');
@@ -784,21 +753,17 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
     }
     console.log(`  Restart verified: engine PID ${result.engine.pid}; dashboard healthy.`);
 
-    let shouldOpen = forceOpen || !dashWasUp;
-    if (!shouldOpen) {
-      const reconnected = await _waitForBrowserReconnect(MINIONS_HOME, {
-        afterMs: restartStartMs, timeoutMs: 5000,
-      });
-      shouldOpen = !reconnected;
-    }
+    const shouldOpen = forceOpen || !dashWasUp ||
+      !(await _waitForBrowserReconnect(MINIONS_HOME, { afterMs: restartStartMs, timeoutMs: 5000 }));
     if (shouldOpen) {
       console.log(`  Opening dashboard in browser...`);
       _openInBrowser(`http://localhost:${DASH_PORT}`);
     }
     console.log('');
   })().catch(err => {
-    console.error(`\n  ERROR: Restart verification failed: ${err.message}\n`);
-    process.exit(1);
+    // Health check failures already process.exit(1) above; reaching here means
+    // the browser-open path threw, which is non-fatal — restart already verified.
+    console.log(`  Could not open dashboard: ${err.message}`);
   });
 } else if (cmd === 'nuke') {
   ensureInstalled();
@@ -967,10 +932,7 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
     handled = true;
     const url = `http://localhost:${DASH_PORT}`;
     console.log(`\n  Dashboard already running: ${url}\n`);
-    try {
-      const openCmd = process.platform === 'win32' ? `start ${url}` : process.platform === 'darwin' ? `open ${url}` : `xdg-open ${url}`;
-      execSync(openCmd, { stdio: 'ignore', windowsHide: true });
-    } catch {}
+    openUrlInBrowser(url);
   });
   sock.on('error', () => {
     sock.destroy();

package/dashboard.js

@@ -9422,20 +9422,12 @@ if (require.main === module) {
     console.log(`\n  Auto-refreshes every 4s. Ctrl+C to stop.\n`);
 
     // Auto-open the browser unless suppressed. `minions restart` and the
-    // upgrade path set MINIONS_NO_AUTO_OPEN=1 only when a browser tab was
-    // recently polling the old dashboard, so a new tab would just be a duplicate.
+    // upgrade path set MINIONS_NO_AUTO_OPEN=1 because the CLI orchestrates the
+    // open itself after observing whether an existing tab reconnected.
     if (!process.env.MINIONS_NO_AUTO_OPEN) {
-      const { exec } = require('child_process');
-      try {
-        if (process.platform === 'win32') {
-          exec(`start "" "http://localhost:${PORT}"`);
-        } else if (process.platform === 'darwin') {
-          exec(`open http://localhost:${PORT}`);
-        } else {
-          exec(`xdg-open http://localhost:${PORT}`);
-        }
-      } catch (e) {
-        console.log(`  Could not auto-open browser: ${e.message}`);
+      const result = shared.openUrlInBrowser(`http://localhost:${PORT}`);
+      if (!result.ok) {
+        console.log(`  Could not auto-open browser: ${result.error}`);
         console.log(`  Please open http://localhost:${PORT} manually.`);
       }
     }

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-09T22:56:52.587Z"
+  "cachedAt": "2026-05-09T23:11:31.200Z"
 }

package/engine/shared.js

@@ -251,6 +251,21 @@ function resolveEngineCacheDir(fallbackEngineDir) {
   return fallbackEngineDir;
 }
 
+// Cross-platform URL opener. Uses execSync so failures fall through the
+// try/catch and the caller sees them. Dashboard self-open and `minions dash`
+// / `minions restart` post-health open all funnel through here.
+function openUrlInBrowser(url) {
+  const { execSync } = require('child_process');
+  try {
+    if (process.platform === 'win32') execSync(`start "" "${url}"`, { stdio: 'ignore', windowsHide: true });
+    else if (process.platform === 'darwin') execSync(`open "${url}"`, { stdio: 'ignore' });
+    else execSync(`xdg-open "${url}"`, { stdio: 'ignore' });
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: e && e.message ? e.message : String(e) };
+  }
+}
+
 function _flushLogBuffer() {
   if (_logBuffer.length === 0) return;
   const drained = _logBuffer.splice(0);
@@ -3380,6 +3395,7 @@ module.exports = {
   MINIONS_DIR,
   ENGINE_DIR,
   resolveEngineCacheDir,
+  openUrlInBrowser,
   CONTROL_PATH,
   COOLDOWNS_PATH,
   PR_LINKS_PATH,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.1826",
+  "version": "0.1.1828",
   "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"