Refactor audio handling to return base64 WAV data URIs instead of writing to disk. Updated generate_song function to streamline audio response and removed list_songs functionality, enhancing session management by keeping tapes in memory. Adjusted frontend to handle new audio data format and removed unused functions for a cleaner codebase.

.claude/launch.json

@@ -4,7 +4,7 @@
     {
       "name": "lofinity",
       "runtimeExecutable": "/bin/sh",
-      "runtimeArgs": ["-c", "GRADIO_SERVER_PORT=$PORT exec .venv/bin/python app.py"],
+      "runtimeArgs": ["-c", "GRADIO_SERVER_PORT=$PORT LOFINITY_ENGINE=stub exec .venv/bin/python app.py"],
       "port": 7860,
       "autoPort": true
     }

app.py

@@ -16,24 +16,21 @@ Env knobs:
   OLLAMA_MODEL      default llama3.2:3b
 """
 
+import base64
+import io
 import json
 import os
 import threading
-import time
-import uuid
 import wave
 from pathlib import Path
 
 import httpx
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
-from gradio import FileData
 from gradio.server import Server
 
 ROOT = Path(__file__).parent
 FRONTEND = ROOT / "frontend"
-SONGS_DIR = ROOT / ".cache" / "songs"
-SONGS_DIR.mkdir(parents=True, exist_ok=True)
 
 ENGINE = os.getenv("LOFINITY_ENGINE", "musicgen")
 # 30s is musicgen-small's single-shot max (1500 tokens of context)
@@ -142,7 +139,12 @@ def load_musicgen():
     return _musicgen
 
 
-def write_wav(samples, rate: int) -> Path:
+def encode_wav(samples, rate: int) -> str:
+    """Encode mono float samples as a base64 WAV data URI, entirely in memory.
+
+    Nothing is written to disk: on a shared HF Space a songs directory is
+    visible to every visitor and grows without bound. Returning the tape
+    inline keeps it private to the one request that asked for it."""
     import numpy as np
 
     # MusicGen can exceed [-1, 1]; normalize instead of hard-clipping
@@ -150,13 +152,14 @@ def write_wav(samples, rate: int) -> Path:
     if peak > 0.95:
         samples = samples * (0.95 / peak)
     pcm = (samples * 32767).astype("<i2")
-    out = SONGS_DIR / f"{uuid.uuid4().hex}.wav"
-    with wave.open(str(out), "wb") as w:
+    buf = io.BytesIO()
+    with wave.open(buf, "wb") as w:
         w.setnchannels(1)
         w.setsampwidth(2)
         w.setframerate(rate)
         w.writeframes(pcm.tobytes())
-    return out
+    b64 = base64.b64encode(buf.getvalue()).decode("ascii")
+    return f"data:audio/wav;base64,{b64}"
 
 
 def musicgen_engine(music_prompt: str) -> tuple:
@@ -214,42 +217,10 @@ def generate_song(prompt: str) -> dict:
         samples = ambience.mix(samples, rate, bed)
     except Exception as e:  # noqa: BLE001 — a dry tape beats a failed vend
         print(f"[lofinity] ambience mix failed ({e!r}), vending without the bed")
-    out = write_wav(samples, rate)
-    # sidecar metadata so the tape shows up in the collection later
-    out.with_suffix(".json").write_text(
-        json.dumps(
-            {"title": title, "prompt": prompt, "ambience": bed, "created": time.time()}
-        )
-    )
-    return {
-        "title": title,
-        # url is what browser clients play from; the path alone only works
-        # for the python client, which builds the file URL itself
-        "audio": FileData(path=str(out), url=f"/gradio_api/file={out}"),
-    }
-
-
-@app.api(name="list_songs")
-def list_songs() -> list:
-    """Every tape actually vended, newest first. A wav without its sidecar
-    label is not a tape the user owns (stub tones, dev leftovers) — skip it."""
-    songs = []
-    for wav in SONGS_DIR.glob("*.wav"):
-        meta_path = wav.with_suffix(".json")
-        if not meta_path.exists():
-            continue
-        title, created = "Untitled Tape", wav.stat().st_mtime
-        try:
-            meta = json.loads(meta_path.read_text())
-            title = str(meta.get("title") or title)
-            created = float(meta.get("created") or created)
-        except (ValueError, OSError):
-            pass  # a torn label, but the tape was vended — still plays fine
-        songs.append(
-            {"title": title, "created": created, "url": f"/gradio_api/file={wav}"}
-        )
-    songs.sort(key=lambda s: s["created"], reverse=True)
-    return songs
+    # The tape rides back inline as a base64 data URI — no disk write, so it is
+    # never cached on the Space nor shared with other visitors. The frontend
+    # keeps the collection client-side, per browser session.
+    return {"title": title, "audio": encode_wav(samples, rate)}
 
 
 @app.get("/")
@@ -260,4 +231,4 @@ async def homepage():
 app.mount("/static", StaticFiles(directory=FRONTEND), name="static")
 
 if __name__ == "__main__":
-    app.launch(show_error=True, allowed_paths=[str(SONGS_DIR)])
+    app.launch(show_error=True)

frontend/main.js

@@ -480,17 +480,12 @@ try {
 // ---------------------------------------------------------------------------
 
 let generateFn = null;
-let listSongsFn = null;
 
 const ui = initUI({
   generate: (prompt) => {
     if (!generateFn) return Promise.reject(new Error("backend not connected"));
     return generateFn(prompt);
   },
-  listSongs: () => {
-    if (!listSongsFn) return Promise.reject(new Error("backend not connected"));
-    return listSongsFn();
-  },
   onRequestClose: () => {
     if (view.mode === "machine") closeMachineView();
   },
@@ -516,17 +511,16 @@ import("https://cdn.jsdelivr.net/npm/@gradio/client/dist/index.min.js")
     generateFn = async (prompt) => {
       const result = await client.predict("/generate_song", { prompt });
       const data = result.data[0];
-      const url =
-        data.audio?.url ??
-        (data.audio?.path ? `/gradio_api/file=${data.audio.path}` : null);
-      if (!url) throw new Error("no audio in response");
+      const dataUri = data.audio;
+      if (!dataUri) throw new Error("no audio in response");
+      // The tape comes back as an inline base64 WAV; pull it into a Blob URL —
+      // lighter for <audio> than a multi-MB data URI, and the blob's uuid path
+      // gives the collection a stable per-tape key. Nothing touches disk.
+      const blob = await (await fetch(dataUri)).blob();
+      const url = URL.createObjectURL(blob);
       return { title: data.title, url };
     };
-    listSongsFn = async () => {
-      const result = await client.predict("/list_songs", {});
-      return result.data[0] ?? [];
-    };
-    window.lofinity = { generate: generateFn, listSongs: listSongsFn };
+    window.lofinity = { generate: generateFn };
     console.log("[LoFinity] backend connected");
   })
   .catch((err) => console.warn("[LoFinity] backend not reachable:", err));

frontend/ui.js

@@ -8,7 +8,6 @@ const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 export function initUI({
   generate,
-  listSongs,
   onRequestClose,
   onRequestCloseCollection,
   onRequestCloseGameboy,
@@ -65,6 +64,9 @@ export function initUI({
   let gameboyOpen = false;
   let garden = null; // the Game Boy garden mini-game (lazily started)
   let currentSong = null; // { title, url } of the tape in the deck
+  // The collection lives in memory, per browser session — never on the server,
+  // so tapes are private and a reload starts the shelf empty. Newest first.
+  const sessionTapes = [];
 
   function setStage(stage) {
     controlsRow.classList.toggle("hidden", stage !== "prompt");
@@ -109,6 +111,7 @@ export function initUI({
     try {
       // hold the brewing moment even if the backend is fast
       const [result] = await Promise.all([generate(prompt), delay(2600)]);
+      sessionTapes.unshift(result); // newest first, kept only for this session
       loadCassette(result);
       busy = false;
       setStage("cassette");
@@ -327,28 +330,18 @@ export function initUI({
     layoutCarousel();
   }
 
-  async function openCollection() {
+  function openCollection() {
     collectionOpen = true;
     collectionPanel.classList.remove("hidden");
     deck.classList.remove("hidden");
     syncPill();
     carousel.innerHTML = "";
-    setCollectionStatus("rummaging through the tapes…");
-    let songs;
-    try {
-      songs = await listSongs();
-    } catch (err) {
-      console.warn("[LoFinity] couldn't list tapes:", err);
-      if (collectionOpen) setCollectionStatus("the tape shelf is unreachable — try again later");
-      return;
-    }
-    if (!collectionOpen) return; // closed while we were rummaging
-    if (!songs.length) {
+    if (!sessionTapes.length) {
       setCollectionStatus("no tapes yet — go vend a vibe at the machine ♪");
       return;
     }
     setCollectionStatus(null);
-    renderCarousel(songs);
+    renderCarousel(sessionTapes);
   }
 
   function closeCollection() {