bloby-bot 0.22.10 → 0.22.12

package/bin/cli.js

@@ -714,6 +714,72 @@ function writeVersionFile(version) {
   try { fs.writeFileSync(path.join(DATA_DIR, 'VERSION'), version); } catch {}
 }
 
+/**
+ * Poll health endpoint and config.json until the daemon is ready.
+ * Advances the stepper through tunnel + verification steps.
+ */
+async function waitForDaemonHealth(stepper, config, hasTunnel) {
+  const port = config.port || 7400;
+  const relayUrl = config.relay?.url || null;
+  let tunnelUrl = null;
+  let tunnelShown = false;
+  let healthOk = false;
+
+  // Clear any stale tunnelUrl from config so we detect the fresh one
+  const oldTunnelUrl = config.tunnelUrl || null;
+
+  for (let i = 0; i < 120; i++) {
+    await new Promise(r => setTimeout(r, 1000));
+
+    // Check for new tunnel URL in config
+    if (hasTunnel && !tunnelShown) {
+      try {
+        const cfg = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+        if (cfg.tunnelUrl && cfg.tunnelUrl !== oldTunnelUrl) {
+          tunnelUrl = cfg.tunnelUrl;
+          stepper.advance(); // Connecting tunnel done
+          if (relayUrl) {
+            stepper.setInfo([
+              `  ${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}`,
+            ]);
+          }
+          tunnelShown = true;
+        }
+      } catch {}
+    }
+
+    // Check health
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}/api/health`);
+      if (res.ok) {
+        healthOk = true;
+        break;
+      }
+    } catch {}
+  }
+
+  // If tunnel never came up, advance past tunnel step anyway
+  if (hasTunnel && !tunnelShown) {
+    stepper.advance();
+  }
+
+  if (tunnelShown) {
+    stepper.setInfo([]);
+  }
+
+  // Advance past "Verifying connection"
+  stepper.advance();
+
+  // Re-read config for final URLs
+  try {
+    const cfg = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+    if (cfg.tunnelUrl) tunnelUrl = cfg.tunnelUrl;
+  } catch {}
+
+  return { tunnelUrl, relayUrl, healthOk };
+}
+
 // ── Steps ──
 
 function createConfig() {
@@ -1289,13 +1355,19 @@ async function update() {
   const selfUpdate = !!process.env.BLOBY_SELF_UPDATE;
   const daemonWasRunning = !selfUpdate && isDaemonInstalled() && isDaemonActive();
 
+  const updateConfig = fs.existsSync(CONFIG_PATH) ? JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8')) : {};
+  const updateTunnelMode = updateConfig.tunnel?.mode ?? (updateConfig.tunnel?.enabled === false ? 'off' : 'quick');
+  const updateHasTunnel = updateTunnelMode !== 'off';
+
   const steps = [
     'Downloading update',
     ...(daemonWasRunning ? ['Stopping daemon'] : []),
     'Updating files',
     'Installing dependencies',
     'Building interface',
-    ...(daemonWasRunning ? ['Restarting daemon'] : []),
+    ...(daemonWasRunning
+      ? ['Restarting daemon', ...(updateHasTunnel ? ['Connecting tunnel', 'Verifying connection'] : ['Verifying connection'])]
+      : []),
   ];
 
   const stepper = new Stepper(steps);
@@ -1410,6 +1482,7 @@ async function update() {
   fs.rmSync(tmpDir, { recursive: true, force: true });
 
   // Restart daemon if it was running (skipped during self-update)
+  let updateResult = null;
   if (daemonWasRunning) {
     try {
       if (PLATFORM === 'darwin') {
@@ -1419,7 +1492,10 @@ async function update() {
         execSync(cmd, { stdio: 'ignore' });
       }
     } catch {}
-    stepper.advance();
+    stepper.advance(); // Restarting daemon done
+
+    // Wait for daemon to become healthy and tunnel to connect
+    updateResult = await waitForDaemonHealth(stepper, updateConfig, updateHasTunnel);
   }
 
   stepper.finish();
@@ -1442,7 +1518,9 @@ async function update() {
   }
 
   if (daemonWasRunning) {
-    if (isDaemonActive()) {
+    if (updateResult && updateResult.tunnelUrl && updateHasTunnel) {
+      finalMessage(updateResult.tunnelUrl, updateResult.relayUrl);
+    } else if (updateResult && updateResult.healthOk) {
       console.log(`  ${c.blue}✔${c.reset}  Daemon restarted with new version.\n`);
     } else {
       console.log(`  ${c.yellow}⚠${c.reset}  Daemon may still be starting. Check ${c.pink}bloby daemon status${c.reset}\n`);
@@ -1544,9 +1622,37 @@ async function daemon(sub) {
           console.log(`\n  ${c.yellow}⚠${c.reset}  Daemon not installed. Run ${c.pink}bloby daemon install${c.reset} first.\n`);
           process.exit(1);
         }
+
+        banner();
+
+        const restartConfig = fs.existsSync(CONFIG_PATH) ? JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8')) : {};
+        const restartTunnelMode = restartConfig.tunnel?.mode ?? (restartConfig.tunnel?.enabled === false ? 'off' : 'quick');
+        const restartHasTunnel = restartTunnelMode !== 'off';
+
+        const restartSteps = [
+          'Stopping daemon',
+          'Starting daemon',
+          ...(restartHasTunnel ? ['Connecting tunnel', 'Verifying connection'] : ['Verifying connection']),
+        ];
+        const restartStepper = new Stepper(restartSteps);
+        restartStepper.start();
+
         try { execSync(`launchctl unload "${LAUNCHD_PLIST_PATH}" 2>/dev/null`, { stdio: 'ignore' }); } catch {}
+        restartStepper.advance(); // Stopping daemon done
+
         execSync(`launchctl load "${LAUNCHD_PLIST_PATH}"`, { stdio: 'ignore' });
-        console.log(`\n  ${c.blue}✔${c.reset}  Bloby daemon restarted.\n`);
+        restartStepper.advance(); // Starting daemon done
+
+        const restartResult = await waitForDaemonHealth(restartStepper, restartConfig, restartHasTunnel);
+        restartStepper.finish();
+
+        if (!restartHasTunnel) {
+          privateNetworkMessage(restartConfig.port);
+        } else if (restartResult.tunnelUrl) {
+          finalMessage(restartResult.tunnelUrl, restartResult.relayUrl);
+        } else {
+          console.log(`\n  ${c.blue}✔${c.reset}  Bloby daemon restarted.\n`);
+        }
         break;
       }
 
@@ -1654,8 +1760,37 @@ async function daemon(sub) {
 
     case 'restart': {
       if (needsSudo()) sudoReExec();
-      execSync(`systemctl restart ${SERVICE_NAME}`, { stdio: 'inherit' });
-      console.log(`\n  ${c.blue}✔${c.reset}  Bloby daemon restarted.\n`);
+
+      banner();
+
+      const sysRestartConfig = fs.existsSync(CONFIG_PATH) ? JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8')) : {};
+      const sysRestartTunnelMode = sysRestartConfig.tunnel?.mode ?? (sysRestartConfig.tunnel?.enabled === false ? 'off' : 'quick');
+      const sysRestartHasTunnel = sysRestartTunnelMode !== 'off';
+
+      const sysRestartSteps = [
+        'Stopping daemon',
+        'Starting daemon',
+        ...(sysRestartHasTunnel ? ['Connecting tunnel', 'Verifying connection'] : ['Verifying connection']),
+      ];
+      const sysRestartStepper = new Stepper(sysRestartSteps);
+      sysRestartStepper.start();
+
+      execSync(`systemctl stop ${SERVICE_NAME}`, { stdio: 'ignore' });
+      sysRestartStepper.advance(); // Stopping daemon done
+
+      execSync(`systemctl start ${SERVICE_NAME}`, { stdio: 'ignore' });
+      sysRestartStepper.advance(); // Starting daemon done
+
+      const sysRestartResult = await waitForDaemonHealth(sysRestartStepper, sysRestartConfig, sysRestartHasTunnel);
+      sysRestartStepper.finish();
+
+      if (!sysRestartHasTunnel) {
+        privateNetworkMessage(sysRestartConfig.port);
+      } else if (sysRestartResult.tunnelUrl) {
+        finalMessage(sysRestartResult.tunnelUrl, sysRestartResult.relayUrl);
+      } else {
+        console.log(`\n  ${c.blue}✔${c.reset}  Bloby daemon restarted.\n`);
+      }
       break;
     }