@danhachuel/thunderbolt 0.3.93 → 0.3.95

package/app/main.py

@@ -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():
@@ -3576,6 +3595,21 @@ def load_video_tasks_for_catalog() -> list[dict[str, Any]]:
     return [task for task in saved if isinstance(task, dict) and str(task.get("id") or "").strip()]
 
 
+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"}
+
+
+def load_music_tasks_for_catalog() -> list[dict[str, Any]]:
+    """Return persisted tasks that were explicitly created through a music route."""
+    return [task for task in load_video_tasks_for_catalog() if _is_music_task(task)]
+
+
+def load_standard_video_tasks_for_catalog() -> list[dict[str, Any]]:
+    """Keep video backlog free of tasks that belong to the dedicated music queue."""
+    return [task for task in load_video_tasks_for_catalog() if not _is_music_task(task)]
+
+
 def _video_task_format(task: dict[str, Any]) -> str:
     value = task.get("format") or task.get("style_wide") or task.get("style") or "wide"
     return str(value).strip() or "wide"
@@ -3681,6 +3715,73 @@ def render_videos():
                         st.rerun()
 
 
+def render_music_backlog() -> None:
+    """Render the independent audio-only queue; it never reads the video pipeline."""
+    st.subheader("Music Backlog")
+    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'}`.")
+    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
+    known_states = ["to_do", "doing", "blocked", "done", "failed", "cancelled"]
+    extra_states = sorted({str(task.get("state") or "unknown") for task in tasks if str(task.get("state") or "unknown") not in known_states})
+    state_filter = st.selectbox("Filtrar por estado", ["Todos", *known_states, *extra_states], key="music_backlog_state_filter")
+    for task in tasks:
+        if state_filter != "Todos" and task.get("state") != state_filter:
+            continue
+        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 '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.")
+                    st.download_button(
+                        "Descarregar música pronta",
+                        data=music_file.read_bytes(),
+                        file_name=music_file.name,
+                        mime="audio/mpeg",
+                        key=f"music_backlog_download_{task['id']}",
+                        use_container_width=True,
+                    )
+                elif music_path:
+                    st.caption(f"Música registada: {music_path}")
+                else:
+                    st.caption("A música será disponibilizada quando a etapa de geração terminar.")
+            with cols[1]:
+                st.caption("Tipo")
+                st.write("Áudio")
+            with cols[2]:
+                st.write({"music_generation": "Geração musical", "completed": "Concluída", "failed": "Falha"}.get(str(task.get("stage") or ""), "Na fila"))
+            with cols[3]:
+                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"}):
+                        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_music_task(str(task["id"]), "blocked")
+                        st.rerun()
+
+
 def _thumbnail_editor_context(record: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]:
     """Resolve the persisted task channel/Blueprint without requiring either one to remain registered."""
     channel_id = str(record.get("channel_id") or "").strip()
@@ -6029,6 +6130,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)
@@ -6077,6 +6187,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,
@@ -6745,6 +6856,7 @@ def main():
     ]
     music_items = [
         ("Criação de Músicas", ":material/music_note:", "Criação de Músicas"),
+        ("Music Backlog", ":material/queue_music:", "Music Backlog"),
         ("Upload Música", ":material/library_music:", "Upload Música"),
     ]
     models_ai_items = [
@@ -6867,6 +6979,7 @@ def main():
         "Criação de Vídeos": render_new_video,
         "Backlog Vídeos": render_videos,
         "Criação de Músicas": render_music_creation,
+        "Music Backlog": render_music_backlog,
         "Upload Música": render_music_upload,
         "Roteiros": render_scripts,
         "Thumbnails": render_thumbnails,

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.93",
+  "version": "0.3.95",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "license": "MIT",
   "main": "scripts/cli.mjs",