fluxy-bot 0.8.9 → 0.9.0

package/supervisor/index.ts

@@ -4,51 +4,16 @@ import fs from 'fs';
 import path from 'path';
 import { WebSocketServer, WebSocket } from 'ws';
 import { loadConfig, saveConfig } from '../shared/config.js';
-import {
-    createProvider,
-    type AiProvider,
-    type ChatMessage
-} from '../shared/ai.js';
+import { createProvider, type AiProvider, type ChatMessage } from '../shared/ai.js';
 import { paths } from '../shared/paths.js';
-import { PKG_DIR, WORKSPACE_DIR } from '../shared/paths.js';
+import { PKG_DIR } from '../shared/paths.js';
 import { log } from '../shared/logger.js';
-import {
-    startTunnel,
-    stopTunnel,
-    isTunnelAlive,
-    restartTunnel,
-    startNamedTunnel,
-    restartNamedTunnel
-} from './tunnel.js';
-import {
-    spawnWorker,
-    stopWorker,
-    getWorkerPort,
-    isWorkerAlive
-} from './worker.js';
-import {
-    spawnBackend,
-    stopBackend,
-    getBackendPort,
-    isBackendAlive,
-    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';
+import { startTunnel, stopTunnel, isTunnelAlive, restartTunnel, startNamedTunnel, restartNamedTunnel } from './tunnel.js';
+import { spawnWorker, stopWorker, getWorkerPort, isWorkerAlive } from './worker.js';
+import { spawnBackend, stopBackend, getBackendPort, isBackendAlive, 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';
 import { startViteDevServers, stopViteDevServers } from './vite-dev.js';
 import { startScheduler, stopScheduler } from './scheduler.js';
 import { execSync, spawn as cpSpawn } from 'child_process';
@@ -57,30 +22,28 @@ const DIST_FLUXY = path.join(PKG_DIR, 'dist-fluxy');
 
 // Ensure dist-fluxy exists (postinstall may have failed silently)
 if (!fs.existsSync(DIST_FLUXY)) {
-    log.info('Building fluxy chat UI (first run)...');
-    try {
-        execSync('npx vite build --config vite.fluxy.config.ts', {
-            cwd: PKG_DIR,
-            stdio: 'ignore'
-        });
-        log.ok('Fluxy chat UI built');
-    } catch (err) {
-        log.warn(
-            `Failed to build fluxy chat UI: ${err instanceof Error ? err.message : err}`
-        );
-    }
+  log.info('Building fluxy chat UI (first run)...');
+  try {
+    execSync('npx vite build --config vite.fluxy.config.ts', {
+      cwd: PKG_DIR,
+      stdio: 'ignore',
+    });
+    log.ok('Fluxy chat UI built');
+  } catch (err) {
+    log.warn(`Failed to build fluxy chat UI: ${err instanceof Error ? err.message : err}`);
+  }
 }
 
 const MIME_TYPES: Record<string, string> = {
-    '.html': 'text/html',
-    '.js': 'application/javascript',
-    '.css': 'text/css',
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.svg': 'image/svg+xml',
-    '.webm': 'video/webm',
-    '.woff2': 'font/woff2',
-    '.json': 'application/json'
+  '.html': 'text/html',
+  '.js': 'application/javascript',
+  '.css': 'text/css',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.svg': 'image/svg+xml',
+  '.webm': 'video/webm',
+  '.woff2': 'font/woff2',
+  '.json': 'application/json',
 };
 
 // Service worker content — embedded here so it ships with supervisor/ (always updated)
@@ -128,1286 +91,955 @@ div{text-align:center}h1{font-size:18px;margin-bottom:8px;color:#e2e8f0}p{font-s
 <script src="/fluxy/widget.js"></script></body></html>`;
 
 export async function startSupervisor() {
-    const config = loadConfig();
-    const workerPort = getWorkerPort(config.port);
-    const backendPort = getBackendPort(config.port);
-
-    // Create HTTP server first (Vite needs it for HMR WebSocket)
-    // The request handler is set up later via server.on('request')
-    const server = http.createServer();
-
-    // Start Vite dev server — pass supervisor server so Vite attaches HMR WebSocket directly
-    console.log('[supervisor] Starting Vite dev server...');
-    const vitePorts = await startViteDevServers(config.port, server);
-    console.log(`[supervisor] Vite ready — dashboard :${vitePorts.dashboard}`);
-    console.log(
-        `[supervisor] Upgrade listeners on server: ${server.listenerCount('upgrade')}`
-    );
-
-    // Ensure file storage dirs exist
-    ensureFileDirs();
-
-    // Fluxy's AI brain
-    let ai: AiProvider | null = null;
-    if (
-        config.ai.provider &&
-        (config.ai.apiKey || config.ai.provider === 'ollama')
-    ) {
-        ai = createProvider(
-            config.ai.provider,
-            config.ai.apiKey,
-            config.ai.baseUrl
-        );
+  const config = loadConfig();
+  const workerPort = getWorkerPort(config.port);
+  const backendPort = getBackendPort(config.port);
+
+  // Create HTTP server first (Vite needs it for HMR WebSocket)
+  // The request handler is set up later via server.on('request')
+  const server = http.createServer();
+
+  // Start Vite dev server — pass supervisor server so Vite attaches HMR WebSocket directly
+  console.log('[supervisor] Starting Vite dev server...');
+  const vitePorts = await startViteDevServers(config.port, server);
+  console.log(`[supervisor] Vite ready — dashboard :${vitePorts.dashboard}`);
+  console.log(`[supervisor] Upgrade listeners on server: ${server.listenerCount('upgrade')}`);
+
+  // Ensure file storage dirs exist
+  ensureFileDirs();
+
+  // Fluxy's AI brain
+  let ai: AiProvider | null = null;
+  if (config.ai.provider && (config.ai.apiKey || config.ai.provider === 'ollama')) {
+    ai = createProvider(config.ai.provider, config.ai.apiKey, config.ai.baseUrl);
+  }
+
+  // Fluxy chat conversations (in-memory for now)
+  const conversations = new Map<WebSocket, ChatMessage[]>();
+
+  // Track active DB conversation per WS client
+  const clientConvs = new Map<WebSocket, string>();
+
+  // Track current stream state so reconnecting clients get caught up
+  let currentStreamConvId: string | null = null;
+  let currentStreamBuffer = '';
+
+  /** Call worker API endpoints */
+  async function workerApi(path: string, method = 'GET', body?: any) {
+    const opts: RequestInit = { method, headers: { 'Content-Type': 'application/json' } };
+    if (body) opts.body = JSON.stringify(body);
+    const res = await fetch(`http://127.0.0.1:${workerPort}${path}`, opts);
+    return res.json();
+  }
+
+  /** Broadcast to all fluxy WS clients EXCEPT sender */
+  function broadcastFluxyExcept(sender: WebSocket, type: string, data: any) {
+    const msg = JSON.stringify({ type, data });
+    for (const client of fluxyWss.clients) {
+      if (client !== sender && client.readyState === WebSocket.OPEN) client.send(msg);
     }
+  }
 
-    // Fluxy chat conversations (in-memory for now)
-    const conversations = new Map<WebSocket, ChatMessage[]>();
-
-    // Track active DB conversation per WS client
-    const clientConvs = new Map<WebSocket, string>();
-
-    // Track current stream state so reconnecting clients get caught up
-    let currentStreamConvId: string | null = null;
-    let currentStreamBuffer = '';
-
-    /** Call worker API endpoints */
-    async function workerApi(path: string, method = 'GET', body?: any) {
-        const opts: RequestInit = {
-            method,
-            headers: { 'Content-Type': 'application/json' }
-        };
-        if (body) opts.body = JSON.stringify(body);
-        const res = await fetch(`http://127.0.0.1:${workerPort}${path}`, opts);
-        return res.json();
-    }
+  // ── Auth middleware ──
+  const tokenCache = new Map<string, number>(); // token → expiry timestamp
+  const TOKEN_CACHE_TTL = 60_000; // 60s
 
-    /** Broadcast to all fluxy WS clients EXCEPT sender */
-    function broadcastFluxyExcept(sender: WebSocket, type: string, data: any) {
-        const msg = JSON.stringify({ type, data });
-        for (const client of fluxyWss.clients) {
-            if (client !== sender && client.readyState === WebSocket.OPEN)
-                client.send(msg);
-        }
-    }
+  async function validateToken(token: string): Promise<boolean> {
+    const cached = tokenCache.get(token);
+    if (cached && cached > Date.now()) return true;
 
-    // ── Auth middleware ──
-    const tokenCache = new Map<string, number>(); // token → expiry timestamp
-    const TOKEN_CACHE_TTL = 60_000; // 60s
-
-    async function validateToken(token: string): Promise<boolean> {
-        const cached = tokenCache.get(token);
-        if (cached && cached > Date.now()) return true;
-
-        try {
-            const res = await fetch(
-                `http://127.0.0.1:${workerPort}/api/portal/validate-token`,
-                {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ token })
-                }
-            );
-            const data = (await res.json()) as { valid: boolean };
-            if (data.valid) {
-                tokenCache.set(token, Date.now() + TOKEN_CACHE_TTL);
-                return true;
-            }
-            tokenCache.delete(token);
-            return false;
-        } catch {
-            return false;
-        }
+    try {
+      const res = await fetch(`http://127.0.0.1:${workerPort}/api/portal/validate-token`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ token }),
+      });
+      const data = await res.json() as { valid: boolean };
+      if (data.valid) {
+        tokenCache.set(token, Date.now() + TOKEN_CACHE_TTL);
+        return true;
+      }
+      tokenCache.delete(token);
+      return false;
+    } catch {
+      return false;
     }
+  }
 
-    let authRequiredCache: { value: boolean; expires: number } | null = null;
+  let authRequiredCache: { value: boolean; expires: number } | null = null;
 
-    async function isAuthRequired(): Promise<boolean> {
-        if (authRequiredCache && authRequiredCache.expires > Date.now())
-            return authRequiredCache.value;
-        try {
-            const res = await fetch(
-                `http://127.0.0.1:${workerPort}/api/onboard/status`
-            );
-            const data = (await res.json()) as { portalConfigured: boolean };
-            const required = !!data.portalConfigured;
-            authRequiredCache = {
-                value: required,
-                expires: Date.now() + 30_000
-            };
-            return required;
-        } catch {
-            return false;
-        }
+  async function isAuthRequired(): Promise<boolean> {
+    if (authRequiredCache && authRequiredCache.expires > Date.now()) return authRequiredCache.value;
+    try {
+      const res = await fetch(`http://127.0.0.1:${workerPort}/api/onboard/status`);
+      const data = await res.json() as { portalConfigured: boolean };
+      const required = !!data.portalConfigured;
+      authRequiredCache = { value: required, expires: Date.now() + 30_000 };
+      return required;
+    } catch {
+      return false;
+    }
+  }
+
+  const AUTH_EXEMPT_ROUTES = [
+    'POST /api/portal/login',
+    'GET /api/portal/login',
+    'POST /api/portal/validate-token',
+    'GET /api/portal/validate-token',
+    'GET /api/onboard/status',
+    'GET /api/health',
+    'POST /api/onboard',
+    'GET /api/push/vapid-public-key',
+    'GET /api/push/status',
+    'POST /api/auth/claude/start',
+    'POST /api/auth/claude/exchange',
+    'GET /api/auth/claude/status',
+    'POST /api/auth/codex/start',
+    'POST /api/auth/codex/cancel',
+    'GET /api/auth/codex/status',
+    'POST /api/portal/totp/setup',
+    'POST /api/portal/totp/verify-setup',
+    'POST /api/portal/totp/disable',
+    'GET /api/portal/totp/status',
+    'GET /api/portal/login/totp',
+    'POST /api/portal/devices/revoke',
+  ];
+
+  function isExemptRoute(method: string, url: string): boolean {
+    const path = url.split('?')[0];
+    return AUTH_EXEMPT_ROUTES.some((r) => {
+      const [m, p] = r.split(' ');
+      return method === m && path === p;
+    });
+  }
+
+  // HTTP request handler — proxies to Vite dev servers + worker API
+  server.on('request', async (req, res) => {
+    // Fluxy widget — served directly (not part of Vite build)
+    if (req.url === '/fluxy/widget.js') {
+      console.log('[supervisor] Serving /fluxy/widget.js directly');
+      res.writeHead(200, { 'Content-Type': 'application/javascript', 'Cache-Control': 'no-cache' });
+      res.end(fs.readFileSync(paths.widgetJs));
+      return;
     }
 
-    const AUTH_EXEMPT_ROUTES = [
-        'POST /api/portal/login',
-        'GET /api/portal/login',
-        'POST /api/portal/validate-token',
-        'GET /api/portal/validate-token',
-        'GET /api/onboard/status',
-        'GET /api/health',
-        'POST /api/onboard',
-        'GET /api/push/vapid-public-key',
-        'GET /api/push/status',
-        'POST /api/auth/claude/start',
-        'POST /api/auth/claude/exchange',
-        'GET /api/auth/claude/status',
-        'POST /api/auth/codex/start',
-        'POST /api/auth/codex/cancel',
-        'GET /api/auth/codex/status',
-        'POST /api/portal/totp/setup',
-        'POST /api/portal/totp/verify-setup',
-        'POST /api/portal/totp/disable',
-        'GET /api/portal/totp/status',
-        'GET /api/portal/login/totp',
-        'POST /api/portal/devices/revoke'
-    ];
-
-    function isExemptRoute(method: string, url: string): boolean {
-        const path = url.split('?')[0];
-        return AUTH_EXEMPT_ROUTES.some(r => {
-            const [m, p] = r.split(' ');
-            return method === m && path === p;
-        });
+    // Service worker — served from embedded constant (supervisor/ is always updated)
+    if (req.url === '/sw.js' || req.url === '/fluxy/sw.js') {
+      res.writeHead(200, { 'Content-Type': 'application/javascript', 'Cache-Control': 'no-cache' });
+      res.end(SW_JS);
+      return;
     }
 
-    // HTTP request handler — proxies to Vite dev servers + worker API
-    server.on('request', async (req, res) => {
-        // Fluxy widget — served directly (not part of Vite build)
-        if (req.url === '/fluxy/widget.js') {
-            console.log('[supervisor] Serving /fluxy/widget.js directly');
-            res.writeHead(200, {
-                'Content-Type': 'application/javascript',
-                'Cache-Control': 'no-cache'
-            });
-            res.end(fs.readFileSync(paths.widgetJs));
-            return;
-        }
+    // App API routes → proxy to user's backend server
+    if (req.url?.startsWith('/app/api')) {
+      const backendPath = req.url.replace(/^\/app\/api/, '') || '/';
+      console.log(`[supervisor] → backend :${backendPort} | ${req.method} ${backendPath}`);
+      if (!isBackendAlive()) {
+        console.log('[supervisor] Backend down — returning 503');
+        res.writeHead(503, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Backend is starting...' }));
+        return;
+      }
 
-        // Service worker — served from embedded constant (supervisor/ is always updated)
-        if (req.url === '/sw.js' || req.url === '/fluxy/sw.js') {
-            res.writeHead(200, {
-                'Content-Type': 'application/javascript',
-                'Cache-Control': 'no-cache'
-            });
-            res.end(SW_JS);
-            return;
-        }
+      const proxy = http.request(
+        { host: '127.0.0.1', port: backendPort, path: backendPath, method: req.method, headers: req.headers },
+        (proxyRes) => {
+          res.writeHead(proxyRes.statusCode!, proxyRes.headers);
+          proxyRes.pipe(res);
+        },
+      );
+      proxy.on('error', (e) => {
+        console.error(`[supervisor] Backend proxy error: ${req.url}`, e.message);
+        res.writeHead(503, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Backend unavailable' }));
+      });
+      req.pipe(proxy);
+      return;
+    }
 
-        // App API routes → proxy to user's backend server
-        if (req.url?.startsWith('/app/api')) {
-            const backendPath = req.url.replace(/^\/app\/api/, '') || '/';
-            console.log(
-                `[supervisor] → backend :${backendPort} | ${req.method} ${backendPath}`
-            );
-            if (!isBackendAlive()) {
-                console.log('[supervisor] Backend down — returning 503');
-                res.writeHead(503, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Backend is starting...' }));
-                return;
-            }
+    // API routes → proxy to worker
+    if (req.url?.startsWith('/api')) {
+      console.log(`[supervisor] → worker :${workerPort} | ${req.method} ${req.url}`);
+      if (!isWorkerAlive()) {
+        console.log('[supervisor] Worker down — returning 503');
+        res.writeHead(503, { 'Content-Type': 'text/html' });
+        res.end(RECOVERING_HTML);
+        return;
+      }
 
-            const proxy = http.request(
-                {
-                    host: '127.0.0.1',
-                    port: backendPort,
-                    path: backendPath,
-                    method: req.method,
-                    headers: req.headers
-                },
-                proxyRes => {
-                    res.writeHead(proxyRes.statusCode!, proxyRes.headers);
-                    proxyRes.pipe(res);
-                }
-            );
-            proxy.on('error', e => {
-                console.error(
-                    `[supervisor] Backend proxy error: ${req.url}`,
-                    e.message
-                );
-                res.writeHead(503, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Backend unavailable' }));
-            });
-            req.pipe(proxy);
+      // Auth check for mutation routes (POST/PUT/DELETE) — GET/HEAD are read-only, skip auth
+      const method = req.method || 'GET';
+      if (method !== 'GET' && method !== 'HEAD' && !isExemptRoute(method, req.url || '')) {
+        const needsAuth = await isAuthRequired();
+        if (needsAuth) {
+          const authHeader = req.headers['authorization'];
+          const token = authHeader?.startsWith('Bearer ') ? authHeader.slice(7) : null;
+          if (!token || !(await validateToken(token))) {
+            res.writeHead(401, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Unauthorized' }));
             return;
+          }
         }
+      }
 
-        // API routes → proxy to worker
-        if (req.url?.startsWith('/api')) {
-            console.log(
-                `[supervisor] → worker :${workerPort} | ${req.method} ${req.url}`
-            );
-            if (!isWorkerAlive()) {
-                console.log('[supervisor] Worker down — returning 503');
-                res.writeHead(503, { 'Content-Type': 'text/html' });
-                res.end(RECOVERING_HTML);
-                return;
-            }
-
-            // Auth check for mutation routes (POST/PUT/DELETE) — GET/HEAD are read-only, skip auth
-            const method = req.method || 'GET';
-            if (
-                method !== 'GET' &&
-                method !== 'HEAD' &&
-                !isExemptRoute(method, req.url || '')
-            ) {
-                const needsAuth = await isAuthRequired();
-                if (needsAuth) {
-                    const authHeader = req.headers['authorization'];
-                    const token = authHeader?.startsWith('Bearer ')
-                        ? authHeader.slice(7)
-                        : null;
-                    if (!token || !(await validateToken(token))) {
-                        res.writeHead(401, {
-                            'Content-Type': 'application/json'
-                        });
-                        res.end(JSON.stringify({ error: 'Unauthorized' }));
-                        return;
-                    }
-                }
-            }
-
-            const proxy = http.request(
-                {
-                    host: '127.0.0.1',
-                    port: workerPort,
-                    path: req.url,
-                    method: req.method,
-                    headers: req.headers
-                },
-                proxyRes => {
-                    res.writeHead(proxyRes.statusCode!, proxyRes.headers);
-                    proxyRes.pipe(res);
-                }
-            );
-            proxy.on('error', e => {
-                console.error(
-                    `[supervisor] Worker proxy error: ${req.url}`,
-                    e.message
-                );
-                res.writeHead(503, { 'Content-Type': 'text/html' });
-                res.end(RECOVERING_HTML);
-            });
-            req.pipe(proxy);
-            return;
-        }
+      const proxy = http.request(
+        { host: '127.0.0.1', port: workerPort, path: req.url, method: req.method, headers: req.headers },
+        (proxyRes) => {
+          res.writeHead(proxyRes.statusCode!, proxyRes.headers);
+          proxyRes.pipe(res);
+        },
+      );
+      proxy.on('error', (e) => {
+        console.error(`[supervisor] Worker proxy error: ${req.url}`, e.message);
+        res.writeHead(503, { 'Content-Type': 'text/html' });
+        res.end(RECOVERING_HTML);
+      });
+      req.pipe(proxy);
+      return;
+    }
 
-        // Fluxy routes → serve pre-built static files from dist-fluxy/
-        // Note: must check '/fluxy/' (with slash) to avoid matching '/fluxy_tilts.webm' etc.
-        if (req.url === '/fluxy' || req.url?.startsWith('/fluxy/')) {
-            // Strip /fluxy prefix and resolve file path
-            let filePath = req.url!.replace(/^\/fluxy\/?/, '') || 'fluxy.html';
-            // Strip query strings (e.g. ?v=xxx)
-            filePath = filePath.split('?')[0];
-            const fullPath = path.join(DIST_FLUXY, filePath);
-
-            // Security: prevent directory traversal
-            if (!fullPath.startsWith(DIST_FLUXY)) {
-                res.writeHead(403);
-                res.end('Forbidden');
-                return;
-            }
+    // Fluxy routes → serve pre-built static files from dist-fluxy/
+    // Note: must check '/fluxy/' (with slash) to avoid matching '/fluxy_tilts.webm' etc.
+    if (req.url === '/fluxy' || req.url?.startsWith('/fluxy/')) {
+      // Strip /fluxy prefix and resolve file path
+      let filePath = req.url!.replace(/^\/fluxy\/?/, '') || 'fluxy.html';
+      // Strip query strings (e.g. ?v=xxx)
+      filePath = filePath.split('?')[0];
+      const fullPath = path.join(DIST_FLUXY, filePath);
+
+      // Security: prevent directory traversal
+      if (!fullPath.startsWith(DIST_FLUXY)) {
+        res.writeHead(403);
+        res.end('Forbidden');
+        return;
+      }
 
-            try {
-                const stat = fs.statSync(fullPath);
-                if (stat.isFile()) {
-                    const ext = path.extname(fullPath);
-                    const mime = MIME_TYPES[ext] || 'application/octet-stream';
-                    // HTML files: no-cache so rebuilds are picked up immediately
-                    // Hashed assets (.js, .css): immutable caching
-                    const cacheControl =
-                        ext === '.html'
-                            ? 'no-cache'
-                            : 'public, max-age=31536000, immutable';
-                    res.writeHead(200, {
-                        'Content-Type': mime,
-                        'Cache-Control': cacheControl
-                    });
-                    fs.createReadStream(fullPath).pipe(res);
-                } else {
-                    res.writeHead(404);
-                    res.end('Not found');
-                }
-            } catch {
-                res.writeHead(404);
-                res.end('Not found');
-            }
-            return;
+      try {
+        const stat = fs.statSync(fullPath);
+        if (stat.isFile()) {
+          const ext = path.extname(fullPath);
+          const mime = MIME_TYPES[ext] || 'application/octet-stream';
+          // HTML files: no-cache so rebuilds are picked up immediately
+          // Hashed assets (.js, .css): immutable caching
+          const cacheControl = ext === '.html' ? 'no-cache' : 'public, max-age=31536000, immutable';
+          res.writeHead(200, { 'Content-Type': mime, 'Cache-Control': cacheControl });
+          fs.createReadStream(fullPath).pipe(res);
+        } else {
+          res.writeHead(404);
+          res.end('Not found');
         }
+      } catch {
+        res.writeHead(404);
+        res.end('Not found');
+      }
+      return;
+    }
 
-        // Everything else → proxy to dashboard Vite dev server
-        console.log(
-            `[supervisor] → dashboard Vite :${vitePorts.dashboard} | ${req.method} ${req.url}`
-        );
-        const proxy = http.request(
-            {
-                host: '127.0.0.1',
-                port: vitePorts.dashboard,
-                path: req.url,
-                method: req.method,
-                headers: req.headers
-            },
-            proxyRes => {
-                res.writeHead(proxyRes.statusCode!, proxyRes.headers);
-                proxyRes.pipe(res);
-            }
-        );
-        proxy.on('error', e => {
-            console.error(
-                `[supervisor] Dashboard Vite proxy error: ${req.url}`,
-                e.message
-            );
-            res.writeHead(503, { 'Content-Type': 'text/html' });
-            res.end(RECOVERING_HTML);
-        });
-        req.pipe(proxy);
+    // Everything else → proxy to dashboard Vite dev server
+    console.log(`[supervisor] → dashboard Vite :${vitePorts.dashboard} | ${req.method} ${req.url}`);
+    const proxy = http.request(
+      { host: '127.0.0.1', port: vitePorts.dashboard, path: req.url, method: req.method, headers: req.headers },
+      (proxyRes) => {
+        res.writeHead(proxyRes.statusCode!, proxyRes.headers);
+        proxyRes.pipe(res);
+      },
+    );
+    proxy.on('error', (e) => {
+      console.error(`[supervisor] Dashboard Vite proxy error: ${req.url}`, e.message);
+      res.writeHead(503, { 'Content-Type': 'text/html' });
+      res.end(RECOVERING_HTML);
     });
+    req.pipe(proxy);
+  });
 
-    // WebSocket: Fluxy chat + proxy worker WS
-    const fluxyWss = new WebSocketServer({ noServer: true });
+  // WebSocket: Fluxy chat + proxy worker WS
+  const fluxyWss = new WebSocketServer({ noServer: true });
 
-    /** Send a message to all connected fluxy WS clients */
-    function broadcastFluxy(type: string, data: any = {}) {
-        const msg = JSON.stringify({ type, data });
-        for (const client of fluxyWss.clients) {
-            if (client.readyState === WebSocket.OPEN) client.send(msg);
-        }
+  /** Send a message to all connected fluxy WS clients */
+  function broadcastFluxy(type: string, data: any = {}) {
+    const msg = JSON.stringify({ type, data });
+    for (const client of fluxyWss.clients) {
+      if (client.readyState === WebSocket.OPEN) client.send(msg);
+    }
+  }
+
+  fluxyWss.on('connection', (ws) => {
+    log.info('Fluxy chat connected');
+    let convId = Math.random().toString(36).slice(2) + Date.now().toString(36);
+    conversations.set(ws, []);
+
+    // Send current streaming state so reconnecting clients can catch up
+    if (agentQueryActive && currentStreamConvId) {
+      ws.send(JSON.stringify({
+        type: 'chat:state',
+        data: {
+          streaming: true,
+          conversationId: currentStreamConvId,
+          buffer: currentStreamBuffer,
+        },
+      }));
     }
 
-    fluxyWss.on('connection', ws => {
-        log.info('Fluxy chat connected');
-        let convId =
-            Math.random().toString(36).slice(2) + Date.now().toString(36);
-        conversations.set(ws, []);
-
-        // Send current streaming state so reconnecting clients can catch up
-        if (agentQueryActive && currentStreamConvId) {
-            ws.send(
-                JSON.stringify({
-                    type: 'chat:state',
-                    data: {
-                        streaming: true,
-                        conversationId: currentStreamConvId,
-                        buffer: currentStreamBuffer
-                    }
-                })
-            );
-        }
-
-        ws.on('message', raw => {
-            const rawStr = raw.toString();
+    ws.on('message', (raw) => {
+      const rawStr = raw.toString();
 
-            // Heartbeat
-            if (rawStr === 'ping') {
-                if (ws.readyState === WebSocket.OPEN) ws.send('pong');
-                return;
-            }
+      // Heartbeat
+      if (rawStr === 'ping') {
+        if (ws.readyState === WebSocket.OPEN) ws.send('pong');
+        return;
+      }
 
-            const msg = JSON.parse(rawStr);
+      const msg = JSON.parse(rawStr);
 
-            // Whisper transcription via WebSocket (bypasses relay POST issues)
-            if (msg.type === 'whisper:transcribe') {
-                (async () => {
-                    try {
-                        const result = await workerApi(
-                            '/api/whisper/transcribe',
-                            'POST',
-                            { audio: msg.data.audio }
-                        );
-                        if (ws.readyState === WebSocket.OPEN) {
-                            ws.send(
-                                JSON.stringify({
-                                    type: 'whisper:result',
-                                    data: result
-                                })
-                            );
-                        }
-                    } catch (err: any) {
-                        if (ws.readyState === WebSocket.OPEN) {
-                            ws.send(
-                                JSON.stringify({
-                                    type: 'whisper:result',
-                                    data: { error: err.message }
-                                })
-                            );
-                        }
-                    }
-                })();
-                return;
+      // Whisper transcription via WebSocket (bypasses relay POST issues)
+      if (msg.type === 'whisper:transcribe') {
+        (async () => {
+          try {
+            const result = await workerApi('/api/whisper/transcribe', 'POST', { audio: msg.data.audio });
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({ type: 'whisper:result', data: result }));
+            }
+          } catch (err: any) {
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({ type: 'whisper:result', data: { error: err.message } }));
             }
+          }
+        })();
+        return;
+      }
 
-            // Save settings via WebSocket (bypasses relay POST issues)
-            if (msg.type === 'settings:save') {
-                (async () => {
-                    try {
-                        const result = await workerApi(
-                            '/api/onboard',
-                            'POST',
-                            msg.data
-                        );
-                        if (ws.readyState === WebSocket.OPEN) {
-                            ws.send(
-                                JSON.stringify({
-                                    type: 'settings:saved',
-                                    data: result
-                                })
-                            );
-                        }
-                    } catch (err: any) {
-                        log.error(
-                            `[fluxy] settings:save failed: ${err.message}`
-                        );
-                        if (ws.readyState === WebSocket.OPEN) {
-                            ws.send(
-                                JSON.stringify({
-                                    type: 'settings:save-error',
-                                    data: { error: err.message }
-                                })
-                            );
-                        }
-                    }
-                })();
-                return;
+      // Save settings via WebSocket (bypasses relay POST issues)
+      if (msg.type === 'settings:save') {
+        (async () => {
+          try {
+            const result = await workerApi('/api/onboard', 'POST', msg.data);
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({ type: 'settings:saved', data: result }));
+            }
+          } catch (err: any) {
+            log.error(`[fluxy] settings:save failed: ${err.message}`);
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({ type: 'settings:save-error', data: { error: err.message } }));
             }
+          }
+        })();
+        return;
+      }
 
-            // Switch tunnel mode at runtime (off ↔ quick)
-            if (msg.type === 'tunnel:switch') {
-                (async () => {
+      // Switch tunnel mode at runtime (off ↔ quick)
+      if (msg.type === 'tunnel:switch') {
+        (async () => {
+          try {
+            const newMode = msg.data?.mode as 'off' | 'quick';
+            const cfg = loadConfig();
+
+            if (newMode === 'off') {
+              // Stop tunnel, heartbeat, relay, watchdog
+              stopHeartbeat();
+              if (cfg.relay?.token) {
+                try { await disconnect(cfg.relay.token); } catch {}
+              }
+              stopTunnel();
+              if (watchdogInterval) { clearInterval(watchdogInterval); watchdogInterval = null; }
+              tunnelUrl = null;
+              cfg.tunnel.mode = 'off';
+              delete cfg.tunnelUrl;
+              saveConfig(cfg);
+              log.ok('[tunnel:switch] Switched to off — tunnel stopped');
+              if (ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({ type: 'tunnel:switched', data: { mode: 'off' } }));
+              }
+            } else if (newMode === 'quick') {
+              // Start tunnel
+              const newUrl = await startTunnel(cfg.port);
+              tunnelUrl = newUrl;
+              cfg.tunnel.mode = 'quick';
+              cfg.tunnelUrl = newUrl;
+              saveConfig(cfg);
+              log.ok(`[tunnel:switch] Tunnel started: ${newUrl}`);
+
+              // Wait for local server readiness
+              for (let i = 0; i < 15; i++) {
+                try {
+                  const res = await fetch(`http://127.0.0.1:${cfg.port}/api/health?_cb=${Date.now()}`, {
+                    signal: AbortSignal.timeout(3000),
+                  });
+                  if (res.ok) break;
+                } catch {}
+                await new Promise(r => setTimeout(r, 1000));
+              }
+
+              // Reconnect relay if handle exists
+              if (cfg.relay?.token) {
+                try {
+                  await updateTunnelUrl(cfg.relay.token, newUrl);
+                  startHeartbeat(cfg.relay.token, newUrl);
+                  log.ok('[tunnel:switch] Relay reconnected');
+                } catch (err) {
+                  log.warn(`[tunnel:switch] Relay reconnect: ${err instanceof Error ? err.message : err}`);
+                }
+              }
+
+              // Re-create watchdog
+              if (watchdogInterval) clearInterval(watchdogInterval);
+              let lastTick = Date.now();
+              let healthCounter = 0;
+              watchdogInterval = setInterval(async () => {
+                const now = Date.now();
+                const wakeGap = now - lastTick > 60_000;
+                const periodicCheck = ++healthCounter % 10 === 0;
+                lastTick = now;
+                if (wakeGap || periodicCheck) {
+                  const alive = await isTunnelAlive(tunnelUrl!, cfg.port);
+                  if (!alive) {
+                    log.warn('Tunnel dead, restarting...');
                     try {
-                        const newMode = msg.data?.mode as 'off' | 'quick';
-                        const cfg = loadConfig();
-
-                        if (newMode === 'off') {
-                            // Stop tunnel, heartbeat, relay, watchdog
-                            stopHeartbeat();
-                            if (cfg.relay?.token) {
-                                try {
-                                    await disconnect(cfg.relay.token);
-                                } catch {}
-                            }
-                            stopTunnel();
-                            if (watchdogInterval) {
-                                clearInterval(watchdogInterval);
-                                watchdogInterval = null;
-                            }
-                            tunnelUrl = null;
-                            cfg.tunnel.mode = 'off';
-                            delete cfg.tunnelUrl;
-                            saveConfig(cfg);
-                            log.ok(
-                                '[tunnel:switch] Switched to off — tunnel stopped'
-                            );
-                            if (ws.readyState === WebSocket.OPEN) {
-                                ws.send(
-                                    JSON.stringify({
-                                        type: 'tunnel:switched',
-                                        data: { mode: 'off' }
-                                    })
-                                );
-                            }
-                        } else if (newMode === 'quick') {
-                            // Start tunnel
-                            const newUrl = await startTunnel(cfg.port);
-                            tunnelUrl = newUrl;
-                            cfg.tunnel.mode = 'quick';
-                            cfg.tunnelUrl = newUrl;
-                            saveConfig(cfg);
-                            log.ok(`[tunnel:switch] Tunnel started: ${newUrl}`);
-
-                            // Wait for local server readiness
-                            for (let i = 0; i < 15; i++) {
-                                try {
-                                    const res = await fetch(
-                                        `http://127.0.0.1:${cfg.port}/api/health?_cb=${Date.now()}`,
-                                        {
-                                            signal: AbortSignal.timeout(3000)
-                                        }
-                                    );
-                                    if (res.ok) break;
-                                } catch {}
-                                await new Promise(r => setTimeout(r, 1000));
-                            }
-
-                            // Reconnect relay if handle exists
-                            if (cfg.relay?.token) {
-                                try {
-                                    await updateTunnelUrl(
-                                        cfg.relay.token,
-                                        newUrl
-                                    );
-                                    startHeartbeat(cfg.relay.token, newUrl);
-                                    log.ok('[tunnel:switch] Relay reconnected');
-                                } catch (err) {
-                                    log.warn(
-                                        `[tunnel:switch] Relay reconnect: ${err instanceof Error ? err.message : err}`
-                                    );
-                                }
-                            }
-
-                            // Re-create watchdog
-                            if (watchdogInterval)
-                                clearInterval(watchdogInterval);
-                            let lastTick = Date.now();
-                            let healthCounter = 0;
-                            watchdogInterval = setInterval(async () => {
-                                const now = Date.now();
-                                const wakeGap = now - lastTick > 60_000;
-                                const periodicCheck =
-                                    ++healthCounter % 10 === 0;
-                                lastTick = now;
-                                if (wakeGap || periodicCheck) {
-                                    const alive = await isTunnelAlive(
-                                        tunnelUrl!,
-                                        cfg.port
-                                    );
-                                    if (!alive) {
-                                        log.warn('Tunnel dead, restarting...');
-                                        try {
-                                            const restartedUrl =
-                                                await restartTunnel(cfg.port);
-                                            await new Promise(r =>
-                                                setTimeout(r, 3000)
-                                            );
-                                            tunnelUrl = restartedUrl;
-                                            const latestCfg = loadConfig();
-                                            latestCfg.tunnelUrl = restartedUrl;
-                                            saveConfig(latestCfg);
-                                            if (latestCfg.relay?.token) {
-                                                stopHeartbeat();
-                                                startHeartbeat(
-                                                    latestCfg.relay.token,
-                                                    restartedUrl
-                                                );
-                                                await updateTunnelUrl(
-                                                    latestCfg.relay.token,
-                                                    restartedUrl
-                                                );
-                                            }
-                                            log.ok(
-                                                `Tunnel restored: ${restartedUrl}`
-                                            );
-                                        } catch (err) {
-                                            log.error(
-                                                `Tunnel restart failed: ${err instanceof Error ? err.message : err}`
-                                            );
-                                        }
-                                    }
-                                }
-                            }, 30_000);
-
-                            if (ws.readyState === WebSocket.OPEN) {
-                                ws.send(
-                                    JSON.stringify({
-                                        type: 'tunnel:switched',
-                                        data: {
-                                            mode: 'quick',
-                                            tunnelUrl: newUrl
-                                        }
-                                    })
-                                );
-                            }
-                        }
-                    } catch (err: any) {
-                        log.error(`[tunnel:switch] Error: ${err.message}`);
-                        if (ws.readyState === WebSocket.OPEN) {
-                            ws.send(
-                                JSON.stringify({
-                                    type: 'tunnel:switch-error',
-                                    data: { error: err.message }
-                                })
-                            );
-                        }
+                      const restartedUrl = await restartTunnel(cfg.port);
+                      await new Promise(r => setTimeout(r, 3000));
+                      tunnelUrl = restartedUrl;
+                      const latestCfg = loadConfig();
+                      latestCfg.tunnelUrl = restartedUrl;
+                      saveConfig(latestCfg);
+                      if (latestCfg.relay?.token) {
+                        stopHeartbeat();
+                        startHeartbeat(latestCfg.relay.token, restartedUrl);
+                        await updateTunnelUrl(latestCfg.relay.token, restartedUrl);
+                      }
+                      log.ok(`Tunnel restored: ${restartedUrl}`);
+                    } catch (err) {
+                      log.error(`Tunnel restart failed: ${err instanceof Error ? err.message : err}`);
                     }
-                })();
-                return;
+                  }
+                }
+              }, 30_000);
+
+              if (ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({ type: 'tunnel:switched', data: { mode: 'quick', tunnelUrl: newUrl } }));
+              }
             }
+          } catch (err: any) {
+            log.error(`[tunnel:switch] Error: ${err.message}`);
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({ type: 'tunnel:switch-error', data: { error: err.message } }));
+            }
+          }
+        })();
+        return;
+      }
 
-            // New protocol: { type: 'user:message', data: { content, conversationId? } }
-            if (msg.type === 'user:message') {
-                const data = msg.data || {};
-                const content = data.content;
-                if (!content) return;
-                if (data.conversationId) convId = data.conversationId;
-
-                // Re-read config on each message so post-onboard changes are picked up
-                const freshConfig = loadConfig();
-                const freshAi =
-                    freshConfig.ai.provider &&
-                    (freshConfig.ai.apiKey ||
-                        freshConfig.ai.provider === 'ollama')
-                        ? createProvider(
-                              freshConfig.ai.provider,
-                              freshConfig.ai.apiKey,
-                              freshConfig.ai.baseUrl
-                          )
-                        : null;
-
-                log.info(
-                    `[fluxy] provider=${freshConfig.ai.provider}, model=${freshConfig.ai.model}`
-                );
-
-                // Route Anthropic through Agent SDK (uses OAuth token, not API key)
-                if (freshConfig.ai.provider === 'anthropic') {
-                    // Server-side persistence: create or reuse DB conversation, save user message
-                    (async () => {
-                        // Save attachments to disk (before try so it's accessible in startFluxyAgentQuery below)
-                        let savedFiles: SavedFile[] = [];
-                        if (data.attachments?.length) {
-                            for (const att of data.attachments) {
-                                try {
-                                    savedFiles.push(saveAttachment(att));
-                                } catch (err: any) {
-                                    log.warn(
-                                        `[fluxy] File save error: ${err.message}`
-                                    );
-                                }
-                            }
-                        }
-
-                        try {
-                            // Check if we have an existing conversation for this client
-                            let dbConvId = clientConvs.get(ws);
-                            if (!dbConvId) {
-                                // Check if there's a current conversation set in settings
-                                const ctx = await workerApi(
-                                    '/api/context/current'
-                                );
-                                if (ctx.conversationId) {
-                                    dbConvId = ctx.conversationId;
-                                } else {
-                                    // Create a new conversation
-                                    const conv = await workerApi(
-                                        '/api/conversations',
-                                        'POST',
-                                        {
-                                            title: content.slice(0, 80),
-                                            model: freshConfig.ai.model
-                                        }
-                                    );
-                                    dbConvId = conv.id;
-                                    await workerApi(
-                                        '/api/context/set',
-                                        'POST',
-                                        { conversationId: dbConvId }
-                                    );
-                                }
-                                clientConvs.set(ws, dbConvId!);
-                                // Notify client of the conversation ID
-                                if (ws.readyState === WebSocket.OPEN) {
-                                    ws.send(
-                                        JSON.stringify({
-                                            type: 'chat:conversation-created',
-                                            data: { conversationId: dbConvId }
-                                        })
-                                    );
-                                }
-                            }
-                            convId = dbConvId!;
-
-                            // Save user message to DB (include attachment metadata as JSON string)
-                            const meta: any = { model: freshConfig.ai.model };
-                            if (savedFiles.length) {
-                                meta.attachments = JSON.stringify(
-                                    savedFiles.map(f => ({
-                                        type: f.type,
-                                        name: f.name,
-                                        mediaType: f.mediaType,
-                                        filePath: f.relPath
-                                    }))
-                                );
-                            }
-                            await workerApi(
-                                `/api/conversations/${convId}/messages`,
-                                'POST',
-                                {
-                                    role: 'user',
-                                    content,
-                                    meta
-                                }
-                            );
-
-                            // Broadcast user message to other clients
-                            broadcastFluxyExcept(ws, 'chat:sync', {
-                                conversationId: convId,
-                                message: {
-                                    role: 'user',
-                                    content,
-                                    timestamp: new Date().toISOString()
-                                }
-                            });
-                        } catch (err: any) {
-                            log.warn(
-                                `[fluxy] DB persist error: ${err.message}`
-                            );
-                        }
-
-                        // Fetch agent/user names and recent messages in parallel
-                        let botName = 'Fluxy',
-                            humanName = 'Human';
-                        let recentMessages: RecentMessage[] = [];
-                        try {
-                            const [status, recentRaw] = await Promise.all([
-                                workerApi(
-                                    '/api/onboard/status'
-                                ) as Promise<any>,
-                                workerApi(
-                                    `/api/conversations/${convId}/messages/recent?limit=20`
-                                ) as Promise<any[]>
-                            ]);
-                            botName = status.agentName || 'Fluxy';
-                            humanName = status.userName || 'Human';
-
-                            // Filter to user/assistant only, exclude the last entry (current message already sent as SDK prompt)
-                            if (Array.isArray(recentRaw)) {
-                                const filtered = recentRaw.filter(
-                                    (m: any) =>
-                                        m.role === 'user' ||
-                                        m.role === 'assistant'
-                                );
-                                // Slice off the last entry — it's the current user message
-                                if (filtered.length > 0) {
-                                    recentMessages = filtered
-                                        .slice(0, -1)
-                                        .map((m: any) => ({
-                                            role: m.role as
-                                                | 'user'
-                                                | 'assistant',
-                                            content: m.content
-                                        }));
-                                }
-                            }
-                        } catch {}
-
-                        // Start agent query
-                        agentQueryActive = true;
-                        currentStreamConvId = convId;
-                        currentStreamBuffer = '';
-                        startFluxyAgentQuery(
-                            convId,
-                            content,
-                            freshConfig.ai.model,
-                            (type, eventData) => {
-                                // Track stream buffer for reconnecting clients
-                                if (type === 'bot:token' && eventData.token) {
-                                    currentStreamBuffer += eventData.token;
-                                }
-
-                                // Intercept bot:done — Vite HMR handles file changes automatically
-                                if (type === 'bot:done') {
-                                    agentQueryActive = false;
-                                    currentStreamConvId = null;
-                                    currentStreamBuffer = '';
-                                    // 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().then(() =>
-                                            spawnBackend(backendPort)
-                                        );
-                                    }
-                                    // Run deferred update if agent requested one
-                                    if (pendingUpdate) {
-                                        pendingUpdate = false;
-                                        runDeferredUpdate();
-                                    }
-                                    return; // don't forward bot:done to client
-                                }
-
-                                // Save assistant response to DB + clear stream state
-                                if (type === 'bot:response') {
-                                    currentStreamBuffer = '';
-                                    (async () => {
-                                        try {
-                                            await workerApi(
-                                                `/api/conversations/${convId}/messages`,
-                                                'POST',
-                                                {
-                                                    role: 'assistant',
-                                                    content: eventData.content,
-                                                    meta: {
-                                                        model: freshConfig.ai
-                                                            .model
-                                                    }
-                                                }
-                                            );
-                                        } catch (err: any) {
-                                            log.warn(
-                                                `[fluxy] DB persist bot response error: ${err.message}`
-                                            );
-                                        }
-                                    })();
-                                }
-
-                                // Stream all events to every connected client
-                                broadcastFluxy(type, eventData);
-                            },
-                            data.attachments,
-                            savedFiles,
-                            { botName, humanName },
-                            recentMessages
-                        );
-                    })();
-                    return;
+      // New protocol: { type: 'user:message', data: { content, conversationId? } }
+      if (msg.type === 'user:message') {
+        const data = msg.data || {};
+        const content = data.content;
+        if (!content) return;
+        if (data.conversationId) convId = data.conversationId;
+
+        // Re-read config on each message so post-onboard changes are picked up
+        const freshConfig = loadConfig();
+        const freshAi = (freshConfig.ai.provider && (freshConfig.ai.apiKey || freshConfig.ai.provider === 'ollama'))
+          ? createProvider(freshConfig.ai.provider, freshConfig.ai.apiKey, freshConfig.ai.baseUrl)
+          : null;
+
+        log.info(`[fluxy] provider=${freshConfig.ai.provider}, model=${freshConfig.ai.model}`);
+
+        // Route Anthropic through Agent SDK (uses OAuth token, not API key)
+        if (freshConfig.ai.provider === 'anthropic') {
+          // Server-side persistence: create or reuse DB conversation, save user message
+          (async () => {
+            // Save attachments to disk (before try so it's accessible in startFluxyAgentQuery below)
+            let savedFiles: SavedFile[] = [];
+            if (data.attachments?.length) {
+              for (const att of data.attachments) {
+                try {
+                  savedFiles.push(saveAttachment(att));
+                } catch (err: any) {
+                  log.warn(`[fluxy] File save error: ${err.message}`);
                 }
+              }
+            }
 
-                // Other providers: use ai.chat() with conversation history
-                const history = conversations.get(ws) || [];
-                history.push({ role: 'user', content });
-
-                if (!freshAi) {
-                    if (ws.readyState === WebSocket.OPEN) {
-                        ws.send(
-                            JSON.stringify({
-                                type: 'bot:error',
-                                data: {
-                                    error: 'AI not configured. Set up your provider first.'
-                                }
-                            })
-                        );
-                    }
-                    return;
+            try {
+              // Check if we have an existing conversation for this client
+              let dbConvId = clientConvs.get(ws);
+              if (!dbConvId) {
+                // Check if there's a current conversation set in settings
+                const ctx = await workerApi('/api/context/current');
+                if (ctx.conversationId) {
+                  dbConvId = ctx.conversationId;
+                } else {
+                  // Create a new conversation
+                  const conv = await workerApi('/api/conversations', 'POST', { title: content.slice(0, 80), model: freshConfig.ai.model });
+                  dbConvId = conv.id;
+                  await workerApi('/api/context/set', 'POST', { conversationId: dbConvId });
                 }
-
+                clientConvs.set(ws, dbConvId!);
+                // Notify client of the conversation ID
                 if (ws.readyState === WebSocket.OPEN) {
-                    ws.send(
-                        JSON.stringify({
-                            type: 'bot:typing',
-                            data: { conversationId: convId }
-                        })
-                    );
+                  ws.send(JSON.stringify({ type: 'chat:conversation-created', data: { conversationId: dbConvId } }));
                 }
-
-                freshAi.chat(
-                    [
-                        {
-                            role: 'system',
-                            content:
-                                'You are Fluxy, a helpful AI assistant. You help users manage and customize their self-hosted bot.'
-                        },
-                        ...history
-                    ],
-                    freshConfig.ai.model,
-                    token => {
-                        if (ws.readyState === WebSocket.OPEN)
-                            ws.send(
-                                JSON.stringify({
-                                    type: 'bot:token',
-                                    data: { token, conversationId: convId }
-                                })
-                            );
-                    },
-                    full => {
-                        history.push({ role: 'assistant', content: full });
-                        if (ws.readyState === WebSocket.OPEN)
-                            ws.send(
-                                JSON.stringify({
-                                    type: 'bot:response',
-                                    data: {
-                                        conversationId: convId,
-                                        content: full
-                                    }
-                                })
-                            );
-                    },
-                    err => {
-                        if (ws.readyState === WebSocket.OPEN)
-                            ws.send(
-                                JSON.stringify({
-                                    type: 'bot:error',
-                                    data: { error: err.message }
-                                })
-                            );
-                    }
-                );
-                return;
+              }
+              convId = dbConvId!;
+
+              // Save user message to DB (include attachment metadata as JSON string)
+              const meta: any = { model: freshConfig.ai.model };
+              if (savedFiles.length) {
+                meta.attachments = JSON.stringify(savedFiles.map((f) => ({
+                  type: f.type, name: f.name, mediaType: f.mediaType, filePath: f.relPath,
+                })));
+              }
+              await workerApi(`/api/conversations/${convId}/messages`, 'POST', {
+                role: 'user', content, meta,
+              });
+
+              // Broadcast user message to other clients
+              broadcastFluxyExcept(ws, 'chat:sync', {
+                conversationId: convId,
+                message: { role: 'user', content, timestamp: new Date().toISOString() },
+              });
+            } catch (err: any) {
+              log.warn(`[fluxy] DB persist error: ${err.message}`);
             }
 
-            if (msg.type === 'user:stop') {
-                stopFluxyAgentQuery(convId);
-                return;
-            }
+            // Fetch agent/user names and recent messages in parallel
+            let botName = 'Fluxy', humanName = 'Human';
+            let recentMessages: RecentMessage[] = [];
+            try {
+              const [status, recentRaw] = await Promise.all([
+                workerApi('/api/onboard/status') as Promise<any>,
+                workerApi(`/api/conversations/${convId}/messages/recent?limit=20`) as Promise<any[]>,
+              ]);
+              botName = status.agentName || 'Fluxy';
+              humanName = status.userName || 'Human';
+
+              // Filter to user/assistant only, exclude the last entry (current message already sent as SDK prompt)
+              if (Array.isArray(recentRaw)) {
+                const filtered = recentRaw
+                  .filter((m: any) => m.role === 'user' || m.role === 'assistant');
+                // Slice off the last entry — it's the current user message
+                if (filtered.length > 0) {
+                  recentMessages = filtered.slice(0, -1).map((m: any) => ({
+                    role: m.role as 'user' | 'assistant',
+                    content: m.content,
+                  }));
+                }
+              }
+            } catch {}
 
-            if (msg.type === 'user:clear-context') {
+            // Start agent query
+            agentQueryActive = true;
+            currentStreamConvId = convId;
+            currentStreamBuffer = '';
+            startFluxyAgentQuery(convId, content, freshConfig.ai.model, (type, eventData) => {
+              // Track stream buffer for reconnecting clients
+              if (type === 'bot:token' && eventData.token) {
+                currentStreamBuffer += eventData.token;
+              }
+
+              // Intercept bot:done — Vite HMR handles file changes automatically
+              if (type === 'bot:done') {
+                agentQueryActive = false;
+                currentStreamConvId = null;
+                currentStreamBuffer = '';
+                // 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().then(() => spawnBackend(backendPort));
+                }
+                // Run deferred update if agent requested one
+                if (pendingUpdate) {
+                  pendingUpdate = false;
+                  runDeferredUpdate();
+                }
+                return; // don't forward bot:done to client
+              }
+
+              // Save assistant response to DB + clear stream state
+              if (type === 'bot:response') {
+                currentStreamBuffer = '';
                 (async () => {
-                    try {
-                        clientConvs.delete(ws);
-                        await workerApi('/api/context/clear', 'POST');
-                    } catch (err: any) {
-                        log.warn(`[fluxy] Clear context error: ${err.message}`);
-                    }
-                    // Broadcast clear to ALL clients
-                    broadcastFluxy('chat:cleared');
+                  try {
+                    await workerApi(`/api/conversations/${convId}/messages`, 'POST', {
+                      role: 'assistant', content: eventData.content, meta: { model: freshConfig.ai.model },
+                    });
+                  } catch (err: any) {
+                    log.warn(`[fluxy] DB persist bot response error: ${err.message}`);
+                  }
                 })();
-                return;
-            }
-        });
+              }
 
-        ws.on('close', () => {
-            conversations.delete(ws);
-            clientConvs.delete(ws);
-        });
-    });
+              // Stream all events to every connected client
+              broadcastFluxy(type, eventData);
+            }, data.attachments, savedFiles, { botName, humanName }, recentMessages);
+          })();
+          return;
+        }
 
-    // Fluxy chat WebSocket — Vite HMR is handled automatically (hmr.server = this server)
-    server.on('upgrade', async (req, socket: net.Socket, head) => {
-        console.log(
-            `[supervisor] WebSocket upgrade: ${req.url} | protocol=${req.headers['sec-websocket-protocol'] || 'none'}`
-        );
+        // Other providers: use ai.chat() with conversation history
+        const history = conversations.get(ws) || [];
+        history.push({ role: 'user', content });
 
-        if (!req.url?.startsWith('/fluxy/ws')) {
-            console.log('[supervisor] → Letting Vite handle this upgrade');
-            return;
+        if (!freshAi) {
+          if (ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify({ type: 'bot:error', data: { error: 'AI not configured. Set up your provider first.' } }));
+          }
+          return;
         }
 
-        // Auth check for WebSocket
-        const needsAuth = await isAuthRequired();
-        if (needsAuth) {
-            const urlObj = new URL(req.url, `http://${req.headers.host}`);
-            const token = urlObj.searchParams.get('token');
-            if (!token || !(await validateToken(token))) {
-                console.log('[supervisor] WS auth failed — rejecting');
-                socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
-                socket.destroy();
-                return;
-            }
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: 'bot:typing', data: { conversationId: convId } }));
         }
 
-        console.log('[supervisor] → Fluxy chat WebSocket');
-        fluxyWss.handleUpgrade(req, socket, head, ws =>
-            fluxyWss.emit('connection', ws, req)
+        freshAi.chat(
+          [{ role: 'system', content: 'You are Fluxy, a helpful AI assistant. You help users manage and customize their self-hosted bot.' }, ...history],
+          freshConfig.ai.model,
+          (token) => { if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: 'bot:token', data: { token, conversationId: convId } })); },
+          (full) => {
+            history.push({ role: 'assistant', content: full });
+            if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: 'bot:response', data: { conversationId: convId, content: full } }));
+          },
+          (err) => { if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: 'bot:error', data: { error: err.message } })); },
         );
-    });
+        return;
+      }
 
-    // Start
-    server.on('error', (err: NodeJS.ErrnoException) => {
-        if (err.code === 'EADDRINUSE') {
-            log.error(
-                `Port ${config.port} is already in use. Stop the other process or change the port in ${paths.config}`
-            );
-        } else {
-            log.error(`Server error: ${err.message}`);
-        }
-        process.exit(1);
+      if (msg.type === 'user:stop') {
+        stopFluxyAgentQuery(convId);
+        return;
+      }
+
+      if (msg.type === 'user:clear-context') {
+        (async () => {
+          try {
+            clientConvs.delete(ws);
+            await workerApi('/api/context/clear', 'POST');
+          } catch (err: any) {
+            log.warn(`[fluxy] Clear context error: ${err.message}`);
+          }
+          // Broadcast clear to ALL clients
+          broadcastFluxy('chat:cleared');
+        })();
+        return;
+      }
     });
 
-    server.listen(config.port, () => {
-        log.ok(`Supervisor on http://localhost:${config.port}`);
-        log.ok(`Fluxy chat at http://localhost:${config.port}/fluxy`);
-        if (config.tunnel.mode === 'off') {
-            console.log('__READY__');
-        }
+    ws.on('close', () => {
+      conversations.delete(ws);
+      clientConvs.delete(ws);
     });
+  });
 
-    // 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
-    let pendingUpdate = false; // Set when .update file is created during agent turn
+  // Fluxy chat WebSocket — Vite HMR is handled automatically (hmr.server = this server)
+  server.on('upgrade', async (req, socket: net.Socket, head) => {
+    console.log(`[supervisor] WebSocket upgrade: ${req.url} | protocol=${req.headers['sec-websocket-protocol'] || 'none'}`);
 
-    // Run fluxy update in a detached process so it survives daemon stop/restart
-    function runDeferredUpdate() {
-        const cliPath = path.join(PKG_DIR, 'bin', 'cli.js');
-        log.info('Deferred update triggered — running fluxy update...');
-        try {
-            const child = cpSpawn(process.execPath, [cliPath, 'update'], {
-                detached: true,
-                stdio: 'ignore',
-                env: { ...process.env }
-            });
-            child.unref();
-        } catch (err) {
-            log.error(
-                `Deferred update failed: ${err instanceof Error ? err.message : err}`
-            );
-        }
+    if (!req.url?.startsWith('/fluxy/ws')) {
+      console.log('[supervisor] → Letting Vite handle this upgrade');
+      return;
     }
 
-    // Spawn worker + backend
-    spawnWorker(workerPort);
-    spawnBackend(backendPort);
-
-    // Start pulse/cron scheduler
-    startScheduler({
-        broadcastFluxy,
-        workerApi,
-        restartBackend: async () => {
-            resetBackendRestarts();
-            await stopBackend();
-            spawnBackend(backendPort);
-        },
-        getModel: () => loadConfig().ai.model
-    });
+    // Auth check for WebSocket
+    const needsAuth = await isAuthRequired();
+    if (needsAuth) {
+      const urlObj = new URL(req.url, `http://${req.headers.host}`);
+      const token = urlObj.searchParams.get('token');
+      if (!token || !(await validateToken(token))) {
+        console.log('[supervisor] WS auth failed — rejecting');
+        socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+        socket.destroy();
+        return;
+      }
+    }
 
-    // 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 = WORKSPACE_DIR;
-    const backendDir = path.join(workspaceDir, 'backend');
-    let backendRestartTimer: ReturnType<typeof setTimeout> | null = null;
-
-    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(async () => {
-            log.info(`[watcher] ${reason} — restarting backend...`);
-            resetBackendRestarts();
-            await stopBackend();
-            spawnBackend(backendPort);
-        }, 1000);
+    console.log('[supervisor] → Fluxy chat WebSocket');
+    fluxyWss.handleUpgrade(req, socket, head, (ws) => fluxyWss.emit('connection', ws, req));
+  });
+
+  // Start
+  server.on('error', (err: NodeJS.ErrnoException) => {
+    if (err.code === 'EADDRINUSE') {
+      log.error(`Port ${config.port} is already in use. Stop the other process or change the port in ${paths.config}`);
+    } else {
+      log.error(`Server error: ${err.message}`);
     }
+    process.exit(1);
+  });
 
-    // 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}`);
-        }
-    );
+  server.listen(config.port, () => {
+    log.ok(`Supervisor on http://localhost:${config.port}`);
+    log.ok(`Fluxy chat at http://localhost:${config.port}/fluxy`);
+    if (config.tunnel.mode === 'off') {
+      console.log('__READY__');
+    }
+  });
 
-    // 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');
-        }
-        if (filename === '.update') {
-            // Consume the trigger file
-            try {
-                fs.unlinkSync(path.join(workspaceDir, '.update'));
-            } catch {}
-            if (agentQueryActive) {
-                pendingUpdate = true;
-                log.info('Update requested — deferring until agent turn ends');
-            } else {
-                runDeferredUpdate();
-            }
-        }
-    });
+  // 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
+  let pendingUpdate = false; // Set when .update file is created during agent turn
 
-    // Tunnel
-    let tunnelUrl: string | null = null;
+  // Run fluxy update in a detached process so it survives daemon stop/restart
+  function runDeferredUpdate() {
+    const cliPath = path.join(PKG_DIR, 'bin', 'cli.js');
+    log.info('Deferred update triggered — running fluxy update...');
+    try {
+      const child = cpSpawn(process.execPath, [cliPath, 'update'], {
+        detached: true,
+        stdio: 'ignore',
+        env: { ...process.env },
+      });
+      child.unref();
+    } catch (err) {
+      log.error(`Deferred update failed: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+
+  // Spawn worker + backend
+  spawnWorker(workerPort);
+  spawnBackend(backendPort);
+
+  // Start pulse/cron scheduler
+  startScheduler({
+    broadcastFluxy,
+    workerApi,
+    restartBackend: async () => {
+      resetBackendRestarts();
+      await stopBackend();
+      spawnBackend(backendPort);
+    },
+    getModel: () => loadConfig().ai.model,
+  });
+
+  // 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;
+
+  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(async () => {
+      log.info(`[watcher] ${reason} — restarting backend...`);
+      resetBackendRestarts();
+      await stopBackend();
+      spawnBackend(backendPort);
+    }, 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');
+    }
+    if (filename === '.update') {
+      // Consume the trigger file
+      try { fs.unlinkSync(path.join(workspaceDir, '.update')); } catch {}
+      if (agentQueryActive) {
+        pendingUpdate = true;
+        log.info('Update requested — deferring until agent turn ends');
+      } else {
+        runDeferredUpdate();
+      }
+    }
+  });
+
+  // Tunnel
+  let tunnelUrl: string | null = null;
 
-    if (config.tunnel.mode === 'quick') {
+  if (config.tunnel.mode === 'quick') {
+    try {
+      tunnelUrl = await startTunnel(config.port);
+      log.ok(`Tunnel: ${tunnelUrl}`);
+      console.log(`__TUNNEL_URL__=${tunnelUrl}`);
+
+      // Persist tunnel URL so the worker can read it after handle registration
+      config.tunnelUrl = tunnelUrl;
+      saveConfig(config);
+
+      // 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 local server...');
+      for (let i = 0; i < 30; i++) {
         try {
-            tunnelUrl = await startTunnel(config.port);
-            log.ok(`Tunnel: ${tunnelUrl}`);
-            console.log(`__TUNNEL_URL__=${tunnelUrl}`);
-
-            // Persist tunnel URL so the worker can read it after handle registration
-            config.tunnelUrl = tunnelUrl;
-            saveConfig(config);
-
-            // 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 local server...');
-            for (let i = 0; i < 30; i++) {
-                try {
-                    const res = await fetch(
-                        `http://127.0.0.1:${config.port}/api/health?_cb=${Date.now()}`,
-                        {
-                            signal: AbortSignal.timeout(3000)
-                        }
-                    );
-                    log.info(`Readiness probe #${i + 1}: ${res.status}`);
-                    if (res.ok) {
-                        tunnelReady = true;
-                        break;
-                    }
-                } catch (err) {
-                    log.info(
-                        `Readiness probe #${i + 1}: ${err instanceof Error ? err.message : 'error'}`
-                    );
-                }
-                await new Promise(r => setTimeout(r, 1000));
-            }
-            if (!tunnelReady) {
-                log.warn(
-                    'Local server readiness probe timed out — updating relay anyway'
-                );
-            }
+          const res = await fetch(`http://127.0.0.1:${config.port}/api/health?_cb=${Date.now()}`, {
+            signal: AbortSignal.timeout(3000),
+          });
+          log.info(`Readiness probe #${i + 1}: ${res.status}`);
+          if (res.ok) {
+            tunnelReady = true;
+            break;
+          }
+        } catch (err) {
+          log.info(`Readiness probe #${i + 1}: ${err instanceof Error ? err.message : 'error'}`);
+        }
+        await new Promise(r => setTimeout(r, 1000));
+      }
+      if (!tunnelReady) {
+        log.warn('Local server readiness probe timed out — updating relay anyway');
+      }
 
-            // Now register tunnel URL with relay and start heartbeats
-            if (config.relay?.token) {
-                try {
-                    await updateTunnelUrl(config.relay.token, tunnelUrl);
-                    startHeartbeat(config.relay.token, tunnelUrl);
-                    if (config.relay.url) {
-                        log.ok(`Relay: ${config.relay.url}`);
-                        console.log(`__RELAY_URL__=${config.relay.url}`);
-                    }
-                } catch (err) {
-                    log.warn(
-                        `Relay: ${err instanceof Error ? err.message : err}`
-                    );
-                }
-            }
-            console.log('__READY__');
+      // Now register tunnel URL with relay and start heartbeats
+      if (config.relay?.token) {
+        try {
+          await updateTunnelUrl(config.relay.token, tunnelUrl);
+          startHeartbeat(config.relay.token, tunnelUrl);
+          if (config.relay.url) {
+            log.ok(`Relay: ${config.relay.url}`);
+            console.log(`__RELAY_URL__=${config.relay.url}`);
+          }
         } catch (err) {
-            log.warn(`Tunnel: ${err instanceof Error ? err.message : err}`);
-            console.log('__TUNNEL_FAILED__');
+          log.warn(`Relay: ${err instanceof Error ? err.message : err}`);
         }
+      }
+      console.log('__READY__');
+    } catch (err) {
+      log.warn(`Tunnel: ${err instanceof Error ? err.message : err}`);
+      console.log('__TUNNEL_FAILED__');
     }
+  }
 
-    if (config.tunnel.mode === 'named') {
+  if (config.tunnel.mode === 'named') {
+    try {
+      await startNamedTunnel(config.tunnel.configPath!, config.tunnel.name!);
+      tunnelUrl = `https://${config.tunnel.domain}`;
+      log.ok(`Named tunnel: ${tunnelUrl}`);
+      console.log(`__TUNNEL_URL__=${tunnelUrl}`);
+
+      config.tunnelUrl = tunnelUrl;
+      saveConfig(config);
+
+      // Readiness probe — check local server (not tunnel URL, avoids macOS self-reach issue)
+      let tunnelReady = false;
+      log.info('Readiness probe: waiting for local server...');
+      for (let i = 0; i < 30; i++) {
         try {
-            await startNamedTunnel(
-                config.tunnel.configPath!,
-                config.tunnel.name!
-            );
-            tunnelUrl = `https://${config.tunnel.domain}`;
-            log.ok(`Named tunnel: ${tunnelUrl}`);
-            console.log(`__TUNNEL_URL__=${tunnelUrl}`);
-
-            config.tunnelUrl = tunnelUrl;
-            saveConfig(config);
-
-            // Readiness probe — check local server (not tunnel URL, avoids macOS self-reach issue)
-            let tunnelReady = false;
-            log.info('Readiness probe: waiting for local server...');
-            for (let i = 0; i < 30; i++) {
-                try {
-                    const res = await fetch(
-                        `http://127.0.0.1:${config.port}/api/health?_cb=${Date.now()}`,
-                        {
-                            signal: AbortSignal.timeout(3000)
-                        }
-                    );
-                    log.info(`Readiness probe #${i + 1}: ${res.status}`);
-                    if (res.ok) {
-                        tunnelReady = true;
-                        break;
-                    }
-                } catch (err) {
-                    log.info(
-                        `Readiness probe #${i + 1}: ${err instanceof Error ? err.message : 'error'}`
-                    );
-                }
-                await new Promise(r => setTimeout(r, 1000));
-            }
-            if (!tunnelReady) {
-                log.warn('Local server readiness probe timed out');
-            }
-
-            console.log('__READY__');
+          const res = await fetch(`http://127.0.0.1:${config.port}/api/health?_cb=${Date.now()}`, {
+            signal: AbortSignal.timeout(3000),
+          });
+          log.info(`Readiness probe #${i + 1}: ${res.status}`);
+          if (res.ok) {
+            tunnelReady = true;
+            break;
+          }
         } catch (err) {
-            log.warn(
-                `Named tunnel: ${err instanceof Error ? err.message : err}`
-            );
-            console.log('__TUNNEL_FAILED__');
+          log.info(`Readiness probe #${i + 1}: ${err instanceof Error ? err.message : 'error'}`);
         }
-    }
+        await new Promise(r => setTimeout(r, 1000));
+      }
+      if (!tunnelReady) {
+        log.warn('Local server readiness probe timed out');
+      }
 
-    // Tunnel watchdog — detects sleep/wake + periodic health checks
-    let watchdogInterval: ReturnType<typeof setInterval> | null = null;
-    if (tunnelUrl) {
-        let lastTick = Date.now();
-        let healthCounter = 0;
-
-        watchdogInterval = setInterval(async () => {
-            const now = Date.now();
-            const wakeGap = now - lastTick > 60_000;
-            const periodicCheck = ++healthCounter % 10 === 0;
-            lastTick = now; // Update immediately so concurrent ticks don't see a stale gap
-
-            if (wakeGap || periodicCheck) {
-                const alive = await isTunnelAlive(tunnelUrl!, config.port);
-                if (!alive) {
-                    log.warn('Tunnel dead, restarting...');
-                    try {
-                        if (config.tunnel.mode === 'named') {
-                            // Named tunnel: restart process, URL doesn't change
-                            await restartNamedTunnel(
-                                config.tunnel.configPath!,
-                                config.tunnel.name!
-                            );
-                            log.ok(`Named tunnel restored: ${tunnelUrl}`);
-                        } else {
-                            // Quick tunnel: restart and get new URL
-                            const newUrl = await restartTunnel(config.port);
-
-                            // Brief pause to let cloudflared establish the tunnel
-                            await new Promise(r => setTimeout(r, 3000));
-
-                            tunnelUrl = newUrl;
-
-                            // 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(latestCfg.relay.token, newUrl);
-                                await updateTunnelUrl(
-                                    latestCfg.relay.token,
-                                    newUrl
-                                );
-                                log.ok(`Relay updated with new tunnel URL`);
-                            }
-                            log.ok(`Tunnel restored: ${newUrl}`);
-                        }
-                    } catch (err) {
-                        log.error(
-                            `Tunnel restart failed: ${err instanceof Error ? err.message : err}`
-                        );
-                    }
-                }
-            }
-        }, 30_000);
+      console.log('__READY__');
+    } catch (err) {
+      log.warn(`Named tunnel: ${err instanceof Error ? err.message : err}`);
+      console.log('__TUNNEL_FAILED__');
     }
-
-    // Shutdown
-    const shutdown = async () => {
-        log.info('Shutting down...');
-        stopScheduler();
-        backendWatcher.close();
-        workspaceWatcher.close();
-        if (backendRestartTimer) clearTimeout(backendRestartTimer);
-        if (watchdogInterval) clearInterval(watchdogInterval);
-        stopHeartbeat();
-        const latestConfig = loadConfig();
-        if (latestConfig.relay?.token) {
-            await disconnect(latestConfig.relay.token);
+  }
+
+  // Tunnel watchdog — detects sleep/wake + periodic health checks
+  let watchdogInterval: ReturnType<typeof setInterval> | null = null;
+  if (tunnelUrl) {
+    let lastTick = Date.now();
+    let healthCounter = 0;
+
+    watchdogInterval = setInterval(async () => {
+      const now = Date.now();
+      const wakeGap = now - lastTick > 60_000;
+      const periodicCheck = ++healthCounter % 10 === 0;
+      lastTick = now; // Update immediately so concurrent ticks don't see a stale gap
+
+      if (wakeGap || periodicCheck) {
+        const alive = await isTunnelAlive(tunnelUrl!, config.port);
+        if (!alive) {
+          log.warn('Tunnel dead, restarting...');
+          try {
+            if (config.tunnel.mode === 'named') {
+              // Named tunnel: restart process, URL doesn't change
+              await restartNamedTunnel(config.tunnel.configPath!, config.tunnel.name!);
+              log.ok(`Named tunnel restored: ${tunnelUrl}`);
+            } else {
+              // Quick tunnel: restart and get new URL
+              const newUrl = await restartTunnel(config.port);
+
+              // Brief pause to let cloudflared establish the tunnel
+              await new Promise(r => setTimeout(r, 3000));
+
+              tunnelUrl = newUrl;
+
+              // 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(latestCfg.relay.token, newUrl);
+                await updateTunnelUrl(latestCfg.relay.token, newUrl);
+                log.ok(`Relay updated with new tunnel URL`);
+              }
+              log.ok(`Tunnel restored: ${newUrl}`);
+            }
+          } catch (err) {
+            log.error(`Tunnel restart failed: ${err instanceof Error ? err.message : err}`);
+          }
         }
-        // Clear persisted tunnel URL so stale values aren't reused
-        delete latestConfig.tunnelUrl;
-        saveConfig(latestConfig);
-        stopWorker();
-        await stopBackend();
-        stopTunnel();
-        console.log('[supervisor] Stopping Vite dev servers...');
-        await stopViteDevServers();
-        server.close();
-        process.exit(0);
-    };
-    process.on('SIGINT', () => shutdown());
-    process.on('SIGTERM', () => shutdown());
-
-    return tunnelUrl;
+      }
+    }, 30_000);
+  }
+
+  // Shutdown
+  const shutdown = async () => {
+    log.info('Shutting down...');
+    stopScheduler();
+    backendWatcher.close();
+    workspaceWatcher.close();
+    if (backendRestartTimer) clearTimeout(backendRestartTimer);
+    if (watchdogInterval) clearInterval(watchdogInterval);
+    stopHeartbeat();
+    const latestConfig = loadConfig();
+    if (latestConfig.relay?.token) {
+      await disconnect(latestConfig.relay.token);
+    }
+    // Clear persisted tunnel URL so stale values aren't reused
+    delete latestConfig.tunnelUrl;
+    saveConfig(latestConfig);
+    stopWorker();
+    await stopBackend();
+    stopTunnel();
+    console.log('[supervisor] Stopping Vite dev servers...');
+    await stopViteDevServers();
+    server.close();
+    process.exit(0);
+  };
+  process.on('SIGINT', () => shutdown());
+  process.on('SIGTERM', () => shutdown());
+
+  return tunnelUrl;
 }
 
-startSupervisor().catch(err => {
-    log.error('Fatal', err);
-    process.exit(1);
+startSupervisor().catch((err) => {
+  log.error('Fatal', err);
+  process.exit(1);
 });