fluxy-bot 0.5.20 → 0.5.22

package/bin/cli.js

@@ -270,20 +270,19 @@ function bootServer() {
         viteWarmResolve();
       }
 
-      if (tunnelUrl && relayUrl) {
+      if (text.includes('__READY__')) {
         doResolve();
         return;
       }
 
-      if (tunnelUrl && !relayUrl) {
-        setTimeout(doResolve, 3000);
-      }
-
       if (text.includes('__TUNNEL_FAILED__')) {
         doResolve();
       }
     };
 
+    // Safety-net timeout: resolve after 45s even if __READY__ never arrives
+    setTimeout(doResolve, 45_000);
+
     child.stdout.on('data', handleData);
     child.stderr.on('data', (data) => {
       stderrBuf += data.toString();
@@ -315,6 +314,7 @@ async function init() {
     'Installing cloudflared',
     'Starting server',
     'Connecting tunnel',
+    'Verifying connection',
     'Preparing dashboard',
   ];
 
@@ -340,7 +340,8 @@ async function init() {
     process.exit(1);
   }
   const { child, tunnelUrl, relayUrl, viteWarm } = result;
-  stepper.advance();
+  stepper.advance(); // Connecting tunnel done
+  stepper.advance(); // Verifying connection done
 
   // Wait for Vite to finish pre-transforming all modules (with timeout)
   await Promise.race([viteWarm, new Promise(r => setTimeout(r, 30_000))]);
@@ -366,7 +367,7 @@ async function start() {
 
   banner();
 
-  const steps = ['Loading config', 'Starting server', 'Connecting tunnel', 'Preparing dashboard'];
+  const steps = ['Loading config', 'Starting server', 'Connecting tunnel', 'Verifying connection', 'Preparing dashboard'];
   const stepper = new Stepper(steps);
   stepper.start();
 
@@ -383,7 +384,8 @@ async function start() {
     process.exit(1);
   }
   const { child, tunnelUrl, relayUrl, viteWarm } = result;
-  stepper.advance();
+  stepper.advance(); // Connecting tunnel done
+  stepper.advance(); // Verifying connection done
 
   // Wait for Vite to finish pre-transforming all modules (with timeout)
   await Promise.race([viteWarm, new Promise(r => setTimeout(r, 30_000))]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluxy-bot",
-  "version": "0.5.20",
+  "version": "0.5.22",
   "description": "Self-hosted, self-evolving AI agent with its own dashboard.",
   "type": "module",
   "license": "MIT",

package/scripts/install

@@ -132,6 +132,8 @@ install_fluxy() {
     NPM="npm"
     NODE="node"
   else
+    # Add bundled node to PATH so npm's "#!/usr/bin/env node" shebang works
+    export PATH="$NODE_DIR/bin:$PATH"
     NPM="$NODE_DIR/bin/npm"
     NODE="$NODE_DIR/bin/node"
   fi

package/scripts/install.sh

@@ -132,6 +132,8 @@ install_fluxy() {
     NPM="npm"
     NODE="node"
   else
+    # Add bundled node to PATH so npm's "#!/usr/bin/env node" shebang works
+    export PATH="$NODE_DIR/bin:$PATH"
     NPM="$NODE_DIR/bin/npm"
     NODE="$NODE_DIR/bin/node"
   fi

package/supervisor/backend.ts

@@ -6,6 +6,7 @@ import { log } from '../shared/logger.js';
 let child: ChildProcess | null = null;
 let restarts = 0;
 let lastSpawnTime = 0;
+let intentionallyStopped = false;
 const MAX_RESTARTS = 3;
 const STABLE_THRESHOLD = 30_000; // 30s — if backend ran this long, it wasn't a crash loop
 
@@ -16,6 +17,7 @@ export function getBackendPort(basePort: number): number {
 export function spawnBackend(port: number): ChildProcess {
   const backendPath = path.join(PKG_DIR, 'workspace', 'backend', 'index.ts');
   lastSpawnTime = Date.now();
+  intentionallyStopped = false;
 
   child = spawn(process.execPath, ['--import', 'tsx/esm', backendPath], {
     cwd: path.join(PKG_DIR, 'workspace'),
@@ -32,19 +34,21 @@ export function spawnBackend(port: number): ChildProcess {
   });
 
   child.on('exit', (code) => {
-    if (code !== 0 && code !== null) {
-      log.warn(`Backend crashed (code ${code})`);
-      // If backend was alive for >30s, it's not a crash loop — reset counter
-      if (Date.now() - lastSpawnTime > STABLE_THRESHOLD) {
-        restarts = 0;
-      }
-      if (restarts < MAX_RESTARTS) {
-        restarts++;
-        log.info(`Restarting backend (${restarts}/${MAX_RESTARTS})...`);
-        setTimeout(() => spawnBackend(port), 1000 * restarts);
-      } else {
-        log.error('Backend failed too many times. Use Fluxy chat to debug.');
-      }
+    // Supervisor called stopBackend() — don't auto-restart
+    if (intentionallyStopped) return;
+
+    // Any unexpected exit (crash, SIGTERM, OOM, null code) — restart
+    log.warn(`Backend exited unexpectedly (code ${code})`);
+    // If backend was alive for >30s, it's not a crash loop — reset counter
+    if (Date.now() - lastSpawnTime > STABLE_THRESHOLD) {
+      restarts = 0;
+    }
+    if (restarts < MAX_RESTARTS) {
+      restarts++;
+      log.info(`Restarting backend (${restarts}/${MAX_RESTARTS})...`);
+      setTimeout(() => spawnBackend(port), 1000 * restarts);
+    } else {
+      log.error('Backend failed too many times. Use Fluxy chat to debug.');
     }
   });
 
@@ -53,6 +57,7 @@ export function spawnBackend(port: number): ChildProcess {
 }
 
 export function stopBackend(): void {
+  intentionallyStopped = true;
   child?.kill();
   child = null;
 }

package/supervisor/index.ts

@@ -497,11 +497,15 @@ export async function startSupervisor() {
             } catch {}
 
             // Start agent query
+            agentQueryActive = true;
             startFluxyAgentQuery(convId, content, freshConfig.ai.model, (type, eventData) => {
               // Intercept bot:done — Vite HMR handles file changes automatically
               if (type === 'bot:done') {
-                if (eventData.usedFileTools) {
-                  console.log('[supervisor] File tools used — Vite HMR handles frontend, restarting backend');
+                agentQueryActive = false;
+                // Restart if agent used file tools OR file watcher detected changes during the turn
+                if (eventData.usedFileTools || pendingBackendRestart) {
+                  console.log('[supervisor] Agent turn ended — restarting backend');
+                  pendingBackendRestart = false;
                   resetBackendRestarts();
                   stopBackend();
                   spawnBackend(backendPort);
@@ -624,6 +628,10 @@ export async function startSupervisor() {
     log.ok(`Fluxy chat at http://localhost:${config.port}/fluxy`);
   });
 
+  // Track whether an agent query is active — file watcher defers to bot:done during turns
+  let agentQueryActive = false;
+  let pendingBackendRestart = false; // Set when file watcher fires during agent turn
+
   // Spawn worker + backend
   spawnWorker(workerPort);
   spawnBackend(backendPort);
@@ -640,20 +648,45 @@ export async function startSupervisor() {
     getModel: () => loadConfig().ai.model,
   });
 
-  // Watch workspace/backend/ for file changes — auto-restart backend
-  // This catches edits from Claude Code CLI, VS Code, or any external tool
-  const backendDir = path.join(PKG_DIR, 'workspace', 'backend');
+  // Watch workspace files for changes — auto-restart backend
+  // Catches edits from VS Code, CLI, or any external tool.
+  // During agent turns, defers to bot:done (avoids mid-turn restarts).
+  const workspaceDir = path.join(PKG_DIR, 'workspace');
+  const backendDir = path.join(workspaceDir, 'backend');
   let backendRestartTimer: ReturnType<typeof setTimeout> | null = null;
-  const backendWatcher = fs.watch(backendDir, { recursive: true }, (_event, filename) => {
-    if (!filename || !filename.match(/\.(ts|js|json)$/)) return;
-    // Debounce: wait 500ms for rapid edits to settle
+
+  function scheduleBackendRestart(reason: string) {
+    if (agentQueryActive) {
+      // Agent is working — don't restart now, flag it for bot:done
+      pendingBackendRestart = true;
+      return;
+    }
     if (backendRestartTimer) clearTimeout(backendRestartTimer);
     backendRestartTimer = setTimeout(() => {
-      log.info(`[watcher] Backend file changed: ${filename} — restarting...`);
+      log.info(`[watcher] ${reason} — restarting backend...`);
       resetBackendRestarts();
       stopBackend();
       spawnBackend(backendPort);
-    }, 500);
+    }, 1000);
+  }
+
+  // Watch backend/ for code changes
+  const backendWatcher = fs.watch(backendDir, { recursive: true }, (_event, filename) => {
+    if (!filename || !filename.match(/\.(ts|js|json)$/)) return;
+    scheduleBackendRestart(`Backend file changed: ${filename}`);
+  });
+
+  // Watch workspace root for .env changes and .restart trigger
+  const workspaceWatcher = fs.watch(workspaceDir, (_event, filename) => {
+    if (!filename) return;
+    if (filename === '.env') {
+      scheduleBackendRestart('.env changed');
+    }
+    if (filename === '.restart') {
+      // Consume the trigger file
+      try { fs.unlinkSync(path.join(workspaceDir, '.restart')); } catch {}
+      scheduleBackendRestart('.restart trigger');
+    }
   });
 
   // Tunnel
@@ -681,6 +714,25 @@ export async function startSupervisor() {
           log.warn(`Relay: ${err instanceof Error ? err.message : err}`);
         }
       }
+
+      // Poll until the full chain is actually working (avoid 502s)
+      // Cache-busting query param prevents browsers/CDN from serving stale 502s
+      const probeUrl = config.relay?.url || tunnelUrl;
+      let ready = false;
+      for (let i = 0; i < 20; i++) {
+        try {
+          const res = await fetch(probeUrl + `/api/health?_cb=${Date.now()}`, {
+            signal: AbortSignal.timeout(3000),
+            headers: { 'Cache-Control': 'no-cache' },
+          });
+          if (res.ok) { ready = true; break; }
+        } catch {}
+        await new Promise(r => setTimeout(r, 1000));
+      }
+      if (!ready) {
+        log.warn('Readiness probe timed out — URL may not be reachable yet');
+      }
+      console.log('__READY__');
     } catch (err) {
       log.warn(`Tunnel: ${err instanceof Error ? err.message : err}`);
       console.log('__TUNNEL_FAILED__');
@@ -726,6 +778,7 @@ export async function startSupervisor() {
     log.info('Shutting down...');
     stopScheduler();
     backendWatcher.close();
+    workspaceWatcher.close();
     if (backendRestartTimer) clearTimeout(backendRestartTimer);
     if (watchdogInterval) clearInterval(watchdogInterval);
     stopHeartbeat();

package/worker/index.ts

@@ -63,6 +63,15 @@ initWebPush();
 const app = express();
 app.use(express.json({ limit: '10mb' }));
 
+// Prevent browsers/CDN/relay from caching API responses (avoids stale 502s)
+app.use('/api', (_, res, next) => {
+  res.set('Cache-Control', 'no-store, no-cache, must-revalidate, proxy-revalidate');
+  res.set('Pragma', 'no-cache');
+  res.set('Expires', '0');
+  res.set('Surrogate-Control', 'no-store');
+  next();
+});
+
 app.get('/api/health', (_, res) => res.json({ status: 'ok' }));
 app.get('/api/conversations', (_, res) => res.json(listConversations()));
 app.get('/api/conversations/:id', (req, res) => {

package/worker/prompts/fluxy-system-prompt.txt

@@ -218,6 +218,26 @@ Browser: GET /app/api/tasks → Supervisor strips prefix → Backend receives: G
 ## Build Rules
 NEVER run `npm run build`, `vite build`, or any build commands. Vite HMR handles frontend changes automatically. The backend auto-restarts when you edit files. Never look in `dist/` or `dist-fluxy/`.
 
+## Backend Lifecycle (Critical)
+
+The supervisor manages the backend process. You don't need to manage it yourself.
+
+**Auto-restart triggers (you don't need to do anything):**
+- Editing `.ts`, `.js`, or `.json` files in `backend/` → auto-restart
+- Editing `.env` → auto-restart with the new values
+- Creating a `.restart` file → force restart: `touch .restart` (file is auto-deleted)
+- After your turn ends, if you used Write or Edit tools → auto-restart
+
+**During your turn:** The backend does NOT restart mid-turn. All your edits are batched — the backend restarts once when you're done. This means if you're writing multi-file changes, everything applies atomically.
+
+**If the backend crashes:** It auto-restarts up to 3 times. If it keeps crashing, check `backend/index.ts` for syntax errors or bad imports.
+
+**NEVER do these:**
+- Never `kill` processes or run `pkill`/`killall` — you don't manage the supervisor or its children
+- Never run `fluxy start` or try to restart the supervisor — only your human can do that
+- Never run `npm start` or `node backend/index.ts` directly — the supervisor handles it
+- If something is truly broken and won't self-heal, tell your human to restart fluxy
+
 ## Sacred Files — NEVER Modify
 - `supervisor/` — chat UI, proxy, process management
 - `worker/` — platform APIs and database