bloby-bot 0.67.0 → 0.68.0

package/bin/cli.js

@@ -194,11 +194,57 @@ const GLYPH = {
 };
 const DIVIDER = `  ${c.dim}${'─'.repeat(29)}${c.reset}`;
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const BAR_WIDTH = 30;
 
 function link(url) {
   return isTTY && useColor ? `\x1b]8;;${url}\x07${url}\x1b]8;;\x07` : url;
 }
 
+function stripAnsi(s) {
+  // SGR colors + OSC-8 hyperlinks — needed to measure visible width for boxes.
+  return s.replace(/\x1b\[[0-9;]*m/g, '').replace(/\x1b\]8;;.*?(\x07|\x1b\\)/g, '');
+}
+
+// Morphy gradient #00ADFE → #0158FB across the progress bar (matches the logo).
+function gradientChar(i, total) {
+  if (!useColor) return '';
+  const t = total > 1 ? i / (total - 1) : 0;
+  const r = Math.round(0 + t * 1);
+  const g = Math.round(173 + t * (88 - 173));
+  const b = Math.round(254 + t * (251 - 254));
+  return `\x1b[38;2;${r};${g};${b}m`;
+}
+
+function progressBar(ratio, width = BAR_WIDTH) {
+  const filled = Math.round(Math.max(0, Math.min(1, ratio)) * width);
+  let bar = '';
+  for (let i = 0; i < filled; i++) bar += `${gradientChar(i, width)}█`;
+  bar += `${c.reset}${c.dim}${'░'.repeat(width - filled)}${c.reset}`;
+  return bar;
+}
+
+/** The final state of a command ("Bloby is running", "Bloby stopped") gets a box —
+ *  it's the one thing the user came for, so it must be unmissable. Pipes get the
+ *  content as plain lines. */
+function resultBox(lines) {
+  if (!isTTY) {
+    for (const l of lines) {
+      const plain = stripAnsi(l);
+      console.log(plain.trim() ? `  ${l}` : '');
+    }
+    return;
+  }
+  const width = Math.max(...lines.map(l => stripAnsi(l).length)) + 4;
+  const B = c.blue;
+  console.log('');
+  console.log(`  ${B}╭${'─'.repeat(width)}╮${c.reset}`);
+  for (const l of lines) {
+    const pad = width - 2 - stripAnsi(l).length;
+    console.log(`  ${B}│${c.reset} ${l}${' '.repeat(Math.max(0, pad))} ${B}│${c.reset}`);
+  }
+  console.log(`  ${B}╰${'─'.repeat(width)}╯${c.reset}`);
+}
+
 // Single terminal-cleanup path: restore cursor + raw mode, stop any spinner.
 // Registered once; every exit route (normal, SIGINT, SIGTERM, crash) goes through it.
 let activeSpinner = null;
@@ -270,6 +316,159 @@ class Spinner {
   info(text)    { this.stopRaw(); console.log(`  ${c.dim}${text ?? this.text}${c.reset}`); return this; }
 }
 
+/** Multi-step progress display for start/restart/update — step list + gradient
+ *  progress bar, repainted in place (the old "stepper", rebuilt on safe footing):
+ *  TTY-gated (plain sequential lines on pipes, so update.log stays readable),
+ *  a real fail() state instead of an all-green finish, pause()/resume() so a
+ *  sudo password prompt isn't erased by the repaint, and no stdin raw-mode grabs.
+ *  Exposes the same update/pause/resume/stopRaw surface as Spinner so
+ *  runPrivileged/ensureCloudflared work with either. */
+class Steps {
+  constructor(titles) {
+    this.titles = [...titles];
+    this.current = 0;
+    this.frame = 0;
+    this.timer = null;
+    this.notes = [];
+    this._lines = 0;
+    this.live = false;
+    this.done = false;
+    this._failed = false;
+    this._printedNotes = new Set();
+  }
+  start() {
+    console.log('');
+    if (fancyTTY) {
+      activeSpinner = this;
+      this.live = true;
+      process.stdout.write('\x1b[?25l');
+      this.timer = setInterval(() => {
+        this.frame = (this.frame + 1) % SPINNER_FRAMES.length;
+        this.render();
+      }, 80);
+      this.render();
+    } else if (this.titles.length) {
+      console.log(`  …  ${this.titles[0]}`);
+    }
+    return this;
+  }
+  render() {
+    if (!this.live) return;
+    let out = '';
+    if (this._lines > 0) out += `\x1b[${this._lines}A`;
+    const W = (s = '') => { out += `\x1b[2K${s}\n`; };
+    for (let i = 0; i < this.titles.length; i++) {
+      if (i < this.current) W(`  ${GLYPH.ok}  ${this.titles[i]}`);
+      else if (i === this.current && this._failed) W(`  ${GLYPH.err}  ${this.titles[i]}`);
+      else if (i === this.current && !this.done) W(`  ${c.pink}${SPINNER_FRAMES[this.frame]}${c.reset}  ${this.titles[i]}${c.dim}...${c.reset}`);
+      else W(`  ${c.dim}○  ${this.titles[i]}${c.reset}`);
+    }
+    const ratio = this.current / this.titles.length;
+    W();
+    const label = ratio >= 1 ? `${c.pink}Done${c.reset}` : `${c.dim}${Math.round(ratio * 100)}%${c.reset}`;
+    W(`  ${progressBar(ratio)}  ${label}`);
+    let count = this.titles.length + 2;
+    if (this.notes.length) {
+      W();
+      for (const n of this.notes) W(n);
+      count += 1 + this.notes.length;
+    }
+    if (count < this._lines) {
+      const extra = this._lines - count;
+      for (let i = 0; i < extra; i++) out += '\x1b[2K\n';
+      out += `\x1b[${extra}A`;
+    }
+    process.stdout.write(out);
+    this._lines = count;
+  }
+  advance() {
+    if (this.current >= this.titles.length) return this;
+    if (!this.live) {
+      console.log(`  ${GLYPH.ok}  ${this.titles[this.current]}`);
+      this.current++;
+      if (this.current < this.titles.length) console.log(`  …  ${this.titles[this.current]}`);
+      return this;
+    }
+    this.current++;
+    this.render();
+    return this;
+  }
+  setNote(lines) {
+    const arr = lines || [];
+    if (!this.live) {
+      for (const n of arr) {
+        const key = stripAnsi(n);
+        if (!this._printedNotes.has(key)) { this._printedNotes.add(key); console.log(n); }
+      }
+      this.notes = arr;
+      return this;
+    }
+    this.notes = arr;
+    this.render();
+    return this;
+  }
+  /** Spinner-compat: transient sub-status (cloudflared download, sudo notice). */
+  update(text) { return this.setNote(text ? [`  ${c.dim}${text}${c.reset}`] : []); }
+  pause() {
+    if (this.live) { this._paused = true; this._stop(); }
+    return this;
+  }
+  resume() {
+    if (this._paused && fancyTTY && !this.done) {
+      this._paused = false;
+      this.live = true;
+      activeSpinner = this;
+      process.stdout.write('\x1b[?25l');
+      this._lines = 0; // repaint fresh below whatever the pause printed
+      this.timer = setInterval(() => {
+        this.frame = (this.frame + 1) % SPINNER_FRAMES.length;
+        this.render();
+      }, 80);
+      this.render();
+    }
+    return this;
+  }
+  _stop() {
+    if (this.timer) { clearInterval(this.timer); this.timer = null; }
+    if (this.live) {
+      process.stdout.write('\x1b[?25h');
+      this.live = false;
+    }
+    if (activeSpinner === this) activeSpinner = null;
+  }
+  stopRaw() { this._stop(); }
+  finish() {
+    this.notes = [];
+    if (this.live) {
+      this.current = this.titles.length;
+      this.done = true;
+      this.render();
+      // render() guards on live, so flip done before the final paint above, then stop.
+      this._stop();
+    } else {
+      while (this.current < this.titles.length) {
+        console.log(`  ${GLYPH.ok}  ${this.titles[this.current]}`);
+        this.current++;
+      }
+      this.done = true;
+    }
+    return this;
+  }
+  fail(message) {
+    this.notes = [];
+    this._failed = true;
+    if (this.live) {
+      this.render();
+      this._stop();
+    } else if (this.current < this.titles.length) {
+      console.log(`  ${GLYPH.err}  ${this.titles[this.current]}`);
+    }
+    this.done = true;
+    if (message) console.log(`\n  ${GLYPH.err}  ${message}`);
+    return this;
+  }
+}
+
 function banner() {
   if (HOSTED) return;
   console.log(`
@@ -846,40 +1045,130 @@ async function killStraySupervisors({ exceptPid = null } = {}) {
 }
 
 // ── Readiness wait ──
-// Replaces the old launchd-log-offset __READY__ grep with portable signals that
-// work identically on macOS/Linux: the supervisor pidfile, /api/health, and the
-// tunnelUrl the supervisor writes back into config.json.
-
-async function waitForReady({ sinceMs, oldTunnelUrl, wantTunnel, tunnelMode, spinner, timeoutMs = 90_000 }) {
+// Drives the Steps display through: server up (/api/health + pidfile) →
+// tunnel connected (config.tunnelUrl writeback / __TUNNEL_URL__) → connection
+// verified (__READY__, which the supervisor emits only AFTER registering the
+// tunnel with the relay — that's the moment the user's real URL actually works,
+// and it's the signal the old battle-tested stepper waited for).
+// Markers are read from the launchd log via byte offset on macOS (rotation only
+// ever happens while the job is stopped, so the offset is stable) and from
+// journalctl --since on Linux (best-effort: falls back to health+tunnel when
+// the journal isn't readable).
+
+function formatJournalTime(date) {
+  const p = (n) => String(n).padStart(2, '0');
+  return `${date.getFullYear()}-${p(date.getMonth() + 1)}-${p(date.getDate())} ${p(date.getHours())}:${p(date.getMinutes())}:${p(date.getSeconds())}`;
+}
+
+async function waitForReady({ sinceMs, oldTunnelUrl, tunnelMode, ui, logOffset = 0, timeoutMs = 150_000 }) {
+  const U = ui ?? { advance() {}, setNote() {}, update() {} };
   const config = readConfig() || {};
   const port = config.port || 7400;
   const relayUrl = config.relay?.url || null;
+  const wantTunnel = tunnelMode !== 'off';
+
   let healthy = false;
   let tunnelUrl = null;
+  let ready = false;        // __READY__ seen — relay registration verified
+  let verified = false;     // ready, or best-effort fallback when markers unavailable
+  let tunnelFailed = false;
+  let offset = logOffset;
+  let sawDaemonOutput = false;
+  let tunnelAt = 0;
+  let phase = 'server';     // server → tunnel → verify → done
+
   const deadline = Date.now() + timeoutMs;
-  // Interactive callers stop waiting on a slow tunnel after 60s (don't hold the
-  // terminal hostage); callers that passed a bigger budget (hosted provisioning)
-  // get the full window — a slow tunnel is not a failed tunnel.
-  const tunnelDeadline = Date.now() + (timeoutMs > 90_000 ? timeoutMs : Math.min(timeoutMs, 60_000));
+  // If no tunnel URL appears at all within this window while healthy, stop
+  // holding the terminal (a slow tunnel is reported, not waited on forever).
+  const tunnelDeadline = Date.now() + (timeoutMs > 150_000 ? timeoutMs : Math.min(timeoutMs, 90_000));
+  const sinceDate = new Date(sinceMs - 2000);
+
+  const readNewDaemonOutput = () => {
+    if (PLATFORM === 'darwin') {
+      try {
+        const size = fs.statSync(LAUNCHD_LOG).size;
+        if (size < offset) offset = 0; // file replaced/truncated underneath us
+        if (size > offset) {
+          const fd = fs.openSync(LAUNCHD_LOG, 'r');
+          const buf = Buffer.alloc(size - offset);
+          fs.readSync(fd, buf, 0, buf.length, offset);
+          fs.closeSync(fd);
+          offset = size;
+          return buf.toString('utf-8');
+        }
+      } catch {}
+      return '';
+    }
+    if (PLATFORM === 'linux') {
+      try {
+        const r = spawnSync('journalctl', ['-u', SERVICE_NAME, '--since', formatJournalTime(sinceDate), '-o', 'cat', '-q', '--no-pager'], { encoding: 'utf-8' });
+        return r.stdout || '';
+      } catch { return ''; }
+    }
+    return '';
+  };
 
   while (Date.now() < deadline) {
     if (!healthy) {
       const health = await fetchHealth(port, 2000);
       if (health) {
         healthy = true;
-        if (spinner && wantTunnel) spinner.update('Connecting tunnel...');
+        if (phase === 'server') {
+          U.advance();
+          phase = wantTunnel ? 'tunnel' : 'done';
+        }
       }
     }
+
+    const text = readNewDaemonOutput();
+    if (text) sawDaemonOutput = true;
+    if (text.includes('__TUNNEL_FAILED__')) tunnelFailed = true;
+    if (text.includes('__READY__')) { ready = true; verified = true; }
     if (wantTunnel && !tunnelUrl) {
-      const cfg = readConfig();
-      // Named tunnels keep a stable URL, so "changed since last run" never fires —
-      // accept any URL the supervisor wrote once it is healthy.
-      if (cfg?.tunnelUrl && (cfg.tunnelUrl !== oldTunnelUrl || (tunnelMode === 'named' && healthy))) {
-        tunnelUrl = cfg.tunnelUrl;
+      const m = text.match(/__TUNNEL_URL__=(\S+)/);
+      if (m) tunnelUrl = m[1];
+      if (!tunnelUrl) {
+        const cfg = readConfig();
+        // Named tunnels keep a stable URL, so "changed since last run" never
+        // fires — accept the supervisor's writeback once it is healthy.
+        if (cfg?.tunnelUrl && (cfg.tunnelUrl !== oldTunnelUrl || (tunnelMode === 'named' && healthy))) {
+          tunnelUrl = cfg.tunnelUrl;
+        }
       }
     }
-    if (healthy && (!wantTunnel || tunnelUrl)) break;
-    if (healthy && wantTunnel && Date.now() > tunnelDeadline) break; // healthy but tunnel slow — don't hold the terminal hostage
+
+    if (phase === 'tunnel' && tunnelUrl) {
+      U.advance();
+      phase = 'verify';
+      tunnelAt = Date.now();
+      if (relayUrl) {
+        U.setNote([
+          `  ${c.dim}Waiting for ${c.reset}${c.white}${relayUrl.replace('https://', '')}${c.reset}${c.dim} to become reachable (can take up to 2 min)${c.reset}`,
+          `  ${c.dim}In the meanwhile you can access:${c.reset} ${c.blue}${link(tunnelUrl)}${c.reset}`,
+        ]);
+      } else if (tunnelMode === 'named') {
+        U.setNote([`  ${c.dim}Verifying ${c.reset}${c.white}${tunnelUrl.replace('https://', '')}${c.reset}${c.dim}...${c.reset}`]);
+      }
+    }
+
+    if (phase === 'verify') {
+      if (ready) {
+        U.setNote([]);
+        U.advance();
+        phase = 'done';
+      } else if (PLATFORM === 'linux' && !sawDaemonOutput && healthy && tunnelUrl && Date.now() - tunnelAt > 10_000) {
+        // Journal not readable for this user — can't see __READY__. Healthy +
+        // tunnel up is the best signal available (matches the old Linux path).
+        verified = true;
+        U.setNote([]);
+        U.advance();
+        phase = 'done';
+      }
+    }
+
+    if (phase === 'done') break;
+    if (healthy && tunnelFailed) break;
+    if (healthy && wantTunnel && !tunnelUrl && Date.now() > tunnelDeadline) break;
     await new Promise(r => setTimeout(r, 1000));
   }
 
@@ -887,8 +1176,10 @@ async function waitForReady({ sinceMs, oldTunnelUrl, wantTunnel, tunnelMode, spi
   const cfg = readConfig() || {};
   return {
     healthy,
-    tunnelUrl: tunnelUrl || (wantTunnel && cfg.tunnelUrl !== oldTunnelUrl ? cfg.tunnelUrl : tunnelUrl),
+    tunnelUrl,
     relayUrl: cfg.relay?.url || relayUrl,
+    ready: verified,
+    tunnelFailed,
     runtime: readRuntime(),
     sinceMs,
   };
@@ -912,13 +1203,25 @@ function getNetworkUrls(port) {
   return urls;
 }
 
-function printReadyBlock({ healthy, tunnelUrl, relayUrl, port, tunnelMode }) {
-  console.log('');
+function printReadyBlock({ healthy, ready, tunnelFailed, tunnelUrl, relayUrl, port, tunnelMode }) {
+  // The user's real URL is the relay handle (or named domain) — nobody types the
+  // random trycloudflare address. Lead with it, inside the result box.
+  const primary = relayUrl
+    || (tunnelMode === 'named' && tunnelUrl ? tunnelUrl : null)
+    || (tunnelMode === 'off' ? `http://localhost:${port}` : tunnelUrl);
+
   if (healthy) {
-    console.log(`  ${c.pink}${c.bold}✔  Bloby is running${c.reset}\n`);
+    const boxLines = [` ${c.pink}${c.bold}✔  Bloby is running${c.reset}`];
+    if (primary) {
+      boxLines.push('');
+      boxLines.push(`    ${c.pink}${c.bold}${link(primary)}${c.reset}`);
+    }
+    resultBox(boxLines);
   } else {
-    console.log(`  ${GLYPH.warn}  Bloby is starting — not healthy yet. Check ${c.blue}bloby status${c.reset} in a moment.\n`);
+    resultBox([` ${GLYPH.warn}  ${c.bold}Bloby is starting${c.reset} ${c.dim}— not healthy yet. Check ${c.reset}${c.blue}bloby status${c.reset}${c.dim} in a moment.${c.reset}`]);
   }
+
+  console.log('');
   console.log(`  ${c.dim}${'Local'.padEnd(9)}${c.reset}${c.blue}${link(`http://localhost:${port}`)}${c.reset}`);
   if (tunnelMode === 'off') {
     for (const u of getNetworkUrls(port)) {
@@ -927,12 +1230,20 @@ function printReadyBlock({ healthy, tunnelUrl, relayUrl, port, tunnelMode }) {
   }
   if (tunnelUrl) {
     console.log(`  ${c.dim}${'Tunnel'.padEnd(9)}${c.reset}${c.blue}${link(tunnelUrl)}${c.reset}`);
-  } else if (tunnelMode !== 'off') {
-    console.log(`  ${c.dim}${'Tunnel'.padEnd(9)}still connecting — check ${c.reset}${c.blue}bloby status${c.reset}${c.dim} shortly${c.reset}`);
   }
-  if (relayUrl) {
+  if (relayUrl && relayUrl !== primary) {
     console.log(`  ${c.dim}${'Relay'.padEnd(9)}${c.reset}${c.pink}${link(relayUrl)}${c.reset}`);
   }
+
+  if (tunnelFailed && tunnelMode !== 'off') {
+    console.log(`\n  ${GLYPH.warn}  ${c.bold}Tunnel failed to connect.${c.reset}`);
+    console.log(`     ${c.dim}CloudFlare quick tunnels are rate-limited — this usually resolves itself in a few minutes.${c.reset}`);
+    console.log(`     ${c.dim}Your dashboard still works locally (above). Retry with ${c.reset}${c.blue}bloby restart${c.reset}${c.dim}.${c.reset}`);
+  } else if (healthy && tunnelMode !== 'off' && !tunnelUrl) {
+    console.log(`\n  ${GLYPH.warn}  ${c.dim}Tunnel still connecting — check ${c.reset}${c.blue}bloby status${c.reset}${c.dim} shortly.${c.reset}`);
+  } else if (healthy && tunnelMode !== 'off' && tunnelUrl && !ready) {
+    console.log(`\n  ${GLYPH.warn}  ${c.dim}Could not confirm the relay link yet — check ${c.reset}${c.blue}bloby status${c.reset}${c.dim} in a minute.${c.reset}`);
+  }
 }
 
 // ── Cloudflared install (shared by init/start/tunnel) ──
@@ -1091,15 +1402,17 @@ async function runForeground() {
     s.fail(`Server failed to start: ${err.message}`);
     process.exit(1);
   }
-  s.succeed('Bloby is running (foreground — Ctrl+C stops it)');
+  s.stopRaw();
   printReadyBlock({
     healthy: true,
+    ready: !result.tunnelFailed,
+    tunnelFailed: result.tunnelFailed,
     tunnelUrl: result.tunnelFailed ? null : result.tunnelUrl,
     relayUrl: result.relayUrl,
     port: config.port || 7400,
     tunnelMode,
   });
-  console.log(`\n  ${c.dim}Press Ctrl+C to stop${c.reset}\n`);
+  console.log(`\n  ${c.dim}Running in the foreground — press Ctrl+C to stop${c.reset}\n`);
   result.child.stdout.on('data', (d) => process.stdout.write(`  ${c.dim}${d.toString().trim()}${c.reset}\n`));
   result.child.stderr.on('data', (d) => {
     const line = d.toString().trim();
@@ -1111,31 +1424,47 @@ async function runForeground() {
 
 // ── start / stop / restart cores (shared so restart ≡ stop + start, exactly) ──
 
-async function startCore({ spinner, timeoutMs }) {
+/** Step titles for a daemonized start — callers prepend their own (e.g. "Stopping Bloby"). */
+function startStepTitles(config) {
+  const wantTunnel = tunnelModeOf(config) !== 'off';
+  return ['Preparing', 'Starting server', ...(wantTunnel ? ['Connecting tunnel', 'Verifying connection'] : [])];
+}
+
+/** Runs the start sequence against a Steps ui positioned ON the "Preparing" step.
+ *  Advances through Preparing → Starting server → Connecting tunnel → Verifying
+ *  connection as the real signals arrive. */
+async function startCore({ ui, timeoutMs }) {
   const config = readConfig() || {};
   const tunnelMode = tunnelModeOf(config);
   const wantTunnel = tunnelMode !== 'off';
 
-  if (wantTunnel && tunnelMode !== 'named') await ensureCloudflared(spinner);
+  if (wantTunnel && tunnelMode !== 'named') await ensureCloudflared(ui);
 
-  const installed = installServiceFiles({ spinner });
+  const installed = installServiceFiles({ spinner: ui });
   if (!installed.ok) return { ok: false, error: installed.error };
+
+  // Marker baseline: rotate (only safe while certain-stopped) BEFORE capturing
+  // the byte offset, so __READY__ scanning starts exactly at this boot.
+  let logOffset = 0;
+  if (PLATFORM === 'darwin') {
+    if (launchdJob().loaded === false) rotateLaunchdLogIfBig();
+    try { logOffset = fs.statSync(LAUNCHD_LOG).size; } catch {}
+  }
   const sinceMs = Date.now();
   const oldTunnelUrl = config.tunnelUrl || null;
+  ui.update('');
 
-  spinner.update('Starting Bloby...');
-  const started = startDaemonService({ spinner });
+  const started = startDaemonService({ spinner: ui });
   if (!started.ok) return { ok: false, error: started.error };
+  ui.advance(); // Preparing → Starting server
 
-  spinner.update('Waiting for the server...');
-  const ready = await waitForReady({ sinceMs, oldTunnelUrl, wantTunnel, tunnelMode, spinner, ...(timeoutMs ? { timeoutMs } : {}) });
+  const ready = await waitForReady({ sinceMs, oldTunnelUrl, tunnelMode, ui, logOffset, ...(timeoutMs ? { timeoutMs } : {}) });
   return { ok: true, ...ready, port: config.port || 7400, tunnelMode };
 }
 
 async function stopCore({ spinner }) {
   const stopped = await stopDaemonService({ spinner });
   if (!stopped.ok) return stopped;
-  spinner.update('Waiting for processes to exit...');
   await killStraySupervisors();
   return { ok: true };
 }
@@ -1181,7 +1510,8 @@ async function cmdStart() {
 
   if (dPid || runtime) {
     if (dPid) {
-      console.log(`\n  ${c.blue}●${c.reset}  Bloby is already running. Use ${c.blue}bloby restart${c.reset} if you want to restart it.\n`);
+      resultBox([` ${c.blue}●${c.reset}  ${c.bold}Bloby is already running${c.reset}`]);
+      console.log(`\n  ${c.dim}Use ${c.reset}${c.blue}bloby restart${c.reset}${c.dim} if you want to restart it.${c.reset}\n`);
       describeRunning(config);
     } else {
       console.log(`\n  ${GLYPH.warn}  Bloby is already running ${c.dim}(PID ${runtime.pid}, outside the daemon — a foreground or dev instance)${c.reset}.`);
@@ -1201,16 +1531,16 @@ async function cmdStart() {
     return;
   }
 
-  console.log('');
-  const s = new Spinner().start('Starting Bloby...');
-  const result = await startCore({ spinner: s });
+  const steps = new Steps(startStepTitles(config)).start();
+  const result = await startCore({ ui: steps });
   if (!result.ok) {
-    s.fail(`Failed to start: ${result.error}`);
-    console.log(`     Check ${c.blue}bloby logs${c.reset} for details.`);
+    steps.fail(`Failed to start: ${result.error}`);
+    console.log(`     ${c.dim}Check ${c.reset}${c.blue}bloby logs${c.reset}${c.dim} for details.${c.reset}`);
     commandsFooter();
     process.exit(1);
   }
-  s.stopRaw();
+  if (result.healthy && !result.tunnelFailed && (result.tunnelMode === 'off' || result.ready)) steps.finish();
+  else steps.fail();
   printReadyBlock(result);
   commandsFooter();
 }
@@ -1243,7 +1573,8 @@ async function cmdStop() {
     commandsFooter();
     process.exit(1);
   }
-  s.succeed('Bloby stopped.');
+  s.stopRaw();
+  resultBox([` ${c.bold}✔  Bloby stopped${c.reset}`]);
   commandsFooter();
 }
 
@@ -1258,35 +1589,35 @@ async function cmdRestart() {
     process.exit(1);
   }
 
-  console.log('');
   // Anything that can block (cloudflared download) happens BEFORE the stop —
   // never leave Bloby down while waiting on the network.
   const config = readConfig() || {};
   const preMode = tunnelModeOf(config);
   if (preMode !== 'off' && preMode !== 'named' && !hasCloudflared()) {
+    console.log('');
     const sCf = new Spinner().start('Installing cloudflared...');
     try { await installCloudflared(); sCf.succeed('cloudflared ready'); }
     catch (e) { sCf.fail(`cloudflared install failed: ${e.message}`); process.exit(1); }
   }
 
-  const s = new Spinner().start('Stopping Bloby...');
-  const stopped = await stopCore({ spinner: s });
+  const steps = new Steps(['Stopping Bloby', ...startStepTitles(config)]).start();
+  const stopped = await stopCore({ spinner: steps });
   if (!stopped.ok) {
-    s.fail(`Failed to stop: ${stopped.error}`);
+    steps.fail(`Failed to stop: ${stopped.error}`);
     commandsFooter();
     process.exit(1);
   }
-  s.succeed('Stopped.');
+  steps.advance(); // Stopping Bloby → Preparing
 
-  const s2 = new Spinner().start('Starting Bloby...');
-  const result = await startCore({ spinner: s2 });
+  const result = await startCore({ ui: steps });
   if (!result.ok) {
-    s2.fail(`Failed to start: ${result.error}`);
-    console.log(`     Check ${c.blue}bloby logs${c.reset} for details.`);
+    steps.fail(`Failed to start: ${result.error}`);
+    console.log(`     ${c.dim}Check ${c.reset}${c.blue}bloby logs${c.reset}${c.dim} for details.${c.reset}`);
     commandsFooter();
     process.exit(1);
   }
-  s2.stopRaw();
+  if (result.healthy && !result.tunnelFailed && (result.tunnelMode === 'off' || result.ready)) steps.finish();
+  else steps.fail();
   printReadyBlock(result);
   commandsFooter();
 }
@@ -1311,20 +1642,19 @@ async function cmdStatus() {
     (PLATFORM === 'linux' && ['activating', 'active'].includes(systemdShow().activeState))
   );
 
-  console.log('');
   if (running && health) {
     const up = runtime?.startedAt ? ` · up ${formatUptime(Date.now() - runtime.startedAt)}` : (health.uptime != null ? ` · up ${formatUptime(health.uptime * 1000)}` : '');
     const mode = dPid && pid === dPid ? 'daemon' : 'foreground';
     const pidPart = pid ? ` · PID ${pid}` : '';
-    console.log(`  ${c.blue}●${c.reset}  ${c.bold}Bloby is running${c.reset}   ${c.dim}v${version}${pidPart}${up} · ${mode}${c.reset}`);
+    resultBox([` ${c.blue}●${c.reset}  ${c.bold}Bloby is running${c.reset}   ${c.dim}v${version}${pidPart}${up} · ${mode}${c.reset}`]);
   } else if (running) {
-    console.log(`  ${c.yellow}●${c.reset}  ${c.bold}Bloby is starting${c.reset}   ${c.dim}PID ${pid} alive, not answering yet — give it a moment${c.reset}`);
+    resultBox([` ${c.yellow}●${c.reset}  ${c.bold}Bloby is starting${c.reset}   ${c.dim}PID ${pid} alive, not answering yet — give it a moment${c.reset}`]);
   } else if (jobLoadedNoPid) {
-    console.log(`  ${c.yellow}●${c.reset}  ${c.bold}Bloby is restarting${c.reset}   ${c.dim}service loaded but the process is down (starting or crash-looping) — check ${c.reset}${c.blue}bloby logs${c.reset}`);
+    resultBox([` ${c.yellow}●${c.reset}  ${c.bold}Bloby is restarting${c.reset}   ${c.dim}service loaded but the process is down — check ${c.reset}${c.blue}bloby logs${c.reset}`]);
   } else if (installed) {
-    console.log(`  ${c.dim}●  Bloby is stopped${c.reset}   ${c.dim}run ${c.reset}${c.blue}bloby start${c.reset}`);
+    resultBox([` ${c.dim}●${c.reset}  ${c.bold}Bloby is stopped${c.reset}   ${c.dim}run ${c.reset}${c.blue}bloby start${c.reset}`]);
   } else {
-    console.log(`  ${c.dim}●  Bloby is not set up${c.reset}   ${c.dim}run ${c.reset}${c.blue}bloby init${c.reset}`);
+    resultBox([` ${c.dim}●${c.reset}  ${c.bold}Bloby is not set up${c.reset}   ${c.dim}run ${c.reset}${c.blue}bloby init${c.reset}`]);
   }
 
   if (config) {
@@ -1654,7 +1984,8 @@ async function cmdInit() {
         console.log(`__HOSTED_READY__=${JSON.stringify({ tunnelUrl: config?.tunnelUrl || `http://localhost:${config?.port || 7400}`, status: config?.tunnelUrl ? 'ok' : 'tunnel_failed', daemon: true })}`);
         process.exit(0);
       }
-      console.log(`\n  ${c.blue}●${c.reset}  Bloby is already set up and running. Use ${c.blue}bloby restart${c.reset} to restart it, or ${c.blue}bloby tunnel setup${c.reset} to change the tunnel.\n`);
+      resultBox([` ${c.blue}●${c.reset}  ${c.bold}Bloby is already set up and running${c.reset}`]);
+      console.log(`\n  ${c.dim}Use ${c.reset}${c.blue}bloby restart${c.reset}${c.dim} to restart it, or ${c.reset}${c.blue}bloby tunnel setup${c.reset}${c.dim} to change the tunnel.${c.reset}\n`);
       describeRunning(config);
       commandsFooter();
       return;
@@ -1724,23 +2055,27 @@ async function cmdInit() {
   }
 
   if (log) log('Starting daemon...');
-  console.log('');
-  const s = new Spinner().start('Setting up Bloby...');
+  const initConfig = readConfig() || {};
+  const steps = new Steps(startStepTitles(initConfig)).start();
   // Hosted provisioning treats tunnel_failed as meaningful — give cold cloud
   // boxes a longer window before declaring the tunnel down.
-  const result = await startCore({ spinner: s, ...(HOSTED ? { timeoutMs: 150_000 } : {}) });
+  const result = await startCore({ ui: steps, ...(HOSTED ? { timeoutMs: 180_000 } : {}) });
   if (!result.ok) {
-    s.fail(`Failed to start: ${result.error}`);
+    steps.fail(`Failed to start: ${result.error}`);
     if (HOSTED) {
       console.error(JSON.stringify({ error: result.error }));
     }
     process.exit(1);
   }
-  s.stopRaw();
+  if (result.healthy && !result.tunnelFailed && (result.tunnelMode === 'off' || result.ready)) steps.finish();
+  else steps.fail();
 
   if (HOSTED) {
     if (log) log(result.healthy ? 'Daemon running' : 'Daemon starting');
-    console.log(`__HOSTED_READY__=${JSON.stringify({ tunnelUrl: result.tunnelUrl || `http://localhost:${result.port}`, status: result.tunnelUrl ? 'ok' : 'tunnel_failed', daemon: true })}`);
+    // status keyed off the supervisor's explicit __TUNNEL_FAILED__ marker (same
+    // semantics as the no-daemon foreground path) — a slow tunnel is not a failure.
+    const hostedStatus = result.tunnelFailed || !result.tunnelUrl ? 'tunnel_failed' : 'ok';
+    console.log(`__HOSTED_READY__=${JSON.stringify({ tunnelUrl: result.tunnelUrl || `http://localhost:${result.port}`, status: hostedStatus, daemon: true })}`);
     process.exit(0);
   }
 
@@ -1965,13 +2300,15 @@ async function cmdUpdate() {
 
   // Restart only if it was running before — update does not start a stopped bot.
   if (daemonWasRunning) {
-    const s7 = new Spinner().start('Restarting Bloby...');
-    const result = await startCore({ spinner: s7 });
+    const cfgNow = readConfig() || {};
+    const steps = new Steps(startStepTitles(cfgNow)).start();
+    const result = await startCore({ ui: steps });
     if (result.ok && result.healthy) {
-      s7.succeed('Bloby restarted on the new version.');
+      if (!result.tunnelFailed && (result.tunnelMode === 'off' || result.ready)) steps.finish();
+      else steps.fail();
       printReadyBlock(result);
     } else {
-      s7.warn(`Bloby may still be starting — check ${c.blue}bloby status${c.reset}.`);
+      steps.fail(`Bloby may still be starting — check ${c.blue}bloby status${c.reset}.`);
     }
   } else {
     console.log(`  ${c.dim}Bloby was not running. Start it with ${c.reset}${c.blue}bloby start${c.reset}${c.dim} when ready.${c.reset}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloby-bot",
-  "version": "0.67.0",
+  "version": "0.68.0",
   "releaseNotes": [
     "1. Fix: agent self-update now actively relaunches the daemon (launchctl/systemctl) instead of relying on launchd KeepAlive — so `update` from chat/pulse comes back up reliably, matching manual `bloby update`",
     "2. New agent control surface (/__bloby/control/*): restart-and-verify the backend in-turn, tail backend + frontend logs, and acked self-update — replacing the flaky touch .update/.restart triggers",

package/supervisor/backend.ts

@@ -9,6 +9,17 @@ let child: ChildProcess | null = null;
 let restarts = 0;
 let lastSpawnTime = 0;
 let intentionallyStopped = false;
+
+// Hard backstop against an orphaned backend. SIGTERM/SIGINT go through stopBackend() for a graceful
+// stop, but process.exit() (server EADDRINUSE handler, self-update relaunch, fatal errors) bypasses
+// those handlers AND can't run async cleanup — so the backend child would survive as an orphan
+// (PPID→1) still holding BACKEND_PORT, EADDRINUSE-ing every later backend spawn until killPort
+// happens to reclaim it. 'exit' fires on EVERY exit path (including process.exit) and allows the one
+// synchronous kill we need. (A SIGKILL of the supervisor itself can't be caught — killPort covers it
+// on the next startup.)
+process.on('exit', () => {
+  try { if (child && child.exitCode === null) child.kill('SIGKILL'); } catch {}
+});
 // True once the backend has crash-looped past MAX_RESTARTS and given up — i.e. it's down and
 // will NOT come back without the user fixing the code. The supervisor shows the "backend down"
 // interstitial in this state. Cleared on every spawn attempt (a deliberate restart is "trying again").