nothumanallowed 15.1.9 → 15.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "15.1.9",
+  "version": "15.1.10",
   "description": "NotHumanAllowed — 38 AI agents, 80 tools, Studio (visual agentic workflows). Email, calendar, browser automation, screen capture, canvas, cron/heartbeat, Alexandria E2E messaging, GitHub, Notion, Slack, voice chat, free AI (Liara), 28 languages. Zero-dependency CLI.",
   "type": "module",
   "bin": {

package/src/commands/ui.mjs

@@ -84,11 +84,42 @@ export async function cmdUI(args) {
     }
   } catch { /* port is free */ }
 
-  // Auto-start ops daemon (Telegram + cron) if not already running
+  // Detect if we were spawned by the self-restart helper after an npm-update.
+  // The marker file is written by /api/npm-update right before exiting.
+  // This lets us:
+  //   - confirm to the user that the upgrade landed (visible in the boot log)
+  //   - guarantee the ops daemon (Telegram/Discord bot) is back up
+  let restartedFromUpdate = false;
+  try {
+    const fs = await import('fs');
+    const path = await import('path');
+    const os = await import('os');
+    const markerPath = path.join(os.default.homedir(), '.nha', 'last-restart.json');
+    if (fs.existsSync(markerPath)) {
+      const stat = fs.statSync(markerPath);
+      // Consider the marker fresh only if written within the last 5 minutes
+      if (Date.now() - stat.mtimeMs < 5 * 60_000) {
+        const meta = JSON.parse(fs.readFileSync(markerPath, 'utf-8'));
+        restartedFromUpdate = true;
+        console.log(`  \x1b[0;32m↻\x1b[0m Restarted after update: v${meta.fromVersion} → v${meta.toVersion}`);
+      }
+      // Always clean up so we don't repeat the message on next manual restart
+      try { fs.unlinkSync(markerPath); } catch {}
+    }
+  } catch { /* non-fatal */ }
+
+  // Auto-start ops daemon (Telegram + cron) if not already running.
+  // After a self-restart this is what brings the Telegram bot back online —
+  // critical for VM users whose only control channel is Telegram.
   if (!isRunning()) {
     const result = startDaemon();
     if (result.ok) {
-      console.log(`  \x1b[0;32m✓\x1b[0m PAO daemon started (PID ${result.pid})`);
+      console.log(`  \x1b[0;32m✓\x1b[0m PAO daemon ${restartedFromUpdate ? 'restarted' : 'started'} (PID ${result.pid})`);
+    } else {
+      console.log(`  \x1b[0;31m✗\x1b[0m PAO daemon failed to start: ${result.error || 'unknown'}`);
+      if (restartedFromUpdate) {
+        console.log(`    Telegram/Discord bot may be offline. Run "nha ops start" manually.`);
+      }
     }
   }
 

package/src/constants.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export const VERSION = '15.1.9';
+export const VERSION = '15.1.10';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/server/index.mjs

@@ -376,15 +376,40 @@ export async function startServer({ port = 3847, host = '127.0.0.1', noBrowser =
 
   const server = http.createServer(handleRequest);
 
-  // Attach WebSocket AFTER HTTP server is listening to avoid WS error events
-  await new Promise((resolve, reject) => {
-    server.once('error', reject);
+  // Retry the bind for up to 12 s on EADDRINUSE. The classic case is a fresh
+  // self-restart right after the previous process died: the listen socket can
+  // be stuck in TIME_WAIT (no PID owns it, so the lsof-kill above can't help).
+  // Linear backoff 600 ms × 20 = 12 s — more than enough on every kernel I've
+  // seen for a localhost listen socket to clear.
+  const tryListen = () => new Promise((resolve, reject) => {
+    const onErr = (err) => reject(err);
+    server.once('error', onErr);
     server.listen(port, host, () => {
-      server.removeListener('error', reject);
+      server.removeListener('error', onErr);
       resolve(undefined);
     });
   });
 
+  let listenAttempts = 0;
+  const MAX_LISTEN_ATTEMPTS = 20;
+  while (true) {
+    try {
+      await tryListen();
+      break;
+    } catch (err) {
+      listenAttempts++;
+      const isAddrInUse = err && (err.code === 'EADDRINUSE' || err.code === 'EACCES');
+      if (!isAddrInUse || listenAttempts >= MAX_LISTEN_ATTEMPTS) {
+        throw err;
+      }
+      // Brief notice every 3 s so the user knows we're not stuck
+      if (listenAttempts % 5 === 0) {
+        console.log(`\x1b[33m  ! Port ${port} still busy (TIME_WAIT?), retry ${listenAttempts}/${MAX_LISTEN_ATTEMPTS}...\x1b[0m`);
+      }
+      await new Promise((r) => setTimeout(r, 600));
+    }
+  }
+
   setupWebSocket(server);
 
   const G = '\x1b[0;32m', NC = '\x1b[0m', D = '\x1b[2m', BOLD = '\x1b[1m', Y = '\x1b[33m', R = '\x1b[31m';

package/src/server/routes/config.mjs

@@ -146,10 +146,17 @@ export function register(router) {
         }
       } catch { /* ignore */ }
 
-      // Stop the ops daemon if it's running — it must reconnect with new code
+      // Remember if the ops daemon (Telegram/Discord bot) was running so the
+      // newly-spawned server can restart it. Without this, a VM user who
+      // controls everything via Telegram would lose the bot until they ran
+      // `nha ops start` manually.
+      let daemonWasRunning = false;
       try {
         const { isRunning, stopDaemon } = await import('../../services/ops-daemon.mjs');
-        if (isRunning()) await stopDaemon();
+        if (isRunning()) {
+          daemonWasRunning = true;
+          await stopDaemon();
+        }
       } catch { /* ignore */ }
 
       // Send the response NOW, before we kick off the restart. The client
@@ -166,62 +173,87 @@ export function register(router) {
       });
 
       // ── Schedule the self-restart ──
-      // We do this OUTSIDE the response cycle: a detached child that survives
-      // our death, watches our PID, then re-spawns with the same argv.
-      // On POSIX we use `sh -c`. On Windows we use a detached spawn directly
-      // because cmd.exe handles the "wait for PID" idiom differently.
       const parentPid = process.pid;
-      const respawnNode = process.execPath;             // absolute path to node
-      const respawnArgs = process.argv.slice(1);        // [cli.mjs, "ui", ...]
-      const argvJson = JSON.stringify({ node: respawnNode, args: respawnArgs, parentPid });
+      const respawnNode = process.execPath;
+      const respawnArgs = process.argv.slice(1);
+      const home = os.homedir();
+      const nhaDir = path.join(home, '.nha');
+      if (!fs.existsSync(nhaDir)) fs.mkdirSync(nhaDir, { recursive: true });
+
+      // Write the restart marker BEFORE spawning the helper. The new server
+      // reads this on boot to know:
+      //   - the update happened (so it can show "Updated to v…" on first load)
+      //   - whether the ops daemon (Telegram bot) was running and must be restarted
+      const markerPath = path.join(nhaDir, 'last-restart.json');
+      try {
+        fs.writeFileSync(
+          markerPath,
+          JSON.stringify({
+            at: new Date().toISOString(),
+            fromVersion: VERSION,
+            toVersion: newVersion,
+            daemonWasRunning,
+            parentPid,
+          }, null, 2),
+        );
+      } catch { /* non-fatal */ }
+
+      // Open log file for the detached child — if anything goes wrong on boot
+      // we want the user to be able to read why instead of staring at a black
+      // screen. Append mode so previous restart logs survive.
+      const logPath = path.join(nhaDir, 'server.log');
+      let logFd;
+      try {
+        logFd = fs.openSync(logPath, 'a');
+        fs.writeSync(logFd, `\n[${new Date().toISOString()}] === Restart helper spawning. Parent PID: ${parentPid}. Target version: ${newVersion} ===\n`);
+      } catch { /* will fall back to 'ignore' */ }
 
       setTimeout(() => {
         try {
           if (process.platform === 'win32') {
-            // Windows: schedule via PowerShell — wait-process then start the new node.
-            const psScript = `
-              try { Wait-Process -Id ${parentPid} -Timeout 30 } catch {};
-              Start-Sleep -Milliseconds 1200;
-              Start-Process -FilePath "${respawnNode.replace(/\\/g, '\\\\')}" -ArgumentList ${JSON.stringify(respawnArgs).replace(/"/g, '\\"')} -WindowStyle Hidden
-            `.replace(/\s+/g, ' ').trim();
+            // Windows: PowerShell waits for the parent to die, frees the port,
+            // then starts node hidden. Output is redirected to server.log.
+            const psScript = [
+              `try { Wait-Process -Id ${parentPid} -Timeout 30 } catch {};`,
+              `Start-Sleep -Milliseconds 1500;`,
+              `$logPath = "${logPath.replace(/\\/g, '\\\\')}";`,
+              `Start-Process -FilePath "${respawnNode.replace(/\\/g, '\\\\')}"`,
+              ` -ArgumentList ${JSON.stringify(respawnArgs).replace(/"/g, '\\"')}`,
+              ` -RedirectStandardOutput $logPath -RedirectStandardError $logPath`,
+              ` -WindowStyle Hidden`,
+            ].join('').replace(/\s+/g, ' ').trim();
             spawn('powershell.exe', ['-NoProfile', '-Command', psScript], {
               detached: true,
               stdio: 'ignore',
               windowsHide: true,
             }).unref();
           } else {
-            // POSIX: shell loop that polls `kill -0 PID`, then re-exec the cmd.
-            // Using exec replaces the shell process so we don't leave a wrapper.
-            const escapedArgs = respawnArgs.map(a => `'${a.replace(/'/g, `'\\''`)}'`).join(' ');
-            const escapedNode = `'${respawnNode.replace(/'/g, `'\\''`)}'`;
+            // POSIX: poll for parent death (max ~12s), then wait an extra 2s
+            // for TIME_WAIT to clear on the listen socket, then exec node
+            // with stdio redirected to the log file.
+            const escArg = a => `'${a.replace(/'/g, `'\\''`)}'`;
+            const escapedArgs = respawnArgs.map(escArg).join(' ');
+            const escapedNode = escArg(respawnNode);
+            const escapedLog = escArg(logPath);
             const sh = `
               i=0
               while kill -0 ${parentPid} 2>/dev/null && [ $i -lt 60 ]; do
                 sleep 0.2
                 i=$((i+1))
               done
-              sleep 1
-              exec ${escapedNode} ${escapedArgs}
+              # Extra wait: lets TIME_WAIT on the listen socket release and
+              # gives the kernel a moment to fully reap the parent.
+              sleep 2
+              exec ${escapedNode} ${escapedArgs} >> ${escapedLog} 2>&1
             `;
+            const childStdio = logFd ? ['ignore', logFd, logFd] : 'ignore';
             spawn('sh', ['-c', sh], {
               detached: true,
-              stdio: 'ignore',
+              stdio: childStdio,
             }).unref();
           }
-
-          // Mark the restart so the next process knows it was self-spawned
-          try {
-            const home = os.homedir();
-            const nhaDir = path.join(home, '.nha');
-            if (!fs.existsSync(nhaDir)) fs.mkdirSync(nhaDir, { recursive: true });
-            fs.writeFileSync(
-              path.join(nhaDir, 'last-restart.json'),
-              JSON.stringify({ at: new Date().toISOString(), fromVersion: VERSION, toVersion: newVersion, meta: argvJson }, null, 2),
-            );
-          } catch { /* non-fatal */ }
         } catch { /* spawn failed — user will need to restart manually */ }
 
-        // Give the response a moment, then exit so the helper can take over.
         setTimeout(() => process.exit(0), 200);
       }, 600);
     } catch (e) {