nothumanallowed 15.1.8 → 15.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "15.1.8",
+  "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.8';
+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

@@ -88,80 +88,182 @@ export function register(router) {
   });
 
   // POST /api/npm-update
+  //
+  // Two-phase update:
+  //   1. Sync part: run `npm install -g nothumanallowed@latest --prefer-online`
+  //      with cache bypass. Bypass is critical — without --prefer-online, npm
+  //      can install the same version it had cached locally and the user sees
+  //      "nothing changed" (the classic stale-manifest trap).
+  //   2. Async part: spawn a DETACHED helper that watches our PID, waits until
+  //      we exit, sleeps 1 s so the port frees, then re-spawns this process
+  //      with the SAME argv. The newly installed code runs because node will
+  //      re-read the entry script from disk on the next invocation.
+  //
+  // The response is sent BEFORE the parent exits, so the client knows what
+  // version to expect and can poll /api/health for the restart to complete.
   router.post('/api/npm-update', async (req, res) => {
     try {
-      const { exec } = await import('child_process');
+      const { exec, spawn } = await import('child_process');
       const { promisify } = await import('util');
       const execAsync = promisify(exec);
 
-      // Detect the package manager and global prefix to handle permissions correctly
-      let cmd = 'npm install -g nothumanallowed@latest';
-
-      // On macOS/Linux, check if we need special handling for permission
+      // Permission preflight on POSIX
       if (process.platform !== 'win32') {
         try {
-          // Check if npm global dir is writable by current user
           const { stdout: prefix } = await execAsync('npm config get prefix', { timeout: 5000 });
           const globalDir = prefix.trim();
           await fs.promises.access(path.join(globalDir, 'lib'), fs.constants.W_OK);
         } catch {
-          // Global dir not writable — return error with clear instructions
           sendJSON(res, 200, {
             success: false,
             error: 'EACCES: permission denied',
-            message: 'Permission denied. Run: sudo npm install -g nothumanallowed@latest'
+            message: 'Permission denied. Run: sudo npm install -g nothumanallowed@latest --prefer-online',
           });
           return;
         }
       }
 
+      // Clean the metadata cache first — defeats the stale-cache trap that
+      // makes `npm install -g <pkg>` silently install an older version.
+      try { await execAsync('npm cache clean --force', { timeout: 10_000 }); } catch { /* non-fatal */ }
+
+      const cmd = 'npm install -g nothumanallowed@latest --registry=https://registry.npmjs.org/ --prefer-online --no-fund --no-audit';
       const { stdout, stderr } = await execAsync(cmd, {
         timeout: 120_000,
         env: { ...process.env, NODE_ENV: 'production' },
       });
 
-      // Get the installed version from npm output or registry
+      // Resolve the version that actually landed on disk
       let newVersion = '';
       try {
-        // Extract version from npm install output (e.g. "+ nothumanallowed@14.4.18")
         const verMatch = stdout.match(/nothumanallowed@(\d+\.\d+\.\d+)/);
         if (verMatch) {
           newVersion = verMatch[1];
         } else {
-          // Fallback: check registry
           const regResp = await fetch('https://registry.npmjs.org/nothumanallowed/latest');
           const regData = await regResp.json();
           newVersion = regData.version || '';
         }
       } catch { /* ignore */ }
 
-      // Restart ops daemon if running (so Telegram/Discord 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()) {
+          daemonWasRunning = true;
           await stopDaemon();
-          const { execSync: ex2 } = await import('child_process');
-          try { ex2('nha ops start', { timeout: 10_000, stdio: 'ignore' }); } catch {}
         }
-      } catch {}
+      } catch { /* ignore */ }
 
+      // Send the response NOW, before we kick off the restart. The client
+      // needs this payload to know what version to wait for during polling.
       sendJSON(res, 200, {
         success: true,
-        message: newVersion ? `Updated to v${newVersion}! Restart the server to apply.` : 'Update completed',
+        message: newVersion ? `Updated to v${newVersion}. Restarting server...` : 'Update completed. Restarting...',
         newVersion,
-        restart: false, // Do NOT auto-restart — it never works reliably
-        needsManualRestart: true,
-        stdout: stdout.trim(),
-        stderr: stderr.trim()
+        restart: true,
+        restarting: true,
+        needsManualRestart: false,
+        stdout: stdout.trim().slice(-2000),
+        stderr: stderr.trim().slice(-2000),
       });
+
+      // ── Schedule the self-restart ──
+      const parentPid = process.pid;
+      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: 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: 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
+              # 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: childStdio,
+            }).unref();
+          }
+        } catch { /* spawn failed — user will need to restart manually */ }
+
+        setTimeout(() => process.exit(0), 200);
+      }, 600);
     } catch (e) {
       const isPermission = e.message?.includes('EACCES') || e.message?.includes('permission denied');
       sendJSON(res, 200, {
         success: false,
         error: isPermission ? 'EACCES: permission denied' : e.message,
         message: isPermission
-          ? 'Permission denied. Run: sudo npm install -g nothumanallowed@latest'
-          : 'Update failed. Try running: npm install -g nothumanallowed@latest'
+          ? 'Permission denied. Run: sudo npm install -g nothumanallowed@latest --prefer-online'
+          : `Update failed: ${e.message}. Try manually: npm cache clean --force && npm install -g nothumanallowed@latest --prefer-online`,
       });
     }
   });