chore: import upstream snapshot with attribution

desktop/ui/setup.js

@@ -0,0 +1,383 @@
+const { invoke } = window.__TAURI__.core;
+
+let _runtimeUnlisten = null;
+
+// The backend always binds all interfaces; network availability is gated live
+// by the backend itself (Settings → "Make StemDeck available on your network").
+function startBackend() {
+  return invoke("start_backend");
+}
+
+const statusEl = document.getElementById("status");
+const detailsEl = document.getElementById("details");
+const retryBtn = document.getElementById("retry");
+const steps = [...document.querySelectorAll("[data-step]")];
+
+function setStep(name, state) {
+  const el = steps.find((item) => item.dataset.step === name);
+  if (!el) return;
+  el.classList.remove("active", "done", "error");
+  if (state) el.classList.add(state);
+}
+
+function setStatus(message) {
+  statusEl.textContent = message;
+}
+
+function showError(error, hint) {
+  for (const el of steps) {
+    if (el.classList.contains("active")) {
+      el.classList.replace("active", "error");
+    }
+  }
+  setStatus("Setup could not complete.");
+  const msg = String(error?.message ?? error);
+  detailsEl.textContent = hint ? `${msg}\n\n→ ${hint}` : msg;
+  detailsEl.classList.remove("hidden");
+  retryBtn.classList.remove("hidden");
+}
+
+async function runStep(name, fn) {
+  setStep(name, "active");
+  try {
+    const result = await fn();
+    setStep(name, "done");
+    return result;
+  } catch (err) {
+    setStep(name, "error");
+    throw err;
+  }
+}
+
+function minDelay(ms) {
+  return Promise.all([
+    new Promise((r) => setTimeout(r, ms)),
+    new Promise((r) => requestAnimationFrame(r)),
+  ]);
+}
+
+function formatElapsed(startedAt) {
+  const seconds = Math.floor((Date.now() - startedAt) / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const rest = seconds % 60;
+  return minutes > 0 ? `${minutes}m ${rest}s` : `${rest}s`;
+}
+
+function startProgressStatus(messages) {
+  const startedAt = Date.now();
+  let messageIndex = 0;
+
+  const update = () => {
+    const elapsedSeconds = Math.floor((Date.now() - startedAt) / 1000);
+    while (
+      messageIndex + 1 < messages.length &&
+      elapsedSeconds >= messages[messageIndex + 1].afterSeconds
+    ) {
+      messageIndex += 1;
+    }
+
+    setStatus(`${messages[messageIndex].text} Elapsed: ${formatElapsed(startedAt)}.`);
+  };
+
+  update();
+  const timer = window.setInterval(update, 1000);
+  return () => window.clearInterval(timer);
+}
+
+function isMac() {
+  return /mac/i.test(navigator.userAgentData?.platform ?? navigator.platform ?? "");
+}
+
+async function installRuntimePack(appRoot) {
+  const status = await invoke("runtime_pack_status");
+  if (!status.manifestReady) {
+    throw Object.assign(
+      new Error(`Python runtime not found under ${appRoot}.`),
+      { hint: "Try reinstalling StemDeck. If the problem persists, check that your disk has at least 2 GB free." }
+    );
+  }
+
+  const progressWrap = document.getElementById("progress-wrap");
+  const progressFill = document.getElementById("progress-fill");
+
+  // lastProgressAt is updated by the SSE handler below; only meaningful
+  // during a network download, so it is reset just before download starts.
+  let lastReceived = 0;
+  let lastProgressAt = Date.now();
+  const STALL_WARN_MS = 30_000;
+
+  // Guard against stacked listeners on rapid retry (#146): unlisten any
+  // previous registration before creating a new one.
+  if (_runtimeUnlisten) { _runtimeUnlisten(); _runtimeUnlisten = null; }
+
+  const unlisten = await window.__TAURI__.event.listen(
+    "runtime-download-progress",
+    (event) => {
+      const { received, total } = event.payload;
+      if (received !== lastReceived) {
+        lastReceived = received;
+        lastProgressAt = Date.now();
+      }
+      const mb = (received / 1e6).toFixed(0);
+      if (total && total > 0) {
+        const pct = Math.min(100, Math.round((received / total) * 100));
+        progressFill.style.width = `${pct}%`;
+        progressFill.classList.remove("indeterminate");
+        setStatus(`Downloading StemDeck runtime... ${mb} / ${(total / 1e6).toFixed(0)} MB`);
+      } else {
+        progressFill.classList.add("indeterminate");
+        setStatus(`Downloading StemDeck runtime... ${mb} MB received`);
+      }
+    }
+  );
+  _runtimeUnlisten = unlisten;
+
+  progressWrap.classList.remove("hidden");
+  progressFill.style.width = "0%";
+  progressFill.classList.remove("indeterminate");
+
+  try {
+    let verified = false;
+    if (status.archiveReady) {
+      try {
+        setStatus("Runtime archive found locally, verifying...");
+        progressWrap.classList.add("hidden");
+        await invoke("verify_runtime_pack");
+        verified = true;
+      } catch {
+        // Stale or corrupt archive — fall through to re-download
+      }
+    }
+    if (!verified) {
+      progressWrap.classList.remove("hidden");
+      setStatus("Downloading StemDeck runtime...");
+
+      // Reset stall baseline when network download is actually about to start (#150).
+      lastProgressAt = Date.now();
+
+      // stallTimer starts here, not at top of function, so it doesn't fire
+      // during the local verify_runtime_pack path (#150).
+      // When a stall is detected it stops startProgressStatus first to avoid
+      // both timers writing setStatus concurrently (#149).
+      let stopSlowMsg = null;
+      const stallTimer = window.setInterval(() => {
+        const stallMs = Date.now() - lastProgressAt;
+        if (stallMs >= STALL_WARN_MS) {
+          if (stopSlowMsg) { stopSlowMsg(); stopSlowMsg = null; }
+          setStatus(
+            stallMs >= 60_000
+              ? "Download appears unreachable — check your internet connection and click Retry."
+              : "Download seems slow or stalled — check your internet connection."
+          );
+        }
+      }, 5_000);
+
+      // startProgressStatus is assigned after stallTimer creation; the closure
+      // above captures stopSlowMsg by reference, so it sees the updated value.
+      stopSlowMsg = startProgressStatus([
+        { afterSeconds: 0,  text: "Downloading StemDeck runtime..." },
+        { afterSeconds: 30, text: "Still downloading runtime... slow connection detected." },
+        { afterSeconds: 90, text: "Still downloading... large file on a slow connection can take a few minutes." },
+      ]);
+
+      try {
+        await invoke("download_runtime_pack");
+      } catch (err) {
+        throw Object.assign(
+          new Error(String(err)),
+          { hint: "Check your internet connection and click Retry. If the problem persists, try a different network." }
+        );
+      } finally {
+        window.clearInterval(stallTimer);
+        if (stopSlowMsg) { stopSlowMsg(); }
+      }
+      progressWrap.classList.add("hidden");
+      setStatus("Verifying StemDeck runtime...");
+      await invoke("verify_runtime_pack");
+    }
+    setStatus("Installing StemDeck runtime...");
+    const installed = await invoke("extract_runtime_pack");
+    if (!installed.runtimeReady) {
+      throw Object.assign(
+        new Error("Runtime install finished but Python/backend files were not found."),
+        { hint: "Your disk may be full or the archive may be corrupt. Free up space and click Retry to re-download." }
+      );
+    }
+  } finally {
+    _runtimeUnlisten = null;
+    unlisten();
+    progressWrap.classList.add("hidden");
+  }
+}
+
+async function runSetup() {
+  detailsEl.classList.add("hidden");
+  retryBtn.classList.add("hidden");
+  for (const step of steps) step.classList.remove("active", "done", "error");
+
+  try {
+    setStep("runtime", "active");
+    setStatus("Checking Python runtime...");
+    let [runtime] = await Promise.all([
+      invoke("probe_runtime"),
+      minDelay(350),
+    ]);
+
+    // Compare the installed runtime against the version this app bundle expects.
+    // On a DMG upgrade the old runtime is still fully "ready", so this MUST be
+    // checked before the early-return below -- otherwise setup starts the stale
+    // backend + frontend and the new release (e.g. new features, version) never
+    // takes effect until the runtime is manually cleared.
+    const runtimeStatus = await invoke("runtime_pack_status");
+    const expectedVersion = runtimeStatus.manifest?.version;
+    const installedVersion = runtimeStatus.installedVersion;
+    // Mismatch when this build expects a version the installed runtime isn't.
+    // An unknown installedVersion (a runtime from a build that never recorded
+    // one) also counts, so an upgrade still refreshes it. Self-heals: after one
+    // refresh the install records the version and subsequent launches match.
+    const versionMismatch = Boolean(expectedVersion) && installedVersion !== expectedVersion;
+
+    if (runtime.pythonReady && runtime.ffmpegReady && runtime.torchDevice && !versionMismatch) {
+      for (const step of steps) {
+        step.classList.remove("active", "error");
+        if (step.dataset.step === "backend") {
+          step.classList.remove("done");
+        } else {
+          step.classList.add("done");
+        }
+      }
+      await runStep("backend", async () => {
+        setStatus("Runtime is ready. Starting StemDeck backend...");
+        const backend = await startBackend();
+        setStatus("Opening StemDeck...");
+        window.location.replace(backend.url);
+      });
+      return;
+    }
+
+    if (!runtime.pythonReady || versionMismatch) {
+      if (versionMismatch) {
+        setStatus(`Updating runtime from ${installedVersion || "an older build"} to ${expectedVersion}...`);
+      }
+      await invoke("ensure_workspace");
+      await installRuntimePack(runtime.appRoot);
+      runtime = await invoke("probe_runtime");
+      if (!runtime.pythonReady) {
+        setStep("runtime", "error");
+        throw Object.assign(
+          new Error(`Python runtime setup failed under: ${runtime.dataDir}`),
+          { hint: "Check that your disk has at least 2 GB free and click Retry. If it keeps failing, try reinstalling StemDeck." }
+        );
+      }
+    }
+    setStep("runtime", "done");
+    setStatus(`Python runtime found at ${runtime.pythonPath}`);
+    await minDelay(200);
+
+    let gpuSummary = "";
+
+    await runStep("workspace", () => invoke("ensure_workspace"));
+
+    if (runtime.ffmpegReady) {
+      setStep("ffmpeg", "done");
+    } else {
+      await runStep("ffmpeg", async () => {
+        const stopProgress = startProgressStatus([
+          {
+            afterSeconds: 0,
+            text: "Downloading FFmpeg... this can take a few minutes on first run.",
+          },
+          {
+            afterSeconds: 60,
+            text: "Still downloading FFmpeg... slow networks or antivirus scans can delay this.",
+          },
+        ]);
+
+        try {
+          const assets = await invoke("ensure_external_assets");
+          if (!assets.ffmpegReady) {
+            throw new Error(
+              "FFmpeg setup did not complete. Check your internet connection and retry."
+            );
+          }
+        } finally {
+          stopProgress();
+        }
+      });
+    }
+
+    await runStep("gpu", async () => {
+      const macGPU = isMac();
+      const stopProgress = startProgressStatus(
+        macGPU
+          ? [
+              {
+                afterSeconds: 0,
+                text: "Checking Apple Silicon compute support...",
+              },
+              {
+                afterSeconds: 10,
+                text: "Verifying MPS acceleration for AI models...",
+              },
+            ]
+          : [
+              {
+                afterSeconds: 0,
+                text: "Checking NVIDIA GPU and compute support...",
+              },
+              {
+                afterSeconds: 20,
+                text: "Installing NVIDIA acceleration if needed... first run can take 5-15 minutes.",
+              },
+              {
+                afterSeconds: 120,
+                text: "Still installing NVIDIA acceleration... CUDA Torch packages are large.",
+              },
+              {
+                afterSeconds: 300,
+                text: "Still working... setup should finish or time out automatically.",
+              },
+            ]
+      );
+
+      try {
+        const gpu = await invoke("ensure_torch_device");
+        if (macGPU) {
+          gpuSummary =
+            gpu.torchDevice === "mps"
+              ? `${gpu.gpuName} acceleration enabled`
+              : "MPS acceleration unavailable - stem separation will use CPU";
+        } else {
+          if (gpu.gpuDetected && !gpu.cudaVerified) {
+            showError(
+              `GPU detected (${gpu.gpuName}) but CUDA setup failed - stem separation will use CPU.\nCheck logs/setup.log in the StemDeck data folder for details.`
+            );
+          }
+          gpuSummary = gpu.gpuDetected
+            ? gpu.cudaVerified
+              ? `${gpu.gpuName} - CUDA ${gpu.cudaVersion} enabled`
+              : `${gpu.gpuName} found - falling back to CPU (CUDA unverified)`
+            : "No NVIDIA GPU - stem separation will use CPU";
+        }
+        return gpu;
+      } finally {
+        stopProgress();
+      }
+    });
+
+    setStep("model", "done");
+    setStatus("AI separation model will download on first use (~340 MB).");
+
+    await runStep("backend", async () => {
+      setStatus(gpuSummary ? `${gpuSummary} - starting backend...` : "Starting StemDeck backend...");
+      const backend = await startBackend();
+      setStatus("Opening StemDeck...");
+      window.location.replace(backend.url);
+    });
+  } catch (error) {
+    showError(error, error?.hint);
+  }
+}
+
+retryBtn.addEventListener("click", runSetup);
+runSetup();