@danhachuel/thunderbolt 0.3.94 → 0.3.96

package/app/main.py

@@ -22,7 +22,7 @@ try:
 except (OSError, json.JSONDecodeError):
     APP_VERSION = ""
 
-from hermes_ui.domain import STAGES, create_batch, create_channel, create_tasks_for_batch, delete_channel, delete_task, pipeline_summary, set_channel_defaults, transition_task, update_channel, update_channel_video
+from hermes_ui.domain import STAGES, create_batch, create_channel, create_tasks_for_batch, delete_channel, delete_task, pipeline_summary, retry_task_with_current_settings, set_channel_defaults, transition_task, update_channel, update_channel_video
 from hermes_ui.drafts import list_drafts, save_draft
 from hermes_ui.automation_worker import load_worker_status
 from hermes_ui.pipeline_worker import load_pipeline_worker_status, recover_stale_tasks, STALE_TASK_SECONDS, WORKER_HEARTBEAT_TIMEOUT_SECONDS
@@ -41,7 +41,7 @@ from hermes_ui.mcp_server import server_status, start_server, stop_server
 from hermes_ui.material_sources import apply_material_source_cards_to_settings, ensure_material_source_cards, material_source_catalog, material_source_definition, new_material_card, normalize_material_card, selected_material_source
 from hermes_ui.llm_providers import LLM_CARDS_KEY, LLM_PROVIDER_CATALOG, apply_llm_cards_to_settings, ensure_llm_provider_cards, new_llm_card, normalize_llm_card, provider_definition, test_llm_provider_card, stamp_test_result
 from hermes_ui.media_providers import FULL_IA_VIDEO_PROVIDER_CODES, MEDIA_CARDS_KEY, MEDIA_IMAGE_ACTIVE_CARD_KEY, MEDIA_VIDEO_ACTIVE_CARD_KEY, apply_media_provider_cards_to_settings, ensure_media_provider_cards, media_cards_for_pool, media_provider_catalog, media_provider_definition, new_media_card, normalize_media_card
-from hermes_ui.music import list_music_files, materialize_suno_audio, request_suno_generation, store_music_file, store_voiceover_file
+from hermes_ui.music import create_music_task, list_music_files, list_music_tasks, materialize_suno_audio, request_suno_generation, run_music_task, store_music_file, store_voiceover_file, transition_music_task
 from hermes_ui.media_downloader import AUDIO_FORMATS, VIDEO_CONTAINERS, VIDEO_QUALITY_OPTIONS, MediaDownloadError, build_download_options, clear_media_download_history, dependency_status, download_media, list_media_downloads, media_download_file
 from hermes_ui.notifications import clear_notifications, list_notifications, mark_all_notifications_read, mark_notification_read, notification_event_catalog, notification_preferences, record_notification, reconcile_persisted_notifications, save_notification_preferences, unread_notification_count
 from hermes_ui.influencers import BACKEND_OPTIONS, DOCUMENT_EXTENSIONS, IMAGE_EXTENSIONS, backend_name, backend_status, get_repository, test_backend
@@ -2603,8 +2603,27 @@ def render_new_video(page_title: str = "Criação de Vídeos", prefix: str = "ne
 
 
 def render_music_creation():
-    """Expose the complete video-creation UI under the music-oriented navigation entry without changing the original page."""
-    render_new_video(page_title="Criação de Músicas", prefix="new_music")
+    """Create audio-only items for the independent Suno/Lyria Music Backlog."""
+    st.title("Criação de Músicas")
+    st.caption("Crie apenas áudio. Os pedidos desta página não criam vídeo, não usam o MoneyPrinterTurbo e não entram no Backlog Vídeos.")
+    settings = read_json("settings.json", {})
+    with st.form("create_music_task_form"):
+        provider_label = st.selectbox("Provider de geração musical", ["Suno AI", "Google Lyria"], key="music_task_provider")
+        title = st.text_input("Título da música", key="music_task_title")
+        prompt = st.text_area("Prompt musical", placeholder="Instrumental cinematográfico, calmo, sem voz...", key="music_task_prompt", height=150)
+        lyria_model = ""
+        if provider_label == "Google Lyria":
+            models = ["lyria-3-clip-preview", "lyria-3-pro-preview"]
+            configured = str(settings.get("lyria_model") or models[0])
+            lyria_model = st.selectbox("Modelo Lyria", models, index=models.index(configured) if configured in models else 0, key="music_task_lyria_model")
+        submitted = st.form_submit_button("Adicionar ao Music Backlog", type="primary", use_container_width=True)
+    if submitted:
+        try:
+            task = create_music_task(provider_label, prompt, title, lyria_model)
+            st.success(f"Música adicionada ao Music Backlog: {task['title']}")
+            st.rerun()
+        except ValueError as exc:
+            st.error(str(exc))
 
 
 def render_scripts():
@@ -3637,7 +3656,7 @@ def render_videos():
     st.caption("Acompanhamento dos vídeos criados, estados da pipeline e controlos de execução.")
     st.caption(f"Os vídeos são guardados em `{STORAGE / 'videos'}`.")
     _render_pipeline_progress_panel()
-    tasks = load_standard_video_tasks_for_catalog()
+    tasks = load_video_tasks_for_catalog()
     if not tasks:
         st.info("Nenhum vídeo criado.")
         return
@@ -3697,12 +3716,14 @@ def render_videos():
 
 
 def render_music_backlog() -> None:
-    """Render the music-only counterpart of Backlog Videos with the same controls."""
+    """Render the independent audio-only queue; it never reads the video pipeline."""
     st.subheader("Music Backlog")
-    st.caption("Acompanhamento das músicas criadas, estados da pipeline e controlos de execução.")
+    st.caption("Fila independente de geração de áudio por Suno AI ou Google Lyria. Não inclui tarefas, worker ou progresso de vídeo.")
     st.caption(f"As músicas são guardadas em `{STORAGE / 'music'}`.")
-    _render_pipeline_progress_panel()
-    tasks = load_music_tasks_for_catalog()
+    tasks = list_music_tasks()
+    active = [task for task in tasks if str(task.get("state") or "") == "doing"]
+    if active:
+        st.info(f"Geração musical em execução · {len(active)} tarefa(s) de áudio.")
     if not tasks:
         st.info("Nenhuma música criada.")
         return
@@ -3715,10 +3736,10 @@ def render_music_backlog() -> None:
         with st.container(border=True):
             cols = st.columns([2.2, 1, 1, 1.2, 1.8])
             with cols[0]:
-                st.write(f"**{task.get('title') or task.get('topic', 'Sem título')}**")
-                st.caption(f"Música: {task.get('music_source') or 'rota musical'}")
-                st.caption(f"{task.get('channel_name')} · {task.get('id')}")
-                music_path = str(task.get("music_path") or (task.get("artifacts") or {}).get("music") or "").strip()
+                st.write(f"**{task.get('title') or 'Música sem título'}**")
+                st.caption(f"Provider: {'Google Lyria' if str(task.get('provider') or '').casefold() == 'lyria' else 'Suno AI'}")
+                st.caption(str(task.get('id') or ''))
+                music_path = str(task.get("audio_path") or "").strip()
                 if music_path and Path(music_path).is_file():
                     music_file = Path(music_path)
                     st.success("Música pronta; pode continuar para o destino configurado.")
@@ -3735,22 +3756,29 @@ def render_music_backlog() -> None:
                 else:
                     st.caption("A música será disponibilizada quando a etapa de geração terminar.")
             with cols[1]:
-                st.caption("Formato")
-                st.write(_video_task_format(task))
+                st.caption("Tipo")
+                st.write("Áudio")
             with cols[2]:
-                st.write(_pipeline_stage_label(task))
+                st.write({"music_generation": "Geração musical", "completed": "Concluída", "failed": "Falha"}.get(str(task.get("stage") or ""), "Na fila"))
             with cols[3]:
-                _render_video_task_state(task)
+                state = str(task.get("state") or "unknown").strip().lower()
+                progress = _video_task_progress(task)
+                st.caption("Estado")
+                st.write(state or "—")
+                st.caption(VIDEO_TASK_STATE_LABELS.get(state, state.replace("_", " ").capitalize() or "Desconhecido"))
+                st.progress(progress, text=f"{progress}%")
+                if task.get("error"):
+                    st.error(str(task.get("error") or "")[:500])
             with cols[4]:
                 state = str(task.get("state") or "")
                 start_col, stop_col = st.columns(2)
                 with start_col:
                     if st.button("Start", key=f"music_backlog_start_{task['id']}", use_container_width=True, disabled=state not in {"to_do", "blocked", "failed"}):
-                        transition_task(task["id"], "doing")
+                        run_music_task(str(task["id"]), read_json("settings.json", {}))
                         st.rerun()
                 with stop_col:
                     if st.button("Stop", key=f"music_backlog_stop_{task['id']}", use_container_width=True, disabled=state != "doing"):
-                        transition_task(task["id"], "blocked")
+                        transition_music_task(str(task["id"]), "blocked")
                         st.rerun()
 
 
@@ -4026,7 +4054,7 @@ def render_automation():
 
     st.divider()
     st.subheader("Vídeos cadastrados")
-    st.caption("Start retoma as etapas já concluídas e só gera novamente o que ainda não estiver pronto. Apagar remove o card da fila após confirmação e preserva os artefactos locais.")
+    st.caption("Start retoma as etapas já concluídas e só gera novamente o que ainda não estiver pronto. Em tarefas falhadas ou bloqueadas, a nova tentativa lê as chaves, prioridades e configurações actualmente guardadas. Apagar remove o card da fila após confirmação e preserva os artefactos locais.")
     tasks = load_video_tasks_for_catalog()
     if not tasks:
         st.info("Ainda não existem vídeos cadastrados.")
@@ -4046,7 +4074,10 @@ def render_automation():
                 start_col, stop_col, delete_col = st.columns(3)
                 with start_col:
                     if st.button("Start", key=f"automation_start_{task['id']}", use_container_width=True, disabled=state not in {"to_do", "blocked", "failed"}):
-                        transition_task(task["id"], "doing")
+                        if state in {"failed", "blocked"}:
+                            retry_task_with_current_settings(task["id"])
+                        else:
+                            transition_task(task["id"], "doing")
                         st.rerun()
                 with stop_col:
                     if st.button("Stop", key=f"automation_stop_{task['id']}", use_container_width=True, disabled=state != "doing"):
@@ -6102,6 +6133,15 @@ def render_settings():
                             widget_key="api_test_voice_suno",
                         )
 
+                    with st.container(border=True):
+                        st.markdown("#### Google Lyria — geração musical")
+                        st.caption("Google Lyria gera apenas áudio através da API Gemini Interactions; não usa a pipeline de vídeo.")
+                        lyria_api_key = text_setting("Google Lyria API key", "lyria_api_key", secret=True, help_text="Chave da Gemini API com acesso ao modelo Lyria. O valor é guardado apenas localmente.")
+                        _render_credential_status(lyria_api_key)
+                        lyria_models = ["lyria-3-clip-preview", "lyria-3-pro-preview"]
+                        saved_lyria_model = str(settings.get("lyria_model") or lyria_models[0])
+                        lyria_model = st.selectbox("Modelo Google Lyria", lyria_models, index=lyria_models.index(saved_lyria_model) if saved_lyria_model in lyria_models else 0, key="settings_lyria_model")
+
                 with st.expander("Publicação através do Upload-Post", expanded=False):
                     upload_post_enabled = st.checkbox("Activar Upload-Post", bool(settings.get("upload_post_enabled", False)))
                     upload_post_api_key = text_setting("Upload-Post API key", "upload_post_api_key", secret=True)
@@ -6150,6 +6190,7 @@ def render_settings():
                         "elevenlabs_api_key": elevenlabs_api_key, "elevenlabs_model_id": elevenlabs_model_id,
                         "chatterbox_base_url": chatterbox_base_url, "chatterbox_api_key": chatterbox_api_key, "chatterbox_model_id": chatterbox_model_id,
                         "sonilo_api_key": sonilo_api_key, "sonilo_base_url": sonilo_base_url, "suno_api_key": suno_api_key, "suno_api_base_url": suno_api_base_url, "suno_api_endpoint": suno_api_endpoint,
+                        "lyria_api_key": lyria_api_key, "lyria_model": lyria_model,
                         "upload_post_enabled": upload_post_enabled, "upload_post_api_key": upload_post_api_key,
                         "upload_post_username": upload_post_username, "upload_post_platforms": upload_post_platforms,
                         "upload_post_auto_upload": upload_post_auto_upload,

package/hermes_ui/domain.py

@@ -328,6 +328,37 @@ def transition_task(task_id: str, state: str | None = None, stage: str | None =
     return None
 
 
+def retry_task_with_current_settings(task_id: str) -> dict[str, Any] | None:
+    """Queue a failed or blocked task without persisting API credentials or provider snapshots.
+
+    The pipeline reloads settings.json immediately before every execution, so a
+    retry always uses the currently saved API keys, active provider priorities,
+    and provider endpoints while retaining the task's completed artefacts.
+    """
+    tasks = read_json("tasks.json", [])
+    for task in tasks:
+        if task.get("id") != task_id:
+            continue
+        previous_state = str(task.get("state") or "")
+        if previous_state not in {"failed", "blocked"}:
+            raise ValueError("Apenas tarefas falhadas ou bloqueadas podem ser retomadas.")
+        try:
+            retry_count = int(task.get("retry_count") or 0)
+        except (TypeError, ValueError):
+            retry_count = 0
+        task["state"] = "to_do"
+        task["error"] = None
+        task["retry_count"] = retry_count + 1
+        task["retry_requested_at"] = now()
+        task["retry_config_source"] = "settings.json_at_execution"
+        for field in ("failure_api", "failure_provider", "failure_service", "failure_config_fields"):
+            task.pop(field, None)
+        task["updated_at"] = now()
+        write_json("tasks.json", tasks)
+        return task
+    return None
+
+
 def pipeline_summary() -> dict[str, Any]:
     tasks = read_json("tasks.json", [])
     channels = read_json("channels.json", [])

package/hermes_ui/music.py

@@ -2,6 +2,9 @@ from __future__ import annotations
 
 import json
 import re
+import base64
+import uuid
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
@@ -115,3 +118,137 @@ def request_suno_generation(settings: dict[str, Any], prompt: str, title: str =
         return {"ok": True, "message": "Pedido de música enviado ao endpoint Suno configurado.", "data": body if isinstance(body, dict) else {"response": body}}
     except (requests.RequestException, ValueError) as exc:
         return {"ok": False, "message": f"Não foi possível contactar o endpoint Suno configurado: {exc}", "data": {}}
+
+
+def list_music_tasks() -> list[dict[str, Any]]:
+    """Return only tasks created for the independent audio-generation queue."""
+    records = storage.read_json("music_tasks.json", [])
+    if not isinstance(records, list):
+        return []
+    return [dict(record) for record in records if isinstance(record, dict) and str(record.get("id") or "").strip()]
+
+
+def _save_music_tasks(tasks: list[dict[str, Any]]) -> None:
+    storage.write_json("music_tasks.json", tasks)
+
+
+def create_music_task(provider: str, prompt: str, title: str, model: str = "") -> dict[str, Any]:
+    """Enqueue one audio-only generation; no video task or video worker is used."""
+    cleaned_prompt = str(prompt or "").strip()
+    if not cleaned_prompt:
+        raise ValueError("Escreva um prompt musical antes de adicionar à fila.")
+    now = datetime.now(timezone.utc).isoformat(timespec="seconds")
+    task = {
+        "id": f"music_{uuid.uuid4().hex[:12]}",
+        "kind": "audio_generation",
+        "provider": "lyria" if str(provider).strip().casefold() == "google lyria" else "suno",
+        "model": str(model or "").strip(),
+        "title": str(title or "Música sem título").strip() or "Música sem título",
+        "prompt": cleaned_prompt,
+        "state": "to_do",
+        "stage": "music_generation",
+        "progress": 0,
+        "audio_path": "",
+        "error": "",
+        "created_at": now,
+        "updated_at": now,
+    }
+    tasks = list_music_tasks()
+    tasks.insert(0, task)
+    _save_music_tasks(tasks)
+    return task
+
+
+def _update_music_task(task_id: str, **changes: Any) -> dict[str, Any] | None:
+    tasks = list_music_tasks()
+    updated: dict[str, Any] | None = None
+    for task in tasks:
+        if str(task.get("id") or "") == str(task_id):
+            task.update(changes)
+            task["updated_at"] = datetime.now(timezone.utc).isoformat(timespec="seconds")
+            updated = dict(task)
+            break
+    if updated is not None:
+        _save_music_tasks(tasks)
+    return updated
+
+
+def transition_music_task(task_id: str, state: str) -> dict[str, Any] | None:
+    """Change only an independent audio queue state."""
+    if state not in {"to_do", "doing", "blocked", "done", "failed", "cancelled"}:
+        raise ValueError("Estado de música inválido.")
+    return _update_music_task(task_id, state=state)
+
+
+def _extract_lyria_audio(payload: dict[str, Any]) -> bytes:
+    """Extract a base64 audio block from Gemini Interactions without logging the payload."""
+    candidates: list[Any] = []
+    output_audio = payload.get("output_audio") if isinstance(payload, dict) else None
+    if isinstance(output_audio, dict):
+        candidates.append(output_audio.get("data"))
+    for step in payload.get("steps", []) if isinstance(payload, dict) else []:
+        if not isinstance(step, dict):
+            continue
+        content = step.get("content")
+        for block in content if isinstance(content, list) else []:
+            if isinstance(block, dict) and str(block.get("type") or "").casefold() == "audio":
+                candidates.append(block.get("data"))
+    for candidate in candidates:
+        if isinstance(candidate, str) and candidate.strip():
+            try:
+                decoded = base64.b64decode(candidate, validate=True)
+            except (ValueError, TypeError):
+                continue
+            if decoded:
+                return decoded
+    return b""
+
+
+def request_lyria_generation(settings: dict[str, Any], prompt: str, title: str = "", model: str = "") -> dict[str, Any]:
+    """Generate audio through Google Lyria's Interactions API without invoking video tooling."""
+    api_key = str(settings.get("lyria_api_key") or settings.get("gemini_api_key") or "").strip()
+    selected_model = str(model or settings.get("lyria_model") or "lyria-3-clip-preview").strip()
+    if not api_key:
+        return {"ok": False, "message": "Configure a Google Lyria API key em Configurações antes de solicitar uma música.", "data": {}}
+    try:
+        response = requests.post(
+            "https://generativelanguage.googleapis.com/v1beta/interactions",
+            headers={"x-goog-api-key": api_key, "Content-Type": "application/json"},
+            json={"model": selected_model, "input": str(prompt or "").strip()},
+            timeout=180,
+        )
+        if response.status_code >= 400:
+            return {"ok": False, "message": f"Google Lyria devolveu HTTP {response.status_code}.", "data": {"status_code": response.status_code}}
+        body = response.json() if response.content else {}
+        audio = _extract_lyria_audio(body if isinstance(body, dict) else {})
+        if not audio:
+            return {"ok": False, "message": "Google Lyria não devolveu áudio na resposta.", "data": {}}
+        output = store_music_file(f"{title or 'lyria-generated'}.mp3", audio)
+        return {"ok": True, "message": "Música gerada por Google Lyria.", "data": {"audio_path": str(output), "model": selected_model}}
+    except (requests.RequestException, ValueError):
+        return {"ok": False, "message": "Não foi possível contactar Google Lyria.", "data": {}}
+
+
+def run_music_task(task_id: str, settings: dict[str, Any]) -> dict[str, Any] | None:
+    """Run exactly one queued audio generation and persist only its audio artefact."""
+    task = next((record for record in list_music_tasks() if str(record.get("id") or "") == str(task_id)), None)
+    if not task:
+        return None
+    _update_music_task(task_id, state="doing", stage="music_generation", progress=15, error="")
+    provider = str(task.get("provider") or "suno").casefold()
+    if provider == "lyria":
+        result = request_lyria_generation(settings, str(task.get("prompt") or ""), str(task.get("title") or ""), str(task.get("model") or ""))
+        audio_path = str((result.get("data") or {}).get("audio_path") or "")
+    else:
+        result = request_suno_generation(settings, str(task.get("prompt") or ""), str(task.get("title") or ""))
+        try:
+            output = materialize_suno_audio(result.get("data") or {}, str(task.get("title") or "suno-generated.mp3")) if result.get("ok") else None
+            audio_path = str(output or "")
+        except (OSError, requests.RequestException, ValueError):
+            audio_path = ""
+            result = {"ok": False, "message": "A música Suno foi solicitada, mas não foi possível guardar o áudio devolvido.", "data": {}}
+    if result.get("ok") and audio_path:
+        completed = _update_music_task(task_id, state="done", stage="completed", progress=100, audio_path=audio_path, error="")
+        record_notification("music_completed", f"Música concluída: {task.get('title') or 'Música'}", "Áudio guardado no Music Backlog.", metadata={"task_id": task_id, "provider": provider, "filename": Path(audio_path).name}, dedupe_key=f"music-task:{task_id}:{audio_path}")
+        return completed
+    return _update_music_task(task_id, state="failed", stage="failed", progress=100, error=str(result.get("message") or "A geração musical falhou.")[:500])

package/hermes_ui/storage.py

@@ -24,6 +24,7 @@ DEFAULTS: dict[str, Any] = {
         "channels.json": [],
         "channel_videos.json": [],
         "tasks.json": [],
+        "music_tasks.json": [],
     "queues.json": {"niche": [], "blueprint": [], "brand": [], "script": [], "title": [], "thumbnail": [], "video": [], "edit": [], "upload": []},
     "batches.json": [],
     "uploads.json": [],
@@ -300,6 +301,8 @@ DEFAULTS: dict[str, Any] = {
         "suno_api_key": "",
         "suno_api_base_url": "",
         "suno_api_endpoint": "/api/generate",
+        "lyria_api_key": "",
+        "lyria_model": "lyria-3-clip-preview",
         "jewelmusic_enabled": False,
         "jewelmusic_api_key": "",
         "jewelmusic_base_url": "https://api.jewelmusic.com",

package/package.json

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