feat: tui backend server progress and generate script progress

1 files changed, 178 insertions, 62 deletions

diff --git a/app/ui/hub.py b/app/ui/hub.py
index 77d0796..95ac06a 100644
--- a/app/ui/hub.py
+++ b/app/ui/hub.py
@@ -12,10 +12,13 @@ Esc on the main menu quits the hub ('q' mirrors Esc on every screen).
 Esc inside a sub-menu falls back to the main menu.
 """
 
+import contextlib
+import io
 import json
 import re
 import shutil
 import urllib.parse
+from datetime import datetime
 from pathlib import Path
 from typing import Callable, Optional, Tuple
 
@@ -31,9 +34,15 @@ from backends import (
 )
 from backends import audiocpp as audiocpp_backend
 from backends import faster as faster_backend
+from backends import probe as backend_probe
 from backends import qwen as qwen_backend
 from converter import config
-from converter.converter import AUDIO_FORMATS
+from converter.converter import (
+    AUDIO_FORMATS,
+    AudiobookConverter,
+    LOGS_FOLDER,
+    voice_mode_for,
+)
 from converter.tts import (
     AUDIOCPP_FAMILY_QWEN3_TTS,
     BACKEND_AUDIOCPP,
@@ -41,7 +50,7 @@ from converter.tts import (
     BACKEND_QWEN,
     normalize_language,
 )
-from ui import tui
+from ui import runview, tui
 
 _GO_BACK = object()
 
@@ -70,7 +79,7 @@ def run() -> int:
             if info is not None and command[2] < len(info.configure_actions):
                 info.configure_actions[command[2]].run()
         elif kind == "convert":
-            _run_conversion(command[1], command[2])
+            _dispatch_conversion(command[1], command[2])
         elif kind == "server":
             _run_server_action(command[1], command[2])
 
@@ -188,6 +197,8 @@ def _status_mark(status: Optional[BackendStatus]) -> Tuple[str, str, str]:
             text += " (" + ", ".join(status.running_models) + ")"
         return (text, "ok", "body")
     if status is not None and status.installed:
+        if status.models_missing and not status.running:
+            return ("installed (models missing)", "warn", "body")
         return ("installed", "warn", "body")
     return ("unavailable", "err", "dim")
 
@@ -287,9 +298,50 @@ def _convert_menu(stdscr, statuses) -> Optional[tuple]:
     if cmd is None:
         return None
     _add_autostart(cmd, statuses)
+    if not _preflight(stdscr, cmd):
+        return None
     return cmd
 
 
+def _preflight(stdscr, cmd: tuple) -> bool:
+    """Run the overwrite checks in the TUI; stash the plan on the command.
+
+    Asks every "output exists — overwrite?" question now (tui.confirm
+    instead of the console input()) so the run view itself is unattended,
+    and records the discovered books / accepted plan in the command's
+    kwargs (``book_files``/``planned``) for ``audiobook.convert``. Returns
+    False when nothing would be converted (a flash explains why), so the
+    user stays in the menu instead of entering an empty run.
+    """
+    _kind, backend, kwargs = cmd
+    voice_mode = voice_mode_for(backend, kwargs.get("voice"),
+                                kwargs.get("clone"))
+
+    def confirm(message: str, default: bool) -> bool:
+        return tui.confirm(stdscr, message, default=default,
+                           cancel_value=False)
+
+    with contextlib.redirect_stdout(io.StringIO()):
+        book_files, planned = AudiobookConverter.preflight_overwrites(
+            backend=backend, voice=kwargs.get("voice"),
+            voice_mode=voice_mode,
+            voice_clone_ref_audio=kwargs.get("clone"),
+            output_format=kwargs.get("output_format") or config.AUDIO_FORMAT,
+            instructions=kwargs.get("instructions"),
+            confirm=confirm)
+    if not book_files:
+        tui.flash(stdscr, "No books to convert. Add a .txt, .pdf or .epub "
+                  "file to the input folder first.")
+        return False
+    if not planned:
+        tui.flash(stdscr, "Nothing to convert — every existing output was "
+                  "kept.")
+        return False
+    kwargs["book_files"] = book_files
+    kwargs["planned"] = planned
+    return True
+
+
 def _gate_backend(field: dict, key: str) -> Callable:
     """A visible() that shows FIELD only when the Backend field is KEY.
 
@@ -429,6 +481,24 @@ def _audiocpp_fields(stdscr, api_url: Optional[str] = None) -> Optional[tuple]:
             # converter's default: unknown family means qwen3_tts.
             entry["family"] = AUDIOCPP_FAMILY_QWEN3_TTS
 
+    if local:
+        # Only offer entries whose model files are actually on disk: a
+        # server.json can reference a package that was never downloaded,
+        # and picking it would fail the whole run at model-load time.
+        missing = audiocpp_backend.missing_model_entries(server_json)
+        if missing:
+            missing_ids = {item["id"] for item in missing}
+            models = [entry for entry in models
+                      if entry.get("id") not in missing_ids]
+            if not models:
+                hints = audiocpp_backend.model_install_hints(checkout,
+                                                             missing)
+                message = hints[0] if hints \
+                    else "Download the models first."
+                tui.flash(stdscr, "No model files are downloaded for "
+                          f"audio.cpp. {message}")
+                return None
+
     local_voices = _list_voices(data.get("voice_dir")) \
         if data.get("voice_dir") else []
     voice_cache: dict = {}  # model id -> voices (local: shared list)
@@ -871,76 +941,122 @@ def _write_config(updates: dict) -> None:
     path.write_text(text, encoding="utf-8")
 
 
-def _run_conversion(backend: str, kwargs: dict) -> None:
-    """Run a conversion in the plain console (after the TUI returns).
+def _dispatch_conversion(backend: str, kwargs: dict) -> None:
+    """Run a conversion in the full-screen run view (its own curses session).
 
-    A remote conversion (``api_url`` in the kwargs) targets an externally-run
-    server, so no autostart is attempted and the managed instance's setup
-    state is irrelevant. Otherwise, when the convert menu recorded an
-    ``autostart`` server (the user opted to have the hub start it), spawn it
-    now and abort the conversion if it does not come up; a managed server
-    whose port is already occupied by a server this tool did not start is
-    left alone but warned about. After the conversion, offer to stop a
-    server we started.
+    ``_prepare_run_config`` turns the accepted form (plus the autostart
+    decision the convert menu recorded) into everything the run view needs;
+    the view then boots the server when required, runs the conversion with
+    progress events, and asks the cancel/stop-server questions itself. A
+    crash inside the view cancels the worker and returns to the menu
+    instead of taking the whole hub down.
     """
-    autostart = kwargs.pop("autostart", None)
-    api_url = kwargs.get("api_url")
-    if api_url:
-        print(f"[INFO] Converting against remote server at {api_url}")
-    else:
-        status = next((s for s in detect_all() if s.key == backend), None)
-        if status is not None and not status.ready and not status.running:
-            print(f"[WARNING] {status.label} is not fully set up.")
-        if autostart:
-            spec = _find_spec(autostart)
-            if spec is None:
-                print(f"[WARNING] no server named '{autostart}'; continuing")
-            elif not servers.start(spec):
-                print("[ERROR] could not start the server; aborting conversion.")
-                if status is not None and status.launch_hint:
-                    print("Start it manually and run the conversion again:")
-                    print(f"  {status.launch_hint}")
-                return
-        elif status is not None and status.servers:
-            # The managed server's port may be held by a server we did not
-            # start (its pid file is absent); the conversion would silently
-            # talk to that server, so call it out.
-            spec = _select_spec(status, kwargs)
-            if spec is not None and common.server_running(spec.url) \
-                    and not servers.alive(spec.name):
-                print(f"[WARNING] A server this tool did not start is already "
-                      f"running at {spec.url}; the conversion will talk to it. "
-                      f"Stop it (or change the port) to use the managed "
-                      f"{status.label} instance.")
-            elif status.launch_hint:
-                print("[INFO] Make sure the server is running. Start it with:")
-                print(f"  {status.launch_hint}")
-    try:
-        audiobook.convert(backend=backend, **kwargs)
-    finally:
-        if autostart:
-            _maybe_stop_server(autostart)
+    import curses
+    run_config = _prepare_run_config(backend, kwargs)
+    if run_config is None:
+        return
+    holder: dict = {}
 
+    def main(stdscr) -> None:
+        view = runview.RunView(stdscr, run_config)
+        holder["view"] = view
+        view.run()
 
-def _maybe_stop_server(name: str) -> None:
-    """Ask (in the plain console) whether to stop a server we auto-started."""
     try:
-        ans = input(f"\n[?] Stop the '{name}' server now? [y/N] ").strip().lower()
-    except EOFError:
-        return
-    if ans in ("y", "yes"):
-        servers.stop(name)
+        curses.wrapper(main)
+    except tui.WizardCancelled:
+        pass
+    except KeyboardInterrupt:
+        pass
+    except Exception as exc:  # noqa: BLE001 - keep the hub alive
+        view = holder.get("view")
+        if view is not None:
+            view._cancel.set()
+            view._worker.join(timeout=30)
+        print(f"[ERROR] The run view failed: {exc}")
+    finally:
+        try:
+            curses.curs_set(1)  # restore the text cursor hidden by the TUI
+        except Exception:
+            pass
+
+
+def _prepare_run_config(backend: str, kwargs: dict
+                        ) -> Optional[runview.RunConfig]:
+    """Build the run view's config from the accepted conversion kwargs.
+
+    A remote conversion (``api_url``) targets an externally-run server, so
+    no autostart is attempted and the managed instance's setup state is
+    irrelevant. Otherwise, when the convert menu recorded an ``autostart``
+    server (the server was not running), the run view boots it first; a
+    managed server whose port is already occupied by a server this tool
+    did not start is left alone but flagged with a notice. Returns None
+    when the backend disappeared between the menu and the dispatch.
+    """
+    label = backend
+    info = get(backend)
+    if info is not None:
+        label = info.label
+    log_path = str(LOGS_FOLDER / f"audiobook_{datetime.now():%Y%m%d}.log")
+    autostart = kwargs.pop("autostart", None)
+    api_url = kwargs.get("api_url")
+
+    if api_url:
+        identity = _remote_identity(backend, kwargs)
+        return runview.RunConfig(
+            backend=backend, backend_label=f"{label} [remote]",
+            kwargs=kwargs, book_files=kwargs.get("book_files") or [],
+            planned=kwargs.get("planned") or [],
+            server_url=api_url, server_identity=identity,
+            log_path=log_path)
+
+    status = next((s for s in detect_all() if s.key == backend), None)
+    notice = ""
+    spec: Optional[ServerSpec] = None
+    if autostart:
+        spec = _find_spec(autostart)
+    elif status is not None:
+        spec = _select_spec(status, kwargs)
+        if spec is not None and common.server_running(spec.url) \
+                and not servers.alive(spec.name):
+            notice = (f"a server this tool did not start is running at "
+                      f"{spec.url} — the conversion will talk to it")
+    if autostart and spec is None:
+        # The recorded server vanished (backend reconfigured meanwhile):
+        # converting without it is still meaningful, so continue.
+        notice = (f"no server named '{autostart}' — starting it was skipped")
+    return runview.RunConfig(
+        backend=backend, backend_label=label, kwargs=kwargs,
+        book_files=kwargs.get("book_files") or [],
+        planned=kwargs.get("planned") or [],
+        server_name=spec.name if spec is not None else None,
+        server_url=spec.url if spec is not None else None,
+        server_identity=spec.identity if spec is not None else None,
+        autostart_spec=spec if autostart else None,
+        log_path=log_path, notice=notice)
+
+
+def _remote_identity(backend: str, kwargs: dict) -> Optional[str]:
+    """The probe identity of the remote server a conversion targets."""
+    if backend == BACKEND_AUDIOCPP:
+        return backend_probe.IDENTITY_AUDIOCPP
+    if backend == BACKEND_QWEN:
+        return backend_probe.IDENTITY_QWEN_CLONE if kwargs.get("clone") \
+            else backend_probe.IDENTITY_QWEN_CUSTOM
+    if backend == BACKEND_FASTER:
+        return backend_probe.IDENTITY_FASTER
+    return None
 
 
 def _add_autostart(cmd: tuple, statuses) -> None:
     """Auto-start the conversion's target server when it isn't running.
 
     Records the chosen server spec name as ``kwargs['autostart']`` for
-    ``_run_conversion`` to act on. The user already accepted the run on the
-    Generate! screen, so no start-server prompt is asked here — the server
-    is simply started. Mode-aware for qwen (custom vs clone). Remote
-    conversions (a ``api_url`` in the kwargs) never autostart: the server
-    is external to this tool.
+    ``_prepare_run_config`` to act on. The user already accepted the run on
+    the Generate! screen, so no start-server prompt is asked here — the
+    server is simply started. Mode-aware for qwen (custom vs clone).
+    Remote conversions (an ``api_url`` in the kwargs) never autostart: the
+    server is external to this tool.
     """
     _, key, kwargs = cmd
     if kwargs.get("api_url"):