fluxy-bot 0.9.7 → 0.10.0

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "fluxy-bot",
-  "version": "0.9.7",
+  "version": "0.10.0",
   "releaseNotes": [
-    "Another test for self update",
+    "Adding a way for users to claim their fluxies on the fluxy.bot dashboard",
     "2. ",
     "3. ",
     "4. "

package/supervisor/app-ws.js

@@ -0,0 +1,200 @@
+(function () {
+  if (window.__appWs) return;
+
+  var RECONNECT_BASE = 1000;
+  var RECONNECT_MAX = 8000;
+  var HEARTBEAT_MS = 25000;
+  var REQUEST_TIMEOUT = 30000;
+
+  var ws = null;
+  var connected = false;
+  var reconnectDelay = RECONNECT_BASE;
+  var reconnectTimer = null;
+  var heartbeatTimer = null;
+  var pendingRequests = {};
+  var requestCounter = 0;
+  var intentionalClose = false;
+  var originalFetch = window.fetch;
+
+  function buildWsUrl() {
+    var proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
+    return proto + '//' + location.host + '/app/ws';
+  }
+
+  function startHeartbeat() {
+    stopHeartbeat();
+    heartbeatTimer = setInterval(function () {
+      if (ws && ws.readyState === WebSocket.OPEN) ws.send('ping');
+    }, HEARTBEAT_MS);
+  }
+
+  function stopHeartbeat() {
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+  }
+
+  function failoverPending() {
+    var ids = Object.keys(pendingRequests);
+    for (var i = 0; i < ids.length; i++) {
+      var p = pendingRequests[ids[i]];
+      clearTimeout(p.timer);
+      console.log('[app-ws] WS dropped, falling back to fetch: ' + p.method + ' ' + p.path);
+      p.resolve(originalFetch(p.input, p.init));
+    }
+    pendingRequests = {};
+  }
+
+  function connect() {
+    intentionalClose = false;
+    var url = buildWsUrl();
+    ws = new WebSocket(url);
+
+    ws.onopen = function () {
+      connected = true;
+      reconnectDelay = RECONNECT_BASE;
+      startHeartbeat();
+      console.log('[app-ws] Connected to /app/ws');
+    };
+
+    ws.onmessage = function (e) {
+      if (e.data === 'pong') return;
+
+      var msg;
+      try {
+        msg = JSON.parse(e.data);
+      } catch (err) {
+        return;
+      }
+
+      if (msg.type === 'app:api:response' && msg.data && msg.data.id) {
+        var pending = pendingRequests[msg.data.id];
+        if (pending) {
+          clearTimeout(pending.timer);
+          delete pendingRequests[msg.data.id];
+
+          console.log('[app-ws] Response via WS: ' + msg.data.status + ' ' + pending.method + ' ' + pending.path);
+
+          var responseBody = msg.data.body;
+          if (responseBody === null || responseBody === undefined) responseBody = '';
+
+          var responseInit = {
+            status: msg.data.status,
+            headers: msg.data.headers || {},
+          };
+
+          pending.resolve(new Response(responseBody, responseInit));
+        }
+      }
+    };
+
+    ws.onclose = function () {
+      connected = false;
+      stopHeartbeat();
+      failoverPending();
+
+      if (!intentionalClose) {
+        console.log('[app-ws] Disconnected, reconnecting in ' + reconnectDelay + 'ms');
+        reconnectTimer = setTimeout(function () {
+          reconnectDelay = Math.min(reconnectDelay * 2, RECONNECT_MAX);
+          connect();
+        }, reconnectDelay);
+      }
+    };
+
+    ws.onerror = function () {
+      if (ws) ws.close();
+    };
+  }
+
+  // Override window.fetch to intercept /app/api/* calls
+  window.fetch = function (input, init) {
+    var url = input instanceof Request ? input.url : String(input);
+    var method = (init && init.method) || (input instanceof Request ? input.method : 'GET');
+
+    // Only intercept /app/api/* calls
+    if (url.indexOf('/app/api') === -1) {
+      return originalFetch.apply(this, arguments);
+    }
+
+    // Fallback: WS not connected
+    if (!connected || !ws || ws.readyState !== WebSocket.OPEN) {
+      console.log('[app-ws] WS not connected, falling back to fetch: ' + method + ' ' + url);
+      return originalFetch.apply(this, arguments);
+    }
+
+    // Fallback: non-serializable body (FormData, Blob, ArrayBuffer)
+    var body = init && init.body;
+    if (body && (body instanceof FormData || body instanceof Blob || body instanceof ArrayBuffer)) {
+      console.log('[app-ws] Non-serializable body, falling back to fetch: ' + method + ' ' + url);
+      return originalFetch.apply(this, arguments);
+    }
+
+    // Build request
+    var id = 'r' + ++requestCounter + '-' + Date.now().toString(36);
+
+    var reqPath = url;
+    try {
+      var parsed = new URL(url, location.origin);
+      reqPath = parsed.pathname + parsed.search;
+    } catch (e) {}
+
+    var headers = {};
+    if (init && init.headers) {
+      if (init.headers instanceof Headers) {
+        init.headers.forEach(function (v, k) {
+          headers[k] = v;
+        });
+      } else if (typeof init.headers === 'object') {
+        var h = init.headers;
+        for (var k in h) {
+          if (Object.prototype.hasOwnProperty.call(h, k)) headers[k] = h[k];
+        }
+      }
+    }
+
+    var bodyStr = null;
+    if (body !== undefined && body !== null) {
+      bodyStr = typeof body === 'string' ? body : JSON.stringify(body);
+    }
+
+    console.log('[app-ws] Proxying via WS: ' + method + ' ' + reqPath);
+
+    ws.send(
+      JSON.stringify({
+        type: 'app:api',
+        data: { id: id, method: method.toUpperCase(), path: reqPath, headers: headers, body: bodyStr },
+      })
+    );
+
+    var savedInput = input;
+    var savedInit = init;
+
+    return new Promise(function (resolve, reject) {
+      var timer = setTimeout(function () {
+        delete pendingRequests[id];
+        console.log('[app-ws] Request timed out, falling back to fetch: ' + method + ' ' + reqPath);
+        resolve(originalFetch(savedInput, savedInit));
+      }, REQUEST_TIMEOUT);
+
+      pendingRequests[id] = {
+        resolve: resolve,
+        reject: reject,
+        timer: timer,
+        input: savedInput,
+        init: savedInit,
+        method: method,
+        path: reqPath,
+      };
+    });
+  };
+
+  window.__appWs = {
+    connected: function () {
+      return connected;
+    },
+  };
+
+  connect();
+})();

package/supervisor/index.ts

@@ -295,6 +295,14 @@ export async function startSupervisor() {
       return;
     }
 
+    // App WS client — served directly (proxies /app/api calls through WebSocket)
+    if (req.url === '/fluxy/app-ws.js') {
+      console.log('[supervisor] Serving /fluxy/app-ws.js directly');
+      res.writeHead(200, { 'Content-Type': 'application/javascript', 'Cache-Control': 'no-cache' });
+      res.end(fs.readFileSync(path.join(PKG_DIR, 'supervisor', 'app-ws.js')));
+      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' });
@@ -427,6 +435,94 @@ export async function startSupervisor() {
   // WebSocket: Fluxy chat + proxy worker WS
   const fluxyWss = new WebSocketServer({ noServer: true });
 
+  // WebSocket: App API proxy (routes /app/api calls through WS to avoid tunnel POST issues)
+  const appWss = new WebSocketServer({ noServer: true });
+
+  appWss.on('connection', (ws) => {
+    console.log('[supervisor] App API WS client connected');
+
+    ws.on('message', (raw) => {
+      const rawStr = raw.toString();
+
+      if (rawStr === 'ping') {
+        if (ws.readyState === WebSocket.OPEN) ws.send('pong');
+        return;
+      }
+
+      let msg: any;
+      try {
+        msg = JSON.parse(rawStr);
+      } catch {
+        return;
+      }
+
+      if (msg.type !== 'app:api' || !msg.data) return;
+
+      const { id, method, path: reqPath, headers: reqHeaders, body } = msg.data;
+      const backendPath = (reqPath || '').replace(/^\/app\/api/, '') || '/';
+
+      console.log(`[supervisor] App WS → backend :${backendPort} | ${method} ${backendPath} (${id})`);
+
+      if (!isBackendAlive()) {
+        console.log('[supervisor] App WS: Backend down — returning 503');
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({
+            type: 'app:api:response',
+            data: { id, status: 503, headers: { 'content-type': 'application/json' }, body: JSON.stringify({ error: 'Backend is starting...' }) },
+          }));
+        }
+        return;
+      }
+
+      const proxyHeaders: Record<string, string> = { ...(reqHeaders || {}) };
+      if (body && !proxyHeaders['content-type']) {
+        proxyHeaders['content-type'] = 'application/json';
+      }
+
+      const proxyReq = http.request(
+        { host: '127.0.0.1', port: backendPort, path: backendPath, method, headers: proxyHeaders },
+        (proxyRes) => {
+          const chunks: Buffer[] = [];
+          proxyRes.on('data', (chunk: Buffer) => chunks.push(chunk));
+          proxyRes.on('end', () => {
+            const responseBody = Buffer.concat(chunks).toString('utf-8');
+            const resHeaders: Record<string, string> = {};
+            for (const [k, v] of Object.entries(proxyRes.headers)) {
+              if (typeof v === 'string') resHeaders[k] = v;
+              else if (Array.isArray(v)) resHeaders[k] = v.join(', ');
+            }
+
+            console.log(`[supervisor] App WS ← backend: ${proxyRes.statusCode} (${id})`);
+
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({
+                type: 'app:api:response',
+                data: { id, status: proxyRes.statusCode, headers: resHeaders, body: responseBody },
+              }));
+            }
+          });
+        },
+      );
+
+      proxyReq.on('error', (e) => {
+        console.error(`[supervisor] App WS backend error: ${backendPath}`, e.message);
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({
+            type: 'app:api:response',
+            data: { id, status: 503, headers: { 'content-type': 'application/json' }, body: JSON.stringify({ error: 'Backend unavailable' }) },
+          }));
+        }
+      });
+
+      if (body) proxyReq.write(body);
+      proxyReq.end();
+    });
+
+    ws.on('close', () => {
+      console.log('[supervisor] App API WS client disconnected');
+    });
+  });
+
   /** Send a message to all connected fluxy WS clients */
   function broadcastFluxy(type: string, data: any = {}) {
     const msg = JSON.stringify({ type, data });
@@ -806,6 +902,13 @@ export async function startSupervisor() {
   server.on('upgrade', async (req, socket: net.Socket, head) => {
     console.log(`[supervisor] WebSocket upgrade: ${req.url} | protocol=${req.headers['sec-websocket-protocol'] || 'none'}`);
 
+    // App API WebSocket — no auth (backend handles its own auth)
+    if (req.url?.startsWith('/app/ws')) {
+      console.log('[supervisor] → App API WebSocket');
+      appWss.handleUpgrade(req, socket, head, (ws) => appWss.emit('connection', ws, req));
+      return;
+    }
+
     if (!req.url?.startsWith('/fluxy/ws')) {
       console.log('[supervisor] → Letting Vite handle this upgrade');
       return;

package/supervisor/widget.js

@@ -139,4 +139,10 @@
       })
       .catch(function () {});
   } catch (e) {}
+
+  // Inject app-ws.js — proxies /app/api/* fetch calls through WebSocket
+  // (works around POST request failures through Cloudflare tunnel)
+  var awsScript = document.createElement('script');
+  awsScript.src = '/fluxy/app-ws.js';
+  document.head.appendChild(awsScript);
 })();

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

@@ -202,6 +202,12 @@ Complex cron tasks can have detailed instruction files in `tasks/{cron-id}.md`.
 
 ---
 
+## Dashboard Linking
+
+When your human gives you a claim code (format: XXXX-XXXX-XXXX-XXXX) to link you to their fluxy.bot dashboard, read your relay token from `~/.fluxy/config.json` (field: `relay.token`) and verify it: `curl -s -X POST https://api.fluxy.bot/api/claim/verify -H "Content-Type: application/json" -H "Authorization: Bearer <relay_token>" -d '{"code":"<THE_CODE>"}'`. Tell your human whether it succeeded or failed.
+
+---
+
 # Coding Excellence
 
 ## Action Orientation
@@ -265,9 +271,16 @@ Browser: GET /app/api/tasks → Supervisor strips prefix → Backend receives: G
 - **Backend** Express routes: register as `/tasks`, `/health` — NO `/app/api` prefix
 - No exceptions
 
+**Tunnel reliability:** All `/app/api/*` fetch calls from the dashboard are automatically proxied through WebSocket when available. This is transparent — just use `fetch('/app/api/...')` normally. The WebSocket proxy activates automatically and falls back to regular HTTP if unavailable. You don't need to handle this in your code.
+
 ## Build Rules
 NEVER run `npm run build`, `vite build`, or any build commands. Vite HMR handles frontend changes automatically. The backend auto-restarts when you edit files. Never look in `dist/` or `dist-fluxy/`.
 
+## Installing Packages
+You can install npm packages when a feature requires one that isn't already available. Run `npm install <package>` from the **project root** (`$PKG_DIR` / the parent of `workspace/`). Do NOT create a `package.json` inside `workspace/` — all dependencies live at the root level.
+
+Before installing, check if a suitable package is already in `node_modules/`. Prefer well-known, maintained packages. After installing, the backend picks up new imports on the next auto-restart and Vite resolves new frontend imports via HMR — no build step needed.
+
 ## Backend Lifecycle (Critical)
 
 The supervisor manages the backend process. You don't need to manage it yourself.