fluxy-bot 0.5.69 → 0.5.71

package/bin/cli.js

@@ -152,9 +152,9 @@ function generateLaunchdPlist({ nodePath, dataDir }) {
   <key>ThrottleInterval</key>
   <integer>5</integer>
   <key>StandardOutPath</key>
-  <string>${LAUNCHD_LOG_DIR}/stdout.log</string>
+  <string>${LAUNCHD_LOG_DIR}/fluxy.log</string>
   <key>StandardErrorPath</key>
-  <string>${LAUNCHD_LOG_DIR}/stderr.log</string>
+  <string>${LAUNCHD_LOG_DIR}/fluxy.log</string>
   <key>ProcessType</key>
   <string>Standard</string>
 </dict>
@@ -545,15 +545,15 @@ function finalMessage(tunnelUrl, relayUrl) {
   ${c.pink}${c.bold}${link(relayUrl)}${c.reset}`);
   }
 
-  if (os.platform() === 'linux') {
+  if (hasDaemonSupport()) {
     console.log(`
   ${c.dim}─────────────────────────────────${c.reset}
 
   ${c.bold}${c.white}Commands:${c.reset}
-  ${c.dim}Status${c.reset}    ${c.pink}fluxy daemon status${c.reset}
-  ${c.dim}Logs${c.reset}      ${c.pink}fluxy daemon logs${c.reset}
+  ${c.dim}Status${c.reset}    ${c.pink}fluxy status${c.reset}
+  ${c.dim}Logs${c.reset}      ${c.pink}fluxy logs${c.reset}
+  ${c.dim}Stop${c.reset}      ${c.pink}fluxy stop${c.reset}
   ${c.dim}Restart${c.reset}   ${c.pink}fluxy daemon restart${c.reset}
-  ${c.dim}Stop${c.reset}      ${c.pink}fluxy daemon stop${c.reset}
   ${c.dim}Update${c.reset}    ${c.pink}fluxy update${c.reset}
   `);
   } else {
@@ -1222,7 +1222,7 @@ async function daemon(sub) {
   if (PLATFORM === 'darwin') {
     switch (action) {
       case 'install': {
-        const dataDir = path.join(os.homedir(), '.fluxy');
+        const dataDir = ROOT; // Uses REPO_ROOT in dev, DATA_DIR (~/.fluxy) in production
         if (!fs.existsSync(path.join(dataDir, 'supervisor', 'index.ts'))) {
           console.log(`\n  ${c.red}✗${c.reset}  Run ${c.pink}fluxy init${c.reset} first.\n`);
           process.exit(1);
@@ -1301,12 +1301,12 @@ async function daemon(sub) {
           console.log(`\n  ${c.dim}●${c.reset} Fluxy daemon is stopped.`);
         }
         console.log(`  ${c.dim}Plist:${c.reset} ${LAUNCHD_PLIST_PATH}`);
-        console.log(`  ${c.dim}Logs:${c.reset}  ${LAUNCHD_LOG_DIR}/\n`);
+        console.log(`  ${c.dim}Logs:${c.reset}  ${LAUNCHD_LOG_DIR}/fluxy.log\n`);
         break;
       }
 
       case 'logs': {
-        const logFile = path.join(LAUNCHD_LOG_DIR, 'stdout.log');
+        const logFile = path.join(LAUNCHD_LOG_DIR, 'fluxy.log');
         if (!fs.existsSync(logFile)) {
           console.log(`\n  ${c.dim}No logs found at ${logFile}${c.reset}\n`);
           break;
@@ -1548,6 +1548,8 @@ async function tunnel(sub) {
 switch (command) {
   case 'init':    init(); break;
   case 'start':   start(); break;
+  case 'stop':    daemon('stop'); break;
+  case 'logs':    daemon('logs'); break;
   case 'status':  status(); break;
   case 'update':  update(); break;
   case 'daemon':  daemon(subcommand); break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluxy-bot",
-  "version": "0.5.69",
+  "version": "0.5.71",
   "releaseNotes": [
     "Fixed some bugs to iOs ",
     "2. ",

package/supervisor/index.ts

@@ -784,17 +784,18 @@ export async function startSupervisor() {
       config.tunnelUrl = tunnelUrl;
       saveConfig(config);
 
-      // Wait for the tunnel to be reachable before telling the relay about it.
+      // Wait for local server to be reachable before telling the relay.
+      // Probes localhost directly — avoids macOS issue where server can't
+      // reach itself through the Cloudflare tunnel URL.
       let tunnelReady = false;
-      log.info(`Readiness probe: waiting for tunnel ${tunnelUrl}`);
+      log.info('Readiness probe: waiting for local server...');
       for (let i = 0; i < 30; i++) {
         try {
-          const res = await fetch(tunnelUrl + `/api/health?_cb=${Date.now()}`, {
+          const res = await fetch(`http://127.0.0.1:${config.port}/api/health?_cb=${Date.now()}`, {
             signal: AbortSignal.timeout(3000),
-            headers: { 'Cache-Control': 'no-cache, no-store' },
           });
           log.info(`Readiness probe #${i + 1}: ${res.status}`);
-          if (res.status !== 502 && res.status !== 503) {
+          if (res.ok) {
             tunnelReady = true;
             break;
           }
@@ -804,7 +805,7 @@ export async function startSupervisor() {
         await new Promise(r => setTimeout(r, 1000));
       }
       if (!tunnelReady) {
-        log.warn('Tunnel readiness probe timed out — updating relay anyway');
+        log.warn('Local server readiness probe timed out — updating relay anyway');
       }
 
       // Now register tunnel URL with relay and start heartbeats
@@ -837,17 +838,16 @@ export async function startSupervisor() {
       config.tunnelUrl = tunnelUrl;
       saveConfig(config);
 
-      // Readiness probe against the user's domain
+      // Readiness probe — check local server (not tunnel URL, avoids macOS self-reach issue)
       let tunnelReady = false;
-      log.info(`Readiness probe: waiting for tunnel ${tunnelUrl}`);
+      log.info('Readiness probe: waiting for local server...');
       for (let i = 0; i < 30; i++) {
         try {
-          const res = await fetch(tunnelUrl + `/api/health?_cb=${Date.now()}`, {
+          const res = await fetch(`http://127.0.0.1:${config.port}/api/health?_cb=${Date.now()}`, {
             signal: AbortSignal.timeout(3000),
-            headers: { 'Cache-Control': 'no-cache, no-store' },
           });
           log.info(`Readiness probe #${i + 1}: ${res.status}`);
-          if (res.status !== 502 && res.status !== 503) {
+          if (res.ok) {
             tunnelReady = true;
             break;
           }
@@ -857,7 +857,7 @@ export async function startSupervisor() {
         await new Promise(r => setTimeout(r, 1000));
       }
       if (!tunnelReady) {
-        log.warn('Named tunnel readiness probe timed out');
+        log.warn('Local server readiness probe timed out');
       }
 
       console.log('__READY__');
@@ -880,7 +880,7 @@ export async function startSupervisor() {
       lastTick = now; // Update immediately so concurrent ticks don't see a stale gap
 
       if (wakeGap || periodicCheck) {
-        const alive = await isTunnelAlive(tunnelUrl!);
+        const alive = await isTunnelAlive(tunnelUrl!, config.port);
         if (!alive) {
           log.warn('Tunnel dead, restarting...');
           try {
@@ -892,35 +892,21 @@ export async function startSupervisor() {
               // Quick tunnel: restart and get new URL
               const newUrl = await restartTunnel(config.port);
 
-              // Wait for the new tunnel to be reachable before updating the relay
-              log.info(`Waiting for new tunnel to become reachable: ${newUrl}`);
-              let tunnelReady = false;
-              for (let i = 0; i < 30; i++) {
-                try {
-                  const res = await fetch(newUrl + `/api/health?_cb=${Date.now()}`, {
-                    signal: AbortSignal.timeout(3000),
-                    headers: { 'Cache-Control': 'no-cache, no-store' },
-                  });
-                  if (res.status !== 502 && res.status !== 503) {
-                    tunnelReady = true;
-                    log.info(`Tunnel reachable after ${i + 1} probes`);
-                    break;
-                  }
-                } catch {}
-                await new Promise(r => setTimeout(r, 1000));
-              }
-              if (!tunnelReady) {
-                log.warn('Tunnel readiness probe timed out — updating relay anyway');
-              }
+              // Brief pause to let cloudflared establish the tunnel
+              await new Promise(r => setTimeout(r, 3000));
 
               tunnelUrl = newUrl;
-              config.tunnelUrl = newUrl;
-              saveConfig(config);
 
-              if (config.relay?.token) {
+              // Re-read config from disk — relay token may have been added during onboarding
+              const latestCfg = loadConfig();
+              latestCfg.tunnelUrl = newUrl;
+              saveConfig(latestCfg);
+
+              if (latestCfg.relay?.token) {
                 stopHeartbeat();
-                startHeartbeat(config.relay.token, newUrl);
-                await updateTunnelUrl(config.relay.token, newUrl);
+                startHeartbeat(latestCfg.relay.token, newUrl);
+                await updateTunnelUrl(latestCfg.relay.token, newUrl);
+                log.ok(`Relay updated with new tunnel URL`);
               }
               log.ok(`Tunnel restored: ${newUrl}`);
             }

package/supervisor/tunnel.ts

@@ -116,19 +116,33 @@ export function stopTunnel(): void {
   proc = null;
 }
 
-export async function isTunnelAlive(url: string): Promise<boolean> {
-  // Two attempts with a short gap — avoids false positives from transient Cloudflare errors
-  for (let attempt = 0; attempt < 2; attempt++) {
+/** Check if the cloudflared child process is still running */
+export function isTunnelProcessAlive(): boolean {
+  return proc !== null && proc.exitCode === null && proc.signalCode === null;
+}
+
+export async function isTunnelAlive(url: string, localPort?: number): Promise<boolean> {
+  // 1. Process check — if cloudflared exited, tunnel is definitely dead
+  if (!isTunnelProcessAlive()) return false;
+
+  // 2. Local reachability check — confirm the local server is still responding.
+  //    We probe localhost directly instead of the tunnel URL because on macOS
+  //    the server can't reach itself through the Cloudflare tunnel (DNS/firewall).
+  //    If localhost responds and cloudflared is running, the tunnel is alive.
+  if (localPort) {
     try {
-      const res = await fetch(url + `/api/health?_cb=${Date.now()}`, {
-        signal: AbortSignal.timeout(8000),
-        headers: { 'Cache-Control': 'no-cache, no-store' },
+      const res = await fetch(`http://127.0.0.1:${localPort}/api/health?_cb=${Date.now()}`, {
+        signal: AbortSignal.timeout(3000),
       });
-      if (res.status !== 502 && res.status !== 503) return true;
+      if (res.ok) return true;
     } catch {}
-    if (attempt === 0) await new Promise(r => setTimeout(r, 3000));
+    // Local server not responding — but cloudflared is alive, so tunnel is still up.
+    // The worker may be restarting. Don't kill the tunnel for a local issue.
+    return true;
   }
-  return false;
+
+  // No local port provided — process alive is enough
+  return true;
 }
 
 export async function restartTunnel(port: number): Promise<string> {