fluxy-bot 0.5.22 → 0.5.24

package/package.json

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

package/supervisor/backend.ts

@@ -1,4 +1,5 @@
 import { spawn, type ChildProcess } from 'child_process';
+import fs from 'fs';
 import path from 'path';
 import { PKG_DIR } from '../shared/paths.js';
 import { log } from '../shared/logger.js';
@@ -10,6 +11,8 @@ let intentionallyStopped = false;
 const MAX_RESTARTS = 3;
 const STABLE_THRESHOLD = 30_000; // 30s — if backend ran this long, it wasn't a crash loop
 
+const LOG_FILE = path.join(PKG_DIR, 'workspace', '.backend.log');
+
 export function getBackendPort(basePort: number): number {
   return basePort + 4;
 }
@@ -19,6 +22,9 @@ export function spawnBackend(port: number): ChildProcess {
   lastSpawnTime = Date.now();
   intentionallyStopped = false;
 
+  // Clear log file on each restart — only keeps current run
+  try { fs.writeFileSync(LOG_FILE, ''); } catch {}
+
   child = spawn(process.execPath, ['--import', 'tsx/esm', backendPath], {
     cwd: path.join(PKG_DIR, 'workspace'),
     stdio: ['ignore', 'pipe', 'pipe'],
@@ -27,10 +33,12 @@ export function spawnBackend(port: number): ChildProcess {
 
   child.stdout?.on('data', (d) => {
     process.stdout.write(d);
+    try { fs.appendFileSync(LOG_FILE, d); } catch {}
   });
 
   child.stderr?.on('data', (d) => {
     process.stderr.write(d);
+    try { fs.appendFileSync(LOG_FILE, d); } catch {}
   });
 
   child.on('exit', (code) => {
@@ -56,10 +64,26 @@ export function spawnBackend(port: number): ChildProcess {
   return child;
 }
 
-export function stopBackend(): void {
-  intentionallyStopped = true;
-  child?.kill();
-  child = null;
+/** Stop the backend and wait for the process to fully exit before resolving.
+ *  This prevents port collisions when restarting (old process must release the port first). */
+export function stopBackend(): Promise<void> {
+  return new Promise((resolve) => {
+    if (!child || child.exitCode !== null) {
+      child = null;
+      resolve();
+      return;
+    }
+    intentionallyStopped = true;
+    const dying = child;
+    child = null;
+    dying.once('exit', () => resolve());
+    dying.kill();
+    // Safety: force kill after 3s if SIGTERM doesn't work
+    setTimeout(() => {
+      try { dying.kill('SIGKILL'); } catch {}
+      resolve();
+    }, 3000);
+  });
 }
 
 export function isBackendAlive(): boolean {

package/supervisor/index.ts

@@ -507,8 +507,7 @@ export async function startSupervisor() {
                   console.log('[supervisor] Agent turn ended — restarting backend');
                   pendingBackendRestart = false;
                   resetBackendRestarts();
-                  stopBackend();
-                  spawnBackend(backendPort);
+                  stopBackend().then(() => spawnBackend(backendPort));
                 }
                 return; // don't forward bot:done to client
               }
@@ -640,9 +639,9 @@ export async function startSupervisor() {
   startScheduler({
     broadcastFluxy,
     workerApi,
-    restartBackend: () => {
+    restartBackend: async () => {
       resetBackendRestarts();
-      stopBackend();
+      await stopBackend();
       spawnBackend(backendPort);
     },
     getModel: () => loadConfig().ai.model,
@@ -662,10 +661,10 @@ export async function startSupervisor() {
       return;
     }
     if (backendRestartTimer) clearTimeout(backendRestartTimer);
-    backendRestartTimer = setTimeout(() => {
+    backendRestartTimer = setTimeout(async () => {
       log.info(`[watcher] ${reason} — restarting backend...`);
       resetBackendRestarts();
-      stopBackend();
+      await stopBackend();
       spawnBackend(backendPort);
     }, 1000);
   }
@@ -715,18 +714,27 @@ export async function startSupervisor() {
         }
       }
 
-      // Poll until the full chain is actually working (avoid 502s)
-      // Cache-busting query param prevents browsers/CDN from serving stale 502s
+      // Poll until the full relay→tunnel→server chain is actually working.
+      // A 502/503 means the relay can't reach the tunnel yet; anything else
+      // (200, 401, 403, etc.) means the chain is live.
       const probeUrl = config.relay?.url || tunnelUrl;
       let ready = false;
-      for (let i = 0; i < 20; i++) {
+      log.info(`Readiness probe: polling ${probeUrl}`);
+      for (let i = 0; i < 30; i++) {
         try {
           const res = await fetch(probeUrl + `/api/health?_cb=${Date.now()}`, {
             signal: AbortSignal.timeout(3000),
-            headers: { 'Cache-Control': 'no-cache' },
+            headers: { 'Cache-Control': 'no-cache, no-store' },
           });
-          if (res.ok) { ready = true; break; }
-        } catch {}
+          log.info(`Readiness probe #${i + 1}: ${res.status}`);
+          // Any non-502/503 means the relay is reaching the tunnel
+          if (res.status !== 502 && res.status !== 503) {
+            ready = true;
+            break;
+          }
+        } catch (err) {
+          log.info(`Readiness probe #${i + 1}: ${err instanceof Error ? err.message : 'error'}`);
+        }
         await new Promise(r => setTimeout(r, 1000));
       }
       if (!ready) {
@@ -790,7 +798,7 @@ export async function startSupervisor() {
     delete latestConfig.tunnelUrl;
     saveConfig(latestConfig);
     stopWorker();
-    stopBackend();
+    await stopBackend();
     stopTunnel();
     console.log('[supervisor] Stopping Vite dev servers...');
     await stopViteDevServers();

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

@@ -230,7 +230,7 @@ The supervisor manages the backend process. You don't need to manage it yourself
 
 **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.
+**If the backend crashes:** It auto-restarts up to 3 times. If it keeps crashing, read `.backend.log` to see the error output, then fix the code. The log file is cleared on each restart so it only contains the current/last run — no need to truncate it yourself.
 
 **NEVER do these:**
 - Never `kill` processes or run `pkill`/`killall` — you don't manage the supervisor or its children