@danhachuel/thunderbolt 0.4.75 → 0.4.77

package/app/main.py

@@ -69,6 +69,7 @@ from hermes_ui.update_manager import check_version, restart_current_process, upd
 from hermes_ui.script_documents import list_script_documents, read_script_document, save_script_document, script_storage_path
 from hermes_ui.script_generation import generate_script_document
 from hermes_ui.voice_preview import DEFAULT_SAMPLE, load_preview_file, synthesize_preview
+from hermes_ui.elevenlabs_voices import ElevenLabsVoicesError, fetch_personal_voices, personal_voice_options
 from hermes_ui.thumbnail_generation import ThumbnailGenerationError, generate_thumbnail_image
 from hermes_ui.thumbnails import (
     generate_thumbnail_for_task,
@@ -185,7 +186,7 @@ VIDEO_CONCATENATION_OPTIONS = ["Random Concatenation (Recommended)", "Sequential
 VIDEO_TRANSITION_OPTIONS = ["None", "Fade", "Dissolve"]
 VIDEO_ENCODER_OPTIONS = ["Default (Recommended)", "H.264", "H.265"]
 VOICEOVER_MODE_OPTIONS = ["Auto", "Upload", "None"]
-VOICEOVER_SERVICE_OPTIONS = ["Azure Speech SDK V2", "Azure TTS V1"]
+VOICEOVER_SERVICE_OPTIONS = ["Azure Speech SDK V2", "Azure TTS V1", "ElevenLabs"]
 VOICEOVER_VOLUME_OPTIONS = ["20%", "40%", "60%", "80%", "100%"]
 VOICEOVER_SPEED_OPTIONS = ["0.5x", "0.75x", "1.0x", "1.25x", "1.5x", "2.0x"]
 BACKGROUND_MUSIC_SOURCE_OPTIONS = ["Ficheiro existente", "Carregar ficheiro", "Criar via Suno API", "Random Background Music", "Sem música"]
@@ -928,6 +929,9 @@ def voice_catalog(current: str = "") -> list[str]:
         voices.extend(f"{item.get('name', '')}-{item.get('gender', '')}" for item in voice_data if item.get("name"))
     except (OSError, json.JSONDecodeError):
         pass
+    for voice_id in personal_voice_options(read_json("settings.json", {})):
+        if voice_id not in voices:
+            voices.append(voice_id)
     for candidate in (current, "en-US-AriaNeural-Female", "pt-BR-FranciscaNeural-Female", "pt-BR-AntonioNeural-Male"):
         if candidate and candidate not in voices:
             voices.append(candidate)
@@ -1091,6 +1095,8 @@ def render_video_generation_settings(
                     and str(configured_voice_settings.get("azure_speech_region") or "").strip()
                 )
                 voice_service_default = "Azure Speech SDK V2" if configured_azure_voice else "Azure TTS V1"
+                if str(st.session_state.get(f"{prefix}_voice", "")).strip() in personal_voice_options(configured_voice_settings):
+                    voice_service_default = "ElevenLabs"
                 voice_service_index = VOICEOVER_SERVICE_OPTIONS.index(voice_service_default)
                 settings["voiceover_service"] = st.selectbox(
                     "Voiceover Service",
@@ -1108,7 +1114,13 @@ def render_video_generation_settings(
                         st.session_state[channel_state_key] = channel_id
                 current_voice = str(st.session_state.get(f"{prefix}_voice", ""))
                 voice_options = voice_catalog(current_voice)
-                settings["voice"] = st.selectbox("Voice (match script language)", voice_options, format_func=lambda value: value or "Sem voz seleccionada", key=f"{prefix}_voice")
+                personal_options = personal_voice_options(configured_voice_settings)
+                settings["voice"] = st.selectbox(
+                    "Voice (match script language)",
+                    voice_options,
+                    format_func=lambda value: personal_options.get(value, value) if value else "Sem voz seleccionada",
+                    key=f"{prefix}_voice",
+                )
                 volume_speed_cols = st.columns(2)
                 with volume_speed_cols[0]:
                     settings["voiceover_volume"] = st.selectbox("Voiceover Volume", VOICEOVER_VOLUME_OPTIONS, index=VOICEOVER_VOLUME_OPTIONS.index("100%"), key=f"{prefix}_voiceover_volume")
@@ -3376,8 +3388,49 @@ def render_music_creation():
 
 
 def render_custom_music_voices() -> None:
-    """Reserved view for future reusable custom music-voice blueprints."""
+    """List and test personal ElevenLabs voices without exposing credentials."""
     st.title("Vozes Personalizadas")
+    st.caption("Vozes pessoais do ElevenLabs Voice Lab disponíveis para narração no Thunderbolt.")
+    settings = read_json("settings.json", {})
+    refresh_col, cache_col = st.columns([1, 2])
+    with refresh_col:
+        refresh = st.button("Actualizar vozes", type="primary", use_container_width=True, key="elevenlabs_refresh_voices")
+    try:
+        voices, metadata = fetch_personal_voices(settings, force=refresh)
+        if metadata.get("source") == "cache":
+            label = "cache local"
+            if metadata.get("stale"):
+                st.warning("A API não respondeu; a mostrar a última lista guardada localmente.")
+        else:
+            label = "API ElevenLabs"
+        with cache_col:
+            st.caption(f"Fonte: {label} · última actualização: {metadata.get('updated_at') or '—'}")
+    except ElevenLabsVoicesError as exc:
+        st.warning(str(exc))
+        st.info("As vozes padrão continuam disponíveis na criação de vídeos.")
+        return
+
+    if not voices:
+        st.info("Nenhuma voz pessoal foi encontrada nesta conta ElevenLabs.")
+        return
+    test_text = st.text_input("Texto curto para testar uma voz", value=DEFAULT_SAMPLE, key="elevenlabs_voice_test_text")
+    for voice in voices:
+        with st.container(border=True):
+            voice_cols = st.columns([2.2, 1.8, 1])
+            with voice_cols[0]:
+                st.markdown(f"**{voice.get('name', 'Sem nome')}**")
+                st.caption(f"ID: `{voice.get('voice_id', '')}`")
+            with voice_cols[1]:
+                labels = voice.get("labels") or {}
+                st.caption("Categoria: personal")
+                st.caption("Labels: " + (", ".join(f"{key}: {value}" for key, value in labels.items()) if labels else "não disponíveis"))
+            with voice_cols[2]:
+                if st.button("Testar voz", key=f"elevenlabs_test_voice_{voice['voice_id']}", use_container_width=True):
+                    try:
+                        preview = synthesize_preview(test_text, "elevenlabs", voice["voice_id"], settings)
+                        st.audio(str(preview), format="audio/mpeg")
+                    except (OSError, RuntimeError, ValueError) as exc:
+                        st.error(f"Não foi possível testar esta voz: {exc}")
 
 
 def render_scripts():
@@ -4371,6 +4424,22 @@ def _task_thumbnail_path(task: dict[str, Any]) -> Path | None:
     return None
 
 
+def _task_artifact_path(task: dict[str, Any], *names: str) -> Path | None:
+    """Resolve um artefacto local, incluindo caminhos relativos e legados."""
+    artifacts = task.get("artifacts") if isinstance(task.get("artifacts"), dict) else {}
+    for name in names:
+        raw = str(artifacts.get(name) or "").strip()
+        if not raw or raw.startswith(("http://", "https://")):
+            continue
+        candidates = [Path(raw)]
+        if not Path(raw).is_absolute():
+            candidates.extend([STORAGE / raw, STORAGE / "videos" / raw])
+        for candidate in candidates:
+            if candidate.is_file():
+                return candidate
+    return None
+
+
 def _is_music_task(task: dict[str, Any]) -> bool:
     """Identify music pipeline tasks without conflating them with ordinary video tasks."""
     return bool(task.get("music_mode")) or str(task.get("style_wide") or task.get("style") or "").strip().casefold() in {"music", "música"}
@@ -4921,15 +4990,41 @@ def render_automation():
         st.info("Ainda não existem vídeos cadastrados.")
     for task in tasks:
         with st.container(border=True):
-            task_cols = st.columns([2.25, 1.65, 1.15, 1.85])
+            task_cols = st.columns([2.25, 1.55, 1.05, 2.15], gap="small")
+            script_path = _task_artifact_path(task, "script")
+            video_path = _task_artifact_path(task, "video")
+            thumbnail_path = _task_thumbnail_path(task)
+            thumbnail_prompt_path = _task_artifact_path(task, "thumbnail_prompt_json")
+            thumbnail_prompt = str(task.get("thumbnail_prompt") or "").strip()
             with task_cols[0]:
-                thumbnail_path = _task_thumbnail_path(task)
                 if thumbnail_path:
-                    st.image(thumbnail_path, width=180, caption="Thumbnail")
+                    st.image(str(thumbnail_path), width=180, caption="Thumbnail")
                 else:
                     st.caption("Thumbnail ainda não pronta")
                 st.write(f"**{task.get('topic', 'Sem tópico')}**")
                 st.caption(f"{task.get('channel_name', 'Canal')} · {task.get('id', '')}")
+                thumbnail_download_col, prompt_download_col = st.columns(2, gap="small")
+                with thumbnail_download_col:
+                    st.download_button(
+                        "Baixar Thumbnail",
+                        data=thumbnail_path.read_bytes() if thumbnail_path else b"",
+                        file_name=thumbnail_path.name if thumbnail_path else "thumbnail.png",
+                        mime="image/png",
+                        key=f"automation_download_thumbnail_{task['id']}",
+                        use_container_width=True,
+                        disabled=thumbnail_path is None,
+                    )
+                with prompt_download_col:
+                    prompt_data = thumbnail_prompt_path.read_bytes() if thumbnail_prompt_path else thumbnail_prompt.encode("utf-8")
+                    st.download_button(
+                        "Baixar Thumbnail Prompt",
+                        data=prompt_data,
+                        file_name=thumbnail_prompt_path.name if thumbnail_prompt_path else "thumbnail-prompt.txt",
+                        mime="application/json" if thumbnail_prompt_path else "text/plain",
+                        key=f"automation_download_thumbnail_prompt_{task['id']}",
+                        use_container_width=True,
+                        disabled=thumbnail_prompt_path is None and not thumbnail_prompt,
+                    )
             with task_cols[1]:
                 _render_video_task_state(task)
             with task_cols[2]:
@@ -4949,6 +5044,27 @@ def render_automation():
                     if st.button("Stop", key=f"automation_stop_{task['id']}", use_container_width=True, disabled=state != "doing"):
                         stop_task_by_user(task["id"])
                         st.rerun()
+                script_download_col, video_download_col = st.columns(2, gap="small")
+                with script_download_col:
+                    st.download_button(
+                        "Baixar Roteiro",
+                        data=script_path.read_bytes() if script_path else b"",
+                        file_name=script_path.name if script_path else "roteiro.md",
+                        mime="text/markdown",
+                        key=f"automation_download_script_{task['id']}",
+                        use_container_width=True,
+                        disabled=script_path is None,
+                    )
+                with video_download_col:
+                    st.download_button(
+                        "Baixar Vídeo",
+                        data=video_path.read_bytes() if video_path else b"",
+                        file_name=video_path.name if video_path else "video.mp4",
+                        mime="video/mp4",
+                        key=f"automation_download_video_{task['id']}",
+                        use_container_width=True,
+                        disabled=video_path is None,
+                    )
                 with delete_col:
                     confirm_delete_key = f"automation_confirm_delete_{task['id']}"
                     if st.button("Apagar", key=f"automation_delete_{task['id']}", use_container_width=True, disabled=state == "doing"):

package/hermes_ui/elevenlabs_voices.py

@@ -0,0 +1,128 @@
+"""ElevenLabs personal voice catalogue with local, credential-safe caching."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+from typing import Any, Callable
+
+import requests
+
+from . import storage
+
+CACHE_FILENAME = "elevenlabs_voices.json"
+DEFAULT_CACHE_TTL_SECONDS = 6 * 60 * 60
+VOICES_ENDPOINT = "https://api.elevenlabs.io/v1/voices"
+
+
+class ElevenLabsVoicesError(RuntimeError):
+    """A safe, user-facing error raised while reading the ElevenLabs catalogue."""
+
+
+def cache_path() -> Path:
+    return storage.STATE / CACHE_FILENAME
+
+
+def _utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _normalise_voice(item: Any) -> dict[str, Any] | None:
+    if not isinstance(item, dict):
+        return None
+    voice_id = str(item.get("voice_id") or "").strip()
+    category = str(item.get("category") or "").strip().casefold()
+    name = str(item.get("name") or "").strip()
+    if not voice_id or not name or category != "personal":
+        return None
+    labels = item.get("labels") if isinstance(item.get("labels"), dict) else {}
+    samples = item.get("samples") if isinstance(item.get("samples"), list) else []
+    return {
+        "voice_id": voice_id,
+        "name": name,
+        "category": "personal",
+        "labels": {str(key): str(value) for key, value in labels.items()},
+        "samples": [sample for sample in samples if isinstance(sample, dict)],
+    }
+
+
+def normalise_voices(payload: Any) -> list[dict[str, Any]]:
+    items = payload.get("voices", []) if isinstance(payload, dict) else []
+    if not isinstance(items, list):
+        raise ElevenLabsVoicesError("A API ElevenLabs devolveu uma lista de vozes inválida.")
+    result = [_normalise_voice(item) for item in items]
+    return [item for item in result if item is not None]
+
+
+def _read_cache() -> dict[str, Any] | None:
+    payload = storage.read_json(CACHE_FILENAME, {})
+    return payload if isinstance(payload, dict) and isinstance(payload.get("voices"), list) else None
+
+
+def _cache_is_fresh(cache: dict[str, Any], ttl_seconds: int) -> bool:
+    try:
+        updated = datetime.fromisoformat(str(cache.get("updated_at")).replace("Z", "+00:00"))
+        return (_utc_now() - updated).total_seconds() < ttl_seconds
+    except (TypeError, ValueError, OverflowError):
+        return False
+
+
+def _save_cache(voices: list[dict[str, Any]], *, source: str) -> dict[str, Any]:
+    payload = {"updated_at": _utc_now().isoformat(), "source": source, "voices": voices}
+    storage.write_json(CACHE_FILENAME, payload)
+    return payload
+
+
+def fetch_personal_voices(
+    settings: dict[str, Any],
+    *,
+    force: bool = False,
+    ttl_seconds: int = DEFAULT_CACHE_TTL_SECONDS,
+    request_get: Callable[..., Any] = requests.get,
+) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+    """Return personal voices, using cache unless force is requested."""
+    cache = _read_cache()
+    if cache and not force and _cache_is_fresh(cache, ttl_seconds):
+        return list(cache["voices"]), {"source": "cache", "updated_at": cache.get("updated_at")}
+
+    api_key = str(settings.get("elevenlabs_api_key") or "").strip()
+    if not api_key:
+        if cache:
+            return list(cache["voices"]), {"source": "cache", "updated_at": cache.get("updated_at"), "stale": True}
+        raise ElevenLabsVoicesError("Configure a API Key do ElevenLabs em Configuração API antes de actualizar as vozes.")
+    try:
+        response = request_get(VOICES_ENDPOINT, headers={"xi-api-key": api_key}, timeout=30)
+        status = int(getattr(response, "status_code", 200))
+        if status == 401:
+            raise ElevenLabsVoicesError("A API Key do ElevenLabs foi recusada. Confirme a chave em Configuração API.")
+        if status == 429:
+            raise ElevenLabsVoicesError("O limite de pedidos do ElevenLabs foi atingido. Tente novamente mais tarde.")
+        response.raise_for_status()
+        voices = normalise_voices(response.json())
+        saved = _save_cache(voices, source="elevenlabs_api")
+        return voices, {"source": "api", "updated_at": saved["updated_at"]}
+    except ElevenLabsVoicesError:
+        if cache:
+            return list(cache["voices"]), {"source": "cache", "updated_at": cache.get("updated_at"), "stale": True}
+        raise
+    except requests.Timeout as exc:
+        if cache:
+            return list(cache["voices"]), {"source": "cache", "updated_at": cache.get("updated_at"), "stale": True}
+        raise ElevenLabsVoicesError("O ElevenLabs demorou demasiado tempo a responder. Tente novamente.") from exc
+    except (requests.RequestException, ValueError, json.JSONDecodeError) as exc:
+        if cache:
+            return list(cache["voices"]), {"source": "cache", "updated_at": cache.get("updated_at"), "stale": True}
+        raise ElevenLabsVoicesError("Não foi possível obter as vozes do ElevenLabs. Verifique a ligação e a API Key.") from exc
+
+
+def personal_voice_options(settings: dict[str, Any]) -> dict[str, str]:
+    """Return voice_id -> display label without contacting the remote API."""
+    cache = _read_cache()
+    if not cache:
+        return {}
+    return {
+        str(voice["voice_id"]): f"{voice.get('name', voice['voice_id'])} · ElevenLabs personal"
+        for voice in cache.get("voices", [])
+        if isinstance(voice, dict) and voice.get("voice_id")
+    }

package/hermes_ui/pipeline_worker.py

@@ -25,6 +25,7 @@ from hermes_ui.media_providers import FULL_IA_VIDEO_PROVIDER_CODES, media_cards_
 from hermes_ui.material_sources import material_api_keys, material_source_cards, selected_material_source
 from hermes_ui.thumbnail_generation import ThumbnailGenerationError, generate_thumbnail_image
 from hermes_ui.thumbnail_blueprints import thumbnail_blueprint_for_channel
+from hermes_ui.voice_preview import synthesize_preview
 
 PIPELINE_LOCK_FILENAME = "pipeline_worker.lock"
 PIPELINE_LOG_FILENAME = "pipeline_worker.json"
@@ -763,6 +764,8 @@ def _uses_azure_speech_sdk_v2(
     settings: dict[str, Any] | None = None,
 ) -> bool:
     service = str(generation_settings.get("voiceover_service") or "").strip().casefold()
+    if service in {"elevenlabs", "eleven labs"}:
+        return False
     if service in {
         "azure speech sdk v2",
         "azure speech",
@@ -913,6 +916,23 @@ def _run_video_helper_once(
             sync_moneyprinter_config(settings, str(configured_root))
         except OSError as exc:
             raise PipelineError(f"Não foi possível sincronizar a configuração do MoneyPrinterTurbo: {exc}") from exc
+    generation_settings = task.get("generation_settings") if isinstance(task.get("generation_settings"), dict) else {}
+    voiceover_mode = str(generation_settings.get("voiceover_mode") or "").strip().casefold()
+    voiceover_service = str(generation_settings.get("voiceover_service") or "").strip().casefold()
+    generated_elevenlabs_audio: Path | None = None
+    if voiceover_mode not in {"none", "upload"} and voiceover_service == "elevenlabs":
+        elevenlabs_voice = str(task.get("voice") or generation_settings.get("voice") or "").strip()
+        script_text = str(task.get("video_script") or generation_settings.get("video_script") or "").strip()
+        if not elevenlabs_voice:
+            raise PipelineError("Seleccione uma voz personalizada ElevenLabs antes de criar o vídeo.")
+        if not str(settings.get("elevenlabs_api_key") or "").strip():
+            raise PipelineError("ElevenLabs foi seleccionado, mas a API Key não está configurada.")
+        if not script_text:
+            raise PipelineError("ElevenLabs foi seleccionado, mas o roteiro ainda não está disponível.")
+        try:
+            generated_elevenlabs_audio = synthesize_preview(script_text, "elevenlabs", elevenlabs_voice, settings)
+        except (OSError, RuntimeError, ValueError) as exc:
+            raise PipelineError(f"Não foi possível gerar a narração ElevenLabs: {exc}") from exc
     env_values = {
         "MPT_LLM_PROVIDER": provider,
         "MPT_LLM_API_KEY": str(card.get("api_key") or "").strip(),
@@ -932,7 +952,6 @@ def _run_video_helper_once(
     if configured_root:
         command.extend(["--root", str(configured_root)])
     command.extend(["--subject", subject, "--"])
-    generation_settings = task.get("generation_settings") if isinstance(task.get("generation_settings"), dict) else {}
     if _uses_azure_speech_sdk_v2(generation_settings, settings) and str(generation_settings.get("voiceover_mode") or "").strip().casefold() not in {"none", "upload"}:
         missing_voice_config = [
             field for field, value in (
@@ -951,7 +970,7 @@ def _run_video_helper_once(
             })
             raise PipelineError(_failure_message(message, metadata), failure_metadata=metadata)
     command.extend(_moneyprinter_cli_args(task, route, settings=settings))
-    if str(generation_settings.get("voiceover_mode") or "").strip().casefold() == "upload":
+    if voiceover_mode == "upload":
         voiceover_file = Path(str(generation_settings.get("voiceover_file") or "").strip()).expanduser()
         if not str(voiceover_file) or not voiceover_file.is_file() or voiceover_file.stat().st_size <= 0:
             message = "O modo Upload foi seleccionado, mas não existe um ficheiro de narração válido. Carregue o áudio em Configurações de áudio."
@@ -959,6 +978,8 @@ def _run_video_helper_once(
             metadata.update({"failure_api": "Ficheiro local", "failure_provider": "local_storage", "failure_service": "Áudio de narração", "failure_config_fields": "voiceover_file"})
             raise PipelineError(_failure_message(message, metadata), failure_metadata=metadata)
         command.extend(["--custom-audio-file", str(voiceover_file.resolve())])
+    elif generated_elevenlabs_audio is not None:
+        command.extend(["--custom-audio-file", str(generated_elevenlabs_audio.resolve())])
     output_lines: list[str] = []
     line_queue: queue.Queue[str | None] = queue.Queue()
     started_at = time.monotonic()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/thunderbolt",
-  "version": "0.4.75",
+  "version": "0.4.77",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "license": "MIT",
   "main": "scripts/cli.mjs",