fluxy-bot 0.12.1 → 0.12.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluxy-bot",
-  "version": "0.12.1",
+  "version": "0.12.3",
   "releaseNotes": [
     "Adding a way for users to claim their fluxies on the fluxy.bot dashboard",
     "2. ",

package/supervisor/backend.ts

@@ -97,31 +97,47 @@ export function spawnBackend(port: number): ChildProcess {
 }
 
 /** 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). */
+ *  This prevents port collisions when restarting (old process must release the port first).
+ *  Concurrent calls return the same promise to avoid double-spawn races. */
+let stopPromise: Promise<void> | null = null;
+
 export function stopBackend(): Promise<void> {
-  return new Promise((resolve) => {
-    if (!child || child.exitCode !== null) {
-      child = null;
-      resolve();
-      return;
-    }
-    intentionallyStopped = true;
-    const dying = child;
+  if (stopPromise) return stopPromise;
+
+  if (!child || child.exitCode !== null) {
     child = null;
-    dying.once('exit', () => resolve());
+    return Promise.resolve();
+  }
+
+  intentionallyStopped = true;
+  const dying = child;
+  child = null;
+
+  stopPromise = new Promise<void>((resolve) => {
+    dying.once('exit', () => {
+      stopPromise = null;
+      resolve();
+    });
     dying.kill();
     // Safety: force kill after 3s if SIGTERM doesn't work
     setTimeout(() => {
       try { dying.kill('SIGKILL'); } catch {}
+      stopPromise = null;
       resolve();
     }, 3000);
   });
+
+  return stopPromise;
 }
 
 export function isBackendAlive(): boolean {
   return child !== null && child.exitCode === null;
 }
 
+export function isBackendStopping(): boolean {
+  return stopPromise !== null;
+}
+
 export function resetBackendRestarts(): void {
   restarts = 0;
 }

package/supervisor/index.ts

@@ -11,7 +11,7 @@ import { log } from '../shared/logger.js';
 import { startTunnel, stopTunnel, isTunnelAlive, restartTunnel, startNamedTunnel, restartNamedTunnel } from './tunnel.js';
 import { createWorkerApp } from '../worker/index.js';
 import { closeDb, getSession, getSetting } from '../worker/db.js';
-import { spawnBackend, stopBackend, getBackendPort, isBackendAlive, resetBackendRestarts } from './backend.js';
+import { spawnBackend, stopBackend, getBackendPort, isBackendAlive, isBackendStopping, resetBackendRestarts } from './backend.js';
 import { updateTunnelUrl, startHeartbeat, stopHeartbeat, disconnect } from '../shared/relay.js';
 import { startFluxyAgentQuery, stopFluxyAgentQuery, type RecentMessage } from './fluxy-agent.js';
 import { ensureFileDirs, saveAttachment, type SavedFile } from './file-saver.js';
@@ -341,7 +341,7 @@ export async function startSupervisor() {
 
     // App API routes → proxy to user's backend server
     if (req.url?.startsWith('/app/api')) {
-      const backendPath = req.url.replace(/^\/app\/api/, '') || '/';
+      const backendPath = req.url.replace(/^\/app/, '');
       console.log(`[supervisor] → backend :${backendPort} | ${req.method} ${backendPath}`);
       if (!isBackendAlive()) {
         console.log('[supervisor] Backend down — returning 503');
@@ -473,7 +473,7 @@ export async function startSupervisor() {
       if (msg.type !== 'app:api' || !msg.data) return;
 
       const { id, method, path: reqPath, headers: reqHeaders, body } = msg.data;
-      const backendPath = (reqPath || '').replace(/^\/app\/api/, '') || '/';
+      const backendPath = (reqPath || '').replace(/^\/app/, '');
 
       console.log(`[supervisor] App WS → backend :${backendPort} | ${method} ${backendPath} (${id})`);
 
@@ -860,6 +860,7 @@ export async function startSupervisor() {
                 if (eventData.usedFileTools || pendingBackendRestart) {
                   console.log('[supervisor] Agent turn ended — restarting backend');
                   pendingBackendRestart = false;
+                  if (backendRestartTimer) { clearTimeout(backendRestartTimer); backendRestartTimer = null; }
                   resetBackendRestarts();
                   stopBackend().then(() => spawnBackend(backendPort));
                 }
@@ -1058,8 +1059,11 @@ export async function startSupervisor() {
       pendingBackendRestart = true;
       return;
     }
+    // Skip if a stop/restart is already in progress (bot:done handler owns the restart)
+    if (isBackendStopping()) return;
     if (backendRestartTimer) clearTimeout(backendRestartTimer);
     backendRestartTimer = setTimeout(async () => {
+      if (isBackendStopping()) return; // re-check after delay
       log.info(`[watcher] ${reason} — restarting backend...`);
       resetBackendRestarts();
       await stopBackend();

package/vite.config.ts

@@ -25,7 +25,7 @@ export default defineConfig({
     proxy: {
       '/app/api': {
         target: 'http://localhost:3004',
-        rewrite: (path) => path.replace(/^\/app\/api/, '') || '/',
+        rewrite: (path) => path.replace(/^\/app/, ''),
       },
       '/api': 'http://localhost:3000',
     },

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

@@ -260,16 +260,16 @@ Your working directory is the `workspace/` folder. This is your full-stack works
 
 ## Backend Routing (Critical)
 
-A supervisor process sits in front of everything on port 3000. It strips the `/app/api` prefix before forwarding to the backend.
+A supervisor process sits in front of everything on port 3000. It strips the `/app` prefix before forwarding to the backend, preserving the `/api/` path.
 
 ```
-Browser: GET /app/api/tasks → Supervisor strips prefix → Backend receives: GET /tasks
+Browser: GET /app/api/tasks → Supervisor strips /app → Backend receives: GET /api/tasks
 ```
 
 **The rules:**
 - **Frontend** fetch calls: use `/app/api/...`
-- **Backend** Express routes: register as `/tasks`, `/health` — NO `/app/api` prefix
-- No exceptions
+- **Backend** Express routes: register as `/api/tasks`, `/api/health` — standard Express convention with `/api/` prefix
+- The `/app` prefix is what distinguishes workspace backend routes from system routes
 
 **Tunnel reliability:** All `/app/api/*` fetch calls from the dashboard are automatically proxied through WebSocket when available. This is transparent — just use `fetch('/app/api/...')` normally. The WebSocket proxy activates automatically and falls back to regular HTTP if unavailable. You don't need to handle this in your code.
 
@@ -367,6 +367,7 @@ There are TWO completely separate password systems in Fluxy. Understanding the d
 POST /app/api/workspace/set-password
 Body: { "password": "the_password" }
 ```
+(The backend route is `/api/workspace/set-password` — the supervisor strips `/app` from the frontend URL.)
 
 **How to remove it:**
 ```

package/workspace/backend/index.ts

@@ -28,7 +28,7 @@ const app = express();
 app.use(express.json());
 
 // Health check
-app.get('/health', (_req, res) => {
+app.get('/api/health', (_req, res) => {
   res.json({ status: 'ok' });
 });