feat(spaces): prune output dir before each generation

Without cleanup, every video lands in `~/comfyui/output/` and stays there
until the container restarts. The ephemeral disk is 150 GB and preload
already eats ~111 GB, so accumulating generations on the ~39 GB headroom
fills the disk and the replica goes unhealthy — observed today as a
stuck `RUNNING` Space with `replicas.current=0` and the iframe returning
`net::ERR_ABORTED`. Restart cleared it; this prevents the recurrence.

4 h TTL sweep at the top of `_on_generate`. Per-file `OSError` is
swallowed so one bad inode can't abort the cleanup. Tests cover
older-than-threshold deletion, recent-file retention, recursive descent
into ComfyUI's `LTX2.3/` subdir, missing-dir tolerance, and directory
preservation.

app.py

@@ -871,6 +871,31 @@ def _seconds_to_frames(seconds: float, fps: int) -> int:
     return max(9, int(round(float(seconds) * float(fps) / 8) * 8) + 1)
 
 
+def _prune_old_outputs(output_dir: pathlib.Path, max_age_seconds: int = 4 * 3600) -> int:
+    """Delete files under *output_dir* older than *max_age_seconds*; return count.
+
+    HF Spaces ephemeral disk is 150 GB and preload already eats ~111 GB. Without
+    this sweep, generations accumulate in `~/comfyui/output/` until the disk
+    fills and the replica goes unhealthy (observed: stuck `RUNNING` with
+    `replicas.current=0`). Per-file OSError is swallowed so one bad file
+    doesn't abort a sweep that would otherwise free space.
+    """
+    if not output_dir.exists():
+        return 0
+    cutoff = time.time() - max_age_seconds
+    deleted = 0
+    for f in output_dir.rglob("*"):
+        try:
+            if not f.is_file():
+                continue
+            if f.stat().st_mtime < cutoff:
+                f.unlink()
+                deleted += 1
+        except OSError:
+            continue
+    return deleted
+
+
 async def _on_generate(mode_name: str, *, progress: Any = None, **inputs: Any):
     """Generate handler — async generator yielding (status_html, video_path).
 
@@ -879,6 +904,13 @@ async def _on_generate(mode_name: str, *, progress: Any = None, **inputs: Any):
     Spaces; we forward it to the backend so ComfyUI's per-step counter renders
     a real progress bar instead of a generic Gradio spinner.
     """
+    _comfy_dir_now = (
+        (pathlib.Path.home() / "comfyui")
+        if _on_spaces()
+        else pathlib.Path(__file__).parent / "comfyui"
+    )
+    _prune_old_outputs(_comfy_dir_now / "output")
+
     mode = modes.MODE_REGISTRY[mode_name]
 
     fps = int(inputs.get("fps", 24))

tests/test_output_pruning.py

@@ -0,0 +1,75 @@
+"""Tests for the output-dir TTL sweeper.
+
+ComfyUI writes every generated video/audio into `<comfy_dir>/output/...` and
+nothing in this app cleans them up — left alone, they accumulate until the
+Spaces ephemeral disk fills and the container goes unhealthy. `_prune_old_outputs`
+sweeps files older than a TTL each time the user clicks Generate.
+"""
+
+import os
+import pathlib
+import time
+
+import app
+
+
+def _touch(path: pathlib.Path, mtime: float | None = None) -> pathlib.Path:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(b"x")
+    if mtime is not None:
+        os.utime(path, (mtime, mtime))
+    return path
+
+
+def test_prune_old_outputs_deletes_files_older_than_threshold(tmp_path: pathlib.Path) -> None:
+    stale = _touch(tmp_path / "old.mp4", mtime=time.time() - 5 * 3600)
+
+    app._prune_old_outputs(tmp_path, max_age_seconds=4 * 3600)
+
+    assert not stale.exists()
+
+
+def test_prune_old_outputs_keeps_files_younger_than_threshold(tmp_path: pathlib.Path) -> None:
+    fresh = _touch(tmp_path / "new.mp4", mtime=time.time() - 60)
+
+    app._prune_old_outputs(tmp_path, max_age_seconds=4 * 3600)
+
+    assert fresh.exists()
+
+
+def test_prune_old_outputs_returns_deleted_count(tmp_path: pathlib.Path) -> None:
+    _touch(tmp_path / "a.mp4", mtime=time.time() - 5 * 3600)
+    _touch(tmp_path / "b.mp4", mtime=time.time() - 6 * 3600)
+    _touch(tmp_path / "fresh.mp4", mtime=time.time() - 60)
+
+    deleted = app._prune_old_outputs(tmp_path, max_age_seconds=4 * 3600)
+
+    assert deleted == 2
+
+
+def test_prune_old_outputs_recurses_into_subdirs(tmp_path: pathlib.Path) -> None:
+    # ComfyUI writes under <output>/LTX2.3/<filename>.mp4 — the sweeper has
+    # to descend or it'd never touch real outputs.
+    stale = _touch(tmp_path / "LTX2.3" / "old.mp4", mtime=time.time() - 5 * 3600)
+
+    app._prune_old_outputs(tmp_path, max_age_seconds=4 * 3600)
+
+    assert not stale.exists()
+
+
+def test_prune_old_outputs_handles_missing_directory(tmp_path: pathlib.Path) -> None:
+    missing = tmp_path / "does-not-exist"
+
+    # No-op, no crash. Returning 0 is the only sensible answer.
+    assert app._prune_old_outputs(missing, max_age_seconds=4 * 3600) == 0
+
+
+def test_prune_old_outputs_leaves_directories_alone(tmp_path: pathlib.Path) -> None:
+    # The sweeper deletes *files*. Subdirs should remain so the next
+    # generation can write into the same path layout.
+    subdir = tmp_path / "LTX2.3"
+    subdir.mkdir()
+
+    app._prune_old_outputs(tmp_path, max_age_seconds=4 * 3600)
+
+    assert subdir.exists() and subdir.is_dir()