fluxy-bot 0.10.17 → 0.10.19

package/cli/commands/update.ts

@@ -88,13 +88,33 @@ export function registerUpdateCommand(program: Command) {
           fs.cpSync(wsSrc, path.join(DATA_DIR, 'workspace'), { recursive: true });
         }
 
-        // Always update index.html — contains splash screen, SW registration,
-        // and meta tags that ship with each version. Safe to overwrite since
-        // users don't edit this file (their code lives in src/ and backend/).
-        const indexSrc = path.join(extracted, 'workspace', 'client', 'index.html');
-        const indexDst = path.join(DATA_DIR, 'workspace', 'client', 'index.html');
-        if (fs.existsSync(indexSrc)) {
-          fs.cpSync(indexSrc, indexDst, { force: true });
+        // Always update framework files that ship with each version.
+        // These are not user-editable — user code lives in src/components/, src/pages/, backend/, etc.
+        const frameworkFiles = [
+          'workspace/client/index.html',       // splash screen, SW registration, meta tags
+          'workspace/client/src/main.tsx',      // React entry point, app-ready signal
+        ];
+        for (const rel of frameworkFiles) {
+          const src = path.join(extracted, rel);
+          const dst = path.join(DATA_DIR, rel);
+          if (fs.existsSync(src)) {
+            fs.cpSync(src, dst, { force: true });
+          }
+        }
+
+        // Always update public assets that ship with the framework (animation spritesheet, icons).
+        // Only copy specific files — never overwrite user-added public assets.
+        const frameworkAssets = [
+          'spritesheet.webp',
+        ];
+        const publicSrc = path.join(extracted, 'workspace', 'client', 'public');
+        const publicDst = path.join(DATA_DIR, 'workspace', 'client', 'public');
+        for (const asset of frameworkAssets) {
+          const src = path.join(publicSrc, asset);
+          const dst = path.join(publicDst, asset);
+          if (fs.existsSync(src)) {
+            fs.cpSync(src, dst, { force: true });
+          }
         }
 
         for (const file of ['package.json', 'vite.config.ts', 'vite.fluxy.config.ts', 'tsconfig.json', 'postcss.config.js', 'components.json']) {

package/package.json

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

package/supervisor/widget.js

@@ -34,28 +34,39 @@
   panel.appendChild(iframe);
 
   // ══════════════════════════════════════════════════════════════════
-  // ── Canvas Particle Animation (Splash + Bubble) ──────────────────
+  // ── Sprite Sheet Animation (Splash + Bubble) ─────────────────────
   // ══════════════════════════════════════════════════════════════════
 
-  // ── Config ──
-  var TARGET_HEIGHT = 40;
-  var SAMPLE_RES = 60;
-  var MELT_DURATION = 750;
-  var REFORM_DURATION = 850;
-  var TRAVEL_MIN = 400;
-  var TRAVEL_MAX = 1100;
-  var TRAVEL_PX_PER_MS = 0.9;
+  // ── Sprite config ──
+  var COLS = 16;
+  var FRAME_W = 125;
+  var FRAME_H = 120;
+  var DISPLAY_H = 58;
+  var DISPLAY_W = DISPLAY_H * (FRAME_W / FRAME_H);
+
+  // Frame ranges (0-indexed)
+  var IDLE_START = 0, IDLE_END = 29;
+  var MELT_START = 30, MELT_END = 52;
+  var TRAVEL_START = 52, TRAVEL_END = 84;
+  var REFORM_START = 84, REFORM_END = 191;
+
+  // Timing
+  var FPS = 29;
+  var FRAME_MS = 1000 / FPS;
+  var IDLE_FPS = 22;
+  var IDLE_FRAME_MS = 1000 / IDLE_FPS;
+  var REFORM_FPS = 70;
+  var REFORM_FRAME_MS = 1000 / REFORM_FPS;
+
+  var TRAVEL_PX_PER_MS = 0.65;
+  var TRAVEL_MIN = 385;
+  var TRAVEL_MAX = 1150;
   var MIN_SPLASH_MS = 2000;
   var BUBBLE_SIZE = 60;
   var BUBBLE_MARGIN = 24;
 
   // ── Easing ──
-  function easeInCubic(t) { return t * t * t; }
   function easeInOutCubic(t) { return t < 0.5 ? 4*t*t*t : 1 - Math.pow(-2*t + 2, 3) / 2; }
-  function easeOutElastic(t) {
-    if (t === 0 || t === 1) return t;
-    return Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * (2 * Math.PI / 3)) + 1;
-  }
 
   // ── Canvas setup (starts fullscreen for splash) ──
   var canvas = document.createElement('canvas');
@@ -66,16 +77,17 @@
   canvas.style.cssText = 'position:fixed;inset:0;width:100vw;height:100dvh;z-index:9999;pointer-events:none;';
   document.body.appendChild(canvas);
 
-  var bubble = canvas; // alias for toggle/click compatibility
+  var bubble = canvas;
   var ctx = canvas.getContext('2d');
   var dpr = window.devicePixelRatio || 1;
   var W = 0, H = 0;
 
-  // ── Canvas phase: 'splash' | 'transitioning' | 'bubble' ──
+  // ── Canvas phase: 'splash' | 'transitioning' | 'bubble' | 'disabled' ──
   var canvasPhase = 'splash';
   var canvasCreatedAt = Date.now();
   var appReady = false;
   var hideAfterTransition = false;
+  var skipSplash = false;
 
   function resizeCanvas() {
     if (canvasPhase === 'bubble') {
@@ -94,105 +106,36 @@
   resizeCanvas();
   window.addEventListener('resize', function () {
     resizeCanvas();
-    // Recalculate center position during splash
     if (canvasPhase === 'splash' && animState === 'idle') {
       center.x = Math.round(W / 2);
       center.y = Math.round(H / 2);
     }
   });
 
-  // ── Particle state ──
-  var particles = [];
-  var preRendered = null;
-  var displayW = 0, displayH = 0;
-  var particleRadius = 0;
-  var animState = 'loading'; // particle animation state
-  var phaseStart = 0;
+  // ── Animation state ──
+  var spriteSheet = null;
+  var animState = 'loading';
+  var currentFrame = 0;
+  var idleDirection = 1;
+  var lastFrameTime = 0;
   var travelDuration = 0;
+  var travelStartTime = 0;
+  var travelAngle = 0;
+  var travelDrawAngle = 0;
+  var travelFlip = 1;
 
   var center  = { x: 0, y: 0 };
   var travelA = { x: 0, y: 0 };
   var target  = { x: 0, y: 0 };
 
-  // ── Particle constructor ──
-  function Particle(localX, localY, r, g, b, a) {
-    this.localX = localX;
-    this.localY = localY;
-    this.r = r;
-    this.g = g;
-    this.b = b;
-    this.a = a;
-    this.x = 0;
-    this.y = 0;
-
-    var normalizedY = (localY + displayH / 2) / displayH;
-
-    // Melt into an elliptical blob
-    var angle = Math.random() * Math.PI * 2;
-    var dist = Math.sqrt(Math.random());
-    var blobRX = displayW * 0.28;
-    var blobRY = displayH * 0.18;
-    this.meltLocalX = Math.cos(angle) * dist * blobRX;
-    this.meltLocalY = Math.sin(angle) * dist * blobRY + displayH * 0.3;
-
-    // Stagger: top particles melt first
-    this.meltDelay = normalizedY * 0.35;
-
-    this.wobbleAmp = 0.5 + Math.random() * 1.5;
-    this.wobbleFreq = 3 + Math.random() * 4;
-    this.wobblePhase = Math.random() * Math.PI * 2;
-  }
-
-  // ── Load mascot ──
-  function loadMascot(onDone, onFail) {
+  // ── Load sprite sheet ──
+  function loadSprite(onDone, onFail) {
     var img = new Image();
     img.onload = function () {
-      var aspect = img.width / img.height;
-      displayH = TARGET_HEIGHT;
-      displayW = TARGET_HEIGHT * aspect;
-
-      // Pre-render at high DPR for crisp display
-      var preScale = dpr * 2;
-      var pre = document.createElement('canvas');
-      var preCtx = pre.getContext('2d');
-      pre.width = Math.round(displayW * preScale);
-      pre.height = Math.round(displayH * preScale);
-      preCtx.imageSmoothingEnabled = true;
-      preCtx.imageSmoothingQuality = 'high';
-      preCtx.drawImage(img, 0, 0, pre.width, pre.height);
-      preRendered = pre;
-
-      // Sample pixels for particles
-      var sampleH = SAMPLE_RES;
-      var sampleW = Math.round(SAMPLE_RES * aspect);
-
-      var off = document.createElement('canvas');
-      var offCtx = off.getContext('2d');
-      off.width = sampleW;
-      off.height = sampleH;
-      offCtx.imageSmoothingEnabled = true;
-      offCtx.imageSmoothingQuality = 'high';
-      offCtx.drawImage(img, 0, 0, sampleW, sampleH);
-
-      var data = offCtx.getImageData(0, 0, sampleW, sampleH).data;
-      var scaleX = displayW / sampleW;
-      var scaleY = displayH / sampleH;
-      particleRadius = (scaleX + scaleY) / 2 * 0.7;
-
-      for (var y = 0; y < sampleH; y++) {
-        for (var x = 0; x < sampleW; x++) {
-          var i = (y * sampleW + x) * 4;
-          if (data[i + 3] > 50) {
-            var lx = (x - sampleW / 2) * scaleX;
-            var ly = (y - sampleH / 2) * scaleY;
-            particles.push(new Particle(lx, ly, data[i], data[i+1], data[i+2], data[i+3] / 255));
-          }
-        }
-      }
-
-      // Start idle in center
+      spriteSheet = img;
       center.x = Math.round(W / 2);
       center.y = Math.round(H / 2);
+      currentFrame = IDLE_START;
       animState = 'idle';
 
       // Hide the HTML splash fallback
@@ -204,7 +147,7 @@
     img.onerror = function () {
       if (onFail) onFail();
     };
-    img.src = '/fluxy.png';
+    img.src = '/spritesheet.webp';
   }
 
   // ── Trigger move ──
@@ -214,122 +157,129 @@
     target.y = ty;
     travelA.x = center.x;
     travelA.y = center.y;
+
+    var dx = target.x - center.x;
+    var dy = target.y - center.y;
+    var dist = Math.sqrt(dx * dx + dy * dy);
+
+    travelAngle = Math.atan2(dy, dx);
+    travelDrawAngle = travelAngle;
+    travelFlip = 1;
+    if (travelDrawAngle > Math.PI / 2) { travelDrawAngle -= Math.PI; travelFlip = -1; }
+    else if (travelDrawAngle < -Math.PI / 2) { travelDrawAngle += Math.PI; travelFlip = -1; }
+    travelDuration = Math.min(TRAVEL_MAX, Math.max(TRAVEL_MIN, dist / TRAVEL_PX_PER_MS));
+
+    currentFrame = MELT_START;
+    lastFrameTime = performance.now();
     animState = 'melting';
-    phaseStart = performance.now();
   }
 
   // ── Update ──
   function update(now) {
-    var elapsed = now - phaseStart;
-    var i, p, t, e, cx, cy, wx, wy;
+    // Smooth position update during travel (every rAF)
+    if (animState === 'traveling') {
+      var elapsed = now - travelStartTime;
+      var progress = Math.min(1, elapsed / travelDuration);
+      var e = easeInOutCubic(progress);
+      center.x = travelA.x + (target.x - travelA.x) * e;
+      center.y = travelA.y + (target.y - travelA.y) * e;
 
-    if (animState === 'melting') {
-      var progress = elapsed / MELT_DURATION;
       if (progress >= 1) {
-        progress = 1;
-        var dx = target.x - travelA.x;
-        var dy = target.y - travelA.y;
-        var dist = Math.sqrt(dx*dx + dy*dy);
-        travelDuration = Math.min(TRAVEL_MAX, Math.max(TRAVEL_MIN, dist / TRAVEL_PX_PER_MS));
-        animState = 'traveling';
-        phaseStart = now;
-      }
-      for (i = 0; i < particles.length; i++) {
-        p = particles[i];
-        t = Math.max(0, Math.min(1, (progress - p.meltDelay) / (1 - p.meltDelay)));
-        e = easeInCubic(t);
-        p.x = center.x + p.localX + (p.meltLocalX - p.localX) * e;
-        p.y = center.y + p.localY + (p.meltLocalY - p.localY) * e;
-      }
-      return;
-    }
-
-    if (animState === 'traveling') {
-      var progress2 = elapsed / travelDuration;
-      if (progress2 >= 1) {
-        progress2 = 1;
         center.x = target.x;
         center.y = target.y;
         animState = 'reforming';
-        phaseStart = now;
-      }
-      e = easeInOutCubic(progress2);
-      cx = travelA.x + (target.x - travelA.x) * e;
-      cy = travelA.y + (target.y - travelA.y) * e;
-      for (i = 0; i < particles.length; i++) {
-        p = particles[i];
-        wx = Math.sin(now * 0.008 * p.wobbleFreq + p.wobblePhase) * p.wobbleAmp;
-        wy = Math.cos(now * 0.006 * p.wobbleFreq + p.wobblePhase) * p.wobbleAmp * 0.5;
-        p.x = cx + p.meltLocalX + wx;
-        p.y = cy + p.meltLocalY + wy;
+        currentFrame = REFORM_START;
+        lastFrameTime = now;
+        return;
       }
-      return;
     }
 
-    if (animState === 'reforming') {
-      var progress3 = elapsed / REFORM_DURATION;
-      if (progress3 >= 1) {
-        progress3 = 1;
+    // Sprite frame advance (at configured FPS)
+    var frameInterval = animState === 'idle' ? IDLE_FRAME_MS
+                      : animState === 'reforming' ? REFORM_FRAME_MS
+                      : FRAME_MS;
+    var frameDelta = now - lastFrameTime;
+    if (frameDelta < frameInterval) return;
+    lastFrameTime = now - (frameDelta % frameInterval);
+
+    if (animState === 'idle') {
+      currentFrame += idleDirection;
+      if (currentFrame >= IDLE_END) { currentFrame = IDLE_END; idleDirection = -1; }
+      else if (currentFrame <= IDLE_START) { currentFrame = IDLE_START; idleDirection = 1; }
+    } else if (animState === 'melting') {
+      currentFrame++;
+      if (currentFrame > MELT_END) {
+        animState = 'traveling';
+        currentFrame = TRAVEL_START;
+        travelStartTime = now;
+      }
+    } else if (animState === 'traveling') {
+      currentFrame++;
+      if (currentFrame > TRAVEL_END) currentFrame = TRAVEL_START;
+    } else if (animState === 'reforming') {
+      currentFrame++;
+      if (currentFrame > REFORM_END) {
         animState = 'idle';
+        currentFrame = IDLE_START;
+        idleDirection = 1;
         // Transition canvas to bubble mode
         if (canvasPhase === 'transitioning') {
           canvasPhase = 'bubble';
-          canvas.style.cssText = 'position:fixed;bottom:' + BUBBLE_MARGIN + 'px;right:' + BUBBLE_MARGIN + 'px;width:' + BUBBLE_SIZE + 'px;height:' + BUBBLE_SIZE + 'px;z-index:99998;cursor:pointer;border-radius:50%;';
+          canvas.style.cssText = 'position:fixed;bottom:' + BUBBLE_MARGIN + 'px;right:' + BUBBLE_MARGIN + 'px;width:' + BUBBLE_SIZE + 'px;height:' + BUBBLE_SIZE + 'px;z-index:99998;cursor:pointer;border-radius:50%;transition:transform .15s ease;-webkit-tap-highlight-color:transparent;';
           W = BUBBLE_SIZE;
           H = BUBBLE_SIZE;
           canvas.width = BUBBLE_SIZE * dpr;
           canvas.height = BUBBLE_SIZE * dpr;
           ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
-          // Center is now the center of the bubble canvas
           center.x = BUBBLE_SIZE / 2;
           center.y = BUBBLE_SIZE / 2;
-          // Handle onboard hide
           if (hideAfterTransition) {
             canvas.style.display = 'none';
           }
         }
       }
-      e = easeOutElastic(progress3);
-      for (i = 0; i < particles.length; i++) {
-        p = particles[i];
-        p.x = center.x + p.meltLocalX + (p.localX - p.meltLocalX) * e;
-        p.y = center.y + p.meltLocalY + (p.localY - p.meltLocalY) * e;
-      }
     }
   }
 
   // ── Draw ──
+  function drawFrame(frame, x, y, rotate, flipX) {
+    if (!spriteSheet) return;
+    var col = frame % COLS;
+    var row = Math.floor(frame / COLS);
+    var sx = col * FRAME_W;
+    var sy = row * FRAME_H;
+
+    ctx.save();
+    ctx.translate(x, y);
+    if (rotate) ctx.rotate(rotate);
+    if (flipX === -1) ctx.scale(-1, 1);
+    ctx.imageSmoothingEnabled = true;
+    ctx.imageSmoothingQuality = 'high';
+    ctx.drawImage(
+      spriteSheet,
+      sx, sy, FRAME_W, FRAME_H,
+      -DISPLAY_W / 2, -DISPLAY_H / 2,
+      DISPLAY_W, DISPLAY_H
+    );
+    ctx.restore();
+  }
+
   function draw(now) {
     ctx.clearRect(0, 0, W, H);
+    if (!spriteSheet || animState === 'loading') return;
 
-    if (animState === 'idle' && preRendered) {
-      var bob = Math.sin(now * 0.002) * 1;
-      ctx.imageSmoothingEnabled = true;
-      ctx.imageSmoothingQuality = 'high';
-      ctx.drawImage(
-        preRendered,
-        center.x - displayW / 2,
-        center.y - displayH / 2 + bob,
-        displayW,
-        displayH
-      );
-    } else if (animState !== 'loading') {
-      var r = particleRadius;
-      for (var i = 0; i < particles.length; i++) {
-        var p = particles[i];
-        // In transitioning/bubble phase, offset particles relative to canvas
-        var px = p.x;
-        var py = p.y;
-        if (canvasPhase === 'splash' || canvasPhase === 'transitioning') {
-          // Particles are in screen coordinates during splash/transition
-        }
-        ctx.globalAlpha = p.a;
-        ctx.fillStyle = 'rgb(' + p.r + ',' + p.g + ',' + p.b + ')';
-        ctx.beginPath();
-        ctx.arc(px, py, r, 0, Math.PI * 2);
-        ctx.fill();
-      }
-      ctx.globalAlpha = 1;
+    if (animState === 'melting') {
+      var p = (currentFrame - MELT_START) / (MELT_END - MELT_START);
+      var eased = p * p;
+      drawFrame(currentFrame, center.x, center.y, travelDrawAngle * eased, travelFlip);
+    } else if (animState === 'traveling') {
+      drawFrame(currentFrame, center.x, center.y, travelDrawAngle, travelFlip);
+    } else if (animState === 'reforming') {
+      var p2 = (currentFrame - REFORM_START) / (REFORM_END - REFORM_START);
+      var eased2 = 1 - (1 - p2) * (1 - p2);
+      drawFrame(currentFrame, center.x, center.y, travelDrawAngle * (1 - eased2));
+    } else {
+      drawFrame(currentFrame, center.x, center.y);
     }
   }
 
@@ -355,34 +305,70 @@
 
   function triggerTransition() {
     canvasPhase = 'transitioning';
-    // Target: center of the 60x60 bubble area at bottom-right
     var tx = W - BUBBLE_MARGIN - BUBBLE_SIZE / 2;
     var ty = H - BUBBLE_MARGIN - BUBBLE_SIZE / 2;
     moveTo(tx, ty);
   }
 
+  // Skip splash and go straight to bubble mode (for onboard / instant load)
+  function skipToBubble() {
+    canvasPhase = 'bubble';
+    canvas.style.cssText = 'position:fixed;bottom:' + BUBBLE_MARGIN + 'px;right:' + BUBBLE_MARGIN + 'px;width:' + BUBBLE_SIZE + 'px;height:' + BUBBLE_SIZE + 'px;z-index:99998;cursor:pointer;border-radius:50%;transition:transform .15s ease;-webkit-tap-highlight-color:transparent;';
+    W = BUBBLE_SIZE;
+    H = BUBBLE_SIZE;
+    canvas.width = BUBBLE_SIZE * dpr;
+    canvas.height = BUBBLE_SIZE * dpr;
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    center.x = BUBBLE_SIZE / 2;
+    center.y = BUBBLE_SIZE / 2;
+    currentFrame = IDLE_START;
+    idleDirection = 1;
+    animState = 'idle';
+    // Hide the HTML splash fallback
+    var splash = document.getElementById('splash');
+    if (splash) splash.style.display = 'none';
+  }
+
   window.addEventListener('fluxy:app-ready', function () {
     appReady = true;
     maybeTransition();
   });
-  // Race condition guard: check if main.tsx already fired before we registered
   if (window.__fluxyAppReady) {
     appReady = true;
   }
 
-  // ── Start ──
-  loadMascot(
-    function onSuccess() {
-      requestAnimationFrame(loop);
-      // Check if app is already ready
-      maybeTransition();
-    },
-    function onFail() {
-      // Image failed — leave HTML splash visible, hide canvas
-      canvas.style.display = 'none';
-      canvasPhase = 'bubble'; // prevent further transitions
-    }
-  );
+  // ── Check onboard status, then start ──
+  // First-time users get the onboard wizard — skip the splash animation.
+  var onboardActive = false;
+  fetch('/api/settings')
+    .then(function (r) { return r.json(); })
+    .then(function (s) {
+      if (s.onboard_complete !== 'true') {
+        onboardActive = true;
+        skipSplash = true;
+      }
+      startAnimation();
+    })
+    .catch(function () {
+      startAnimation();
+    });
+
+  function startAnimation() {
+    loadSprite(
+      function onSuccess() {
+        if (skipSplash) {
+          skipToBubble();
+          if (onboardActive) canvas.style.display = 'none';
+        }
+        requestAnimationFrame(loop);
+        maybeTransition();
+      },
+      function onFail() {
+        canvas.style.display = 'none';
+        canvasPhase = 'disabled';
+      }
+    );
+  }
 
   // ══════════════════════════════════════════════════════════════════
   // ── Widget Interaction (Panel, Toggle, Messages) ─────────────────
@@ -391,7 +377,7 @@
   var isOpen = false;
 
   function toggle() {
-    if (canvasPhase !== 'bubble') return; // only allow toggle after animation settles
+    if (canvasPhase !== 'bubble') return;
     isOpen = !isOpen;
     panel.classList.toggle('open', isOpen);
     backdrop.classList.toggle('open', isOpen);
@@ -419,10 +405,8 @@
   window.addEventListener('message', function (e) {
     if (!e.data || !e.data.type) return;
 
-    // Close chat panel
     if (e.data.type === 'fluxy:close' && isOpen) toggle();
 
-    // Install App request from chat iframe
     if (e.data.type === 'fluxy:install-app') {
       if (deferredInstallPrompt) {
         deferredInstallPrompt.prompt();
@@ -430,46 +414,27 @@
           if (result.outcome === 'accepted') deferredInstallPrompt = null;
         });
       } else {
-        // No native prompt available — tell chat to show instructions modal
         iframe.contentWindow.postMessage({ type: 'fluxy:show-ios-install' }, '*');
       }
     }
+
+    // Onboard complete — show the bubble
+    if (e.data.type === 'fluxy:onboard-complete') {
+      onboardActive = false;
+      hideAfterTransition = false;
+      canvas.style.display = 'block';
+    }
   });
 
-  // Restore open state after HMR reload (so chat isn't disrupted)
+  // Restore open state after HMR reload
   try {
     if (sessionStorage.getItem('fluxy_widget_open') === '1') {
       sessionStorage.removeItem('fluxy_widget_open');
-      // Only restore if already in bubble phase
       if (canvasPhase === 'bubble') toggle();
     }
   } catch (e) {}
 
-  // Hide widget during initial onboard
-  try {
-    fetch('/api/settings')
-      .then(function (r) { return r.json(); })
-      .then(function (s) {
-        if (s.onboard_complete !== 'true') {
-          if (canvasPhase === 'bubble') {
-            canvas.style.display = 'none';
-          } else {
-            hideAfterTransition = true;
-          }
-          window.addEventListener('message', function onMsg(e) {
-            if (e.data && e.data.type === 'fluxy:onboard-complete') {
-              hideAfterTransition = false;
-              canvas.style.display = 'block';
-              window.removeEventListener('message', onMsg);
-            }
-          });
-        }
-      })
-      .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);