Add subtitle outputs and model preflight

app.py

@@ -40,6 +40,14 @@ COMFY_PROCESS: subprocess.Popen | None = None
 PREPARE_PROCESS: subprocess.Popen | None = None
 BOOTSTRAPPED = False
 BOOTSTRAP_LOG = Path("/tmp/voicegate_bootstrap.log")
+USER_OUTPUT_DIR = ROOT / "user_outputs"
+REQUIRED_MODEL_PATHS = [
+    COMFY_DIR / "models" / "diffusion_models" / "MelBandRoFormer_comfy" / "MelBandRoformer_fp32.safetensors",
+    COMFY_DIR / "models" / "voxcpm" / "VoxCPM2" / "model.safetensors",
+    COMFY_DIR / "models" / "voxcpm" / "VoxCPM2" / "audiovae.pth",
+    COMFY_DIR / "models" / "Qwen3-ASR" / "Qwen3-ASR-1.7B",
+    COMFY_DIR / "models" / "Qwen3-ASR" / "Qwen3-ForcedAligner-0.6B",
+]
 TARGET_LANGUAGES = [
     "Arabic",
     "Burmese",
@@ -133,6 +141,42 @@ def run_bootstrap(lines: list[str], *, allow_heavy: bool = True) -> None:
     BOOTSTRAPPED = True
 
 
+def missing_required_models() -> list[Path]:
+    return [path for path in REQUIRED_MODEL_PATHS if not path.exists()]
+
+
+def ensure_runtime_assets(lines: list[str]) -> None:
+    missing = missing_required_models()
+    if not missing:
+        lines.append("models=ready")
+        return
+
+    lines.append("models=missing")
+    lines.extend(f"missing_model={path}" for path in missing)
+    started = time.time()
+    command = [sys.executable, str(ROOT / "scripts" / "bootstrap_comfy.py"), "--with-models"]
+    result = subprocess.run(
+        command,
+        cwd=ROOT,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        timeout=1800,
+    )
+    lines.append(f"model_prepare_returncode={result.returncode}")
+    lines.append(f"model_prepare_elapsed_sec={time.time() - started:.1f}")
+    if result.returncode != 0:
+        lines.append("model_prepare_tail:")
+        lines.extend(result.stdout.splitlines()[-100:])
+        raise RuntimeError("Could not prepare required VoiceGate models.")
+    remaining = missing_required_models()
+    if remaining:
+        lines.append("models_still_missing:")
+        lines.extend(str(path) for path in remaining)
+        raise RuntimeError("Required VoiceGate models are still missing after preparation.")
+    lines.append("models=ready_after_prepare")
+
+
 def ensure_comfy(lines: list[str], *, timeout: float = 240) -> dict[str, Any]:
     global COMFY_PROCESS
 
@@ -346,6 +390,26 @@ def first_output_audio_path(history: dict[str, Any]) -> str | None:
     return None
 
 
+def text_outputs_for_node(history: dict[str, Any], node_id: str) -> list[str]:
+    node_output = (history.get("outputs", {}) or {}).get(node_id, {})
+    values: list[str] = []
+    for key in ("text", "string"):
+        raw_values = node_output.get(key, []) or []
+        if isinstance(raw_values, str):
+            raw_values = [raw_values]
+        values.extend(str(value) for value in raw_values if str(value).strip())
+    return values
+
+
+def write_srt_file(prefix: str, name: str, text: str) -> str | None:
+    if not text.strip():
+        return None
+    USER_OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    path = USER_OUTPUT_DIR / f"{prefix}_{name}.srt"
+    path.write_text(text, encoding="utf-8")
+    return str(path)
+
+
 def melband_workflow(audio_filename: str, prefix: str) -> dict[str, Any]:
     return {
         "1": {
@@ -489,14 +553,14 @@ def full_voicegate_workflow(audio_filename: str, prefix: str, target_language: s
     )
 
 
-def run_full_voicegate(audio_path: str | None, target_language: str, *, timeout: float = 880) -> tuple[list[str], str | None]:
+def run_full_voicegate(audio_path: str | None, target_language: str, *, timeout: float = 880) -> dict[str, Any]:
     lines = gpu_status_lines()
     started = time.time()
-    output_audio = None
     if not audio_path:
         raise ValueError("Please upload an audio file before running VoiceGate.")
     if not os.environ.get("DEEPSEEK_API_KEY"):
         raise RuntimeError("DEEPSEEK_API_KEY is not configured in the Space.")
+    ensure_runtime_assets(lines)
     ensure_comfy(lines)
     prefix = f"full_{uuid.uuid4().hex[:8]}"
     audio_filename = copy_audio_to_comfy_input(audio_path, prefix)
@@ -507,10 +571,25 @@ def run_full_voicegate(audio_path: str | None, target_language: str, *, timeout:
     lines.extend(timing_lines)
     lines.extend(history_summary(history))
     output_audio = first_output_audio_path(history)
+    source_subtitle = "\n\n".join(text_outputs_for_node(history, "61"))
+    translated_subtitle = "\n\n".join(text_outputs_for_node(history, "179") or text_outputs_for_node(history, "107"))
+    source_subtitle_file = write_srt_file(prefix, "source", source_subtitle)
+    translated_subtitle_file = write_srt_file(prefix, "translated", translated_subtitle)
     if output_audio:
         lines.append(f"output_audio_path={output_audio}")
+    if source_subtitle_file:
+        lines.append(f"source_subtitle_file={source_subtitle_file}")
+    if translated_subtitle_file:
+        lines.append(f"translated_subtitle_file={translated_subtitle_file}")
     lines.append(f"elapsed_sec={time.time() - started:.1f}")
-    return lines, output_audio
+    return {
+        "lines": lines,
+        "audio": output_audio,
+        "source_subtitle": source_subtitle,
+        "translated_subtitle": translated_subtitle,
+        "source_subtitle_file": source_subtitle_file,
+        "translated_subtitle_file": translated_subtitle_file,
+    }
 
 
 def prepare_runtime() -> str:
@@ -650,7 +729,8 @@ def asr_gpu_test(audio_path: str | None) -> str:
 @spaces.GPU(duration=900)
 def full_voicegate_gpu_test(audio_path: str | None, target_language: str) -> str:
     try:
-        lines, _output_audio = run_full_voicegate(audio_path, target_language, timeout=880)
+        result = run_full_voicegate(audio_path, target_language, timeout=880)
+        lines = result["lines"]
     except Exception as exc:
         lines = gpu_status_lines()
         lines.append(f"error={type(exc).__name__}: {exc}")
@@ -661,19 +741,35 @@ def full_voicegate_gpu_test(audio_path: str | None, target_language: str) -> str
 
 
 @spaces.GPU(duration=900)
-def voicegate_user_run(audio_path: str | None, target_language: str) -> tuple[str | None, str]:
+def voicegate_user_run(audio_path: str | None, target_language: str) -> tuple[
+    str | None,
+    str,
+    str | None,
+    str | None,
+    str,
+    str,
+]:
     try:
-        lines, output_audio = run_full_voicegate(audio_path, target_language, timeout=880)
+        result = run_full_voicegate(audio_path, target_language, timeout=880)
+        lines = result["lines"]
+        output_audio = result["audio"]
         if not output_audio:
             lines.append("warning=No output audio file was found in ComfyUI history.")
-        return output_audio, "\n".join(lines)
+        return (
+            output_audio,
+            "\n".join(lines),
+            result["source_subtitle_file"],
+            result["translated_subtitle_file"],
+            result["source_subtitle"],
+            result["translated_subtitle"],
+        )
     except Exception as exc:
         lines = gpu_status_lines()
         lines.append(f"error={type(exc).__name__}: {exc}")
         if COMFY_LOG.exists():
             lines.append("comfy_log_tail:")
             lines.extend(COMFY_LOG.read_text(encoding="utf-8", errors="replace").splitlines()[-160:])
-        return None, "\n".join(lines)
+        return None, "\n".join(lines), None, None, "", ""
 
 
 with gr.Blocks(title="VoiceGate") as demo:
@@ -687,11 +783,23 @@ with gr.Blocks(title="VoiceGate") as demo:
         )
         user_run = gr.Button("Generate translated dubbing", variant="primary")
         user_output_audio = gr.Audio(label="Translated dubbing audio", type="filepath")
+        with gr.Row():
+            user_source_file = gr.File(label="Original subtitle file")
+            user_translated_file = gr.File(label="Translated subtitle file")
+        user_source_text = gr.Textbox(label="Original subtitles", lines=8)
+        user_translated_text = gr.Textbox(label="Translated subtitles", lines=8)
         user_status = gr.Textbox(label="Status", lines=16)
         user_run.click(
             fn=voicegate_user_run,
             inputs=[user_audio, user_target_language],
-            outputs=[user_output_audio, user_status],
+            outputs=[
+                user_output_audio,
+                user_status,
+                user_source_file,
+                user_translated_file,
+                user_source_text,
+                user_translated_text,
+            ],
         )
 
     with gr.Tab("Diagnostics"):

docs/todo.md

@@ -95,10 +95,11 @@ from scaffold to a working Gradio app.
 - [x] Add target language input.
 - [x] Add status/log output.
 - [x] Add generated audio output.
-- [ ] Add generated SRT file outputs.
+- [x] Add generated SRT file outputs.
 - [ ] Wrap GPU-heavy execution with `@spaces.GPU(duration=...)`.
 - [x] Add and run a minimal GPU smoke test button.
 - [x] Keep a diagnostics tab for internal workflow tests.
+- [x] Add automatic model-path preparation for the user-facing run path.
 - [ ] Add guardrails for file type and duration.
 
 ## Phase 6: Minimal Runtime Tests
@@ -121,7 +122,7 @@ from scaffold to a working Gradio app.
 - [ ] Run the full short-audio VoiceGate workflow on the organization ZeroGPU
   Space after quota recovers.
 - [x] Confirm output audio is downloadable/playable from Gradio.
-- [ ] Confirm SRT files are downloadable from Gradio.
+- [ ] Confirm SRT files are downloadable from Gradio after redeploy.
 
 ## Phase 7: Full VoiceGate Path
 
@@ -144,6 +145,9 @@ from scaffold to a working Gradio app.
   ZeroGPU quota before execution.
 - [x] Can a full short-audio workflow run on T4 Small? Yes, on the duplicated
   personal Space with a warm ComfyUI process, the test completed in `24.4s`.
+- [x] How do we avoid user-facing failure after hardware changes? The user path
+  now checks required model paths and runs `bootstrap_comfy.py --with-models`
+  before submitting to ComfyUI.
 - [x] Where should large model files live? `/data/voicegate_models`, with
   symlinks into ComfyUI's expected model directories.
 - [ ] Should the first public demo disable background separation to reduce

docs/work-log.md

@@ -841,7 +841,8 @@ and may still hit runtime or memory limits.
 The first user-facing Gradio interface now has two tabs:
 
 - `Translate`: simple user flow with audio upload, target language dropdown,
-  generated translated dubbing audio output, and status.
+  generated translated dubbing audio output, original/translated subtitle text,
+  downloadable `.srt` subtitle files, and status.
 - `Diagnostics`: retained internal test controls for Prepare, GPU, ComfyUI,
   MelBand, VoxCPM TTS, ASR, and full workflow timing.
 
@@ -854,6 +855,31 @@ Norwegian, Polish, Portuguese, Russian, Spanish, Swahili, Swedish, Tagalog,
 Thai, Turkish, Vietnamese
 ```
 
+User-facing reliability pitfall found on the duplicated personal Space:
+
+- After switching/rebuilding hardware, ComfyUI started successfully but the
+  MelBand model list was empty.
+- `/prompt` failed with:
+
+```text
+MelBandRoFormerModelLoader 96
+model_name: 'MelBandRoFormer_comfy/MelBandRoformer_fp32.safetensors' not in []
+```
+
+Root cause: the runtime container had ComfyUI/custom nodes, but required model
+files were not present or linked under ComfyUI's model directories yet. Internal
+diagnostic usage can tolerate a manual `Prepare` step, but the user-facing
+`Translate` path must not require that.
+
+Mitigation added:
+
+- Before running full VoiceGate, the app checks required MelBand, VoxCPM, and
+  Qwen3-ASR model paths.
+- If any are missing, it runs `scripts/bootstrap_comfy.py --with-models`
+  synchronously and rechecks the paths.
+- If models still cannot be prepared, the app returns a clear preparation error
+  instead of a raw ComfyUI prompt-validation failure.
+
 ## Remaining Work
 
 Next recommended steps:
@@ -862,5 +888,6 @@ Next recommended steps:
    - SRT split and merge
    - full short-audio VoiceGate workflow on the organization ZeroGPU Space after
      quota recovers
-2. Polish the first Gradio user interface and add downloadable subtitle outputs.
+2. Polish the first Gradio user interface and validate the automatic model
+   preparation path after Space rebuilds/hardware changes.
 3. Reduce runtime dependency installation and model reload overhead.