fluxy-bot 0.5.70 → 0.5.72

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluxy-bot",
-  "version": "0.5.70",
+  "version": "0.5.72",
   "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,26 +892,8 @@ 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;
 

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> {