@danhachuel/thunderbolt 0.3.96 → 0.3.98

package/app/main.py

@@ -4,6 +4,7 @@ import hashlib
 import json
 import mimetypes
 import re
+import time
 from contextlib import nullcontext
 from datetime import date, datetime, timezone
 import sys
@@ -42,6 +43,7 @@ from hermes_ui.material_sources import apply_material_source_cards_to_settings,
 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 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.music_generation import MUSIC_GENRES, MUSIC_VOCAL_OPTIONS, generate_music_fields
 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
@@ -49,6 +51,7 @@ from hermes_ui.logs import list_logs, logs_to_rows
 from hermes_ui.languages import LANGUAGE_CODES, VIDEO_LANGUAGE_CODES, LANGUAGE_FLAG_DATA_URIS, language_code, language_label, ui_language_menu_label, ui_text, video_language_label, video_language_options
 from hermes_ui.api_key_tests import test_apify_credentials, test_influencer_database, test_innertube_api_key, test_kaggle_credentials, test_material_source_credentials, test_media_provider_card, test_nano_banana_credentials, test_postiz_credentials, test_telegram_credentials, test_tiktok_credentials, test_upload_post_credentials, test_voice_provider
 from hermes_ui.tutorials import tutorial_body, tutorial_caption, tutorial_title
+from hermes_ui.update_manager import check_version, update_to_latest
 
 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
@@ -1269,6 +1272,48 @@ def render_channel_edit_form(channel: dict, youtube_account_ids: list[str], yout
 
 def render_dashboard():
     ui_language = current_ui_language()
+    update_area, version_area = st.columns([1.45, 4.55])
+    with update_area:
+        st.markdown(
+            """
+            <style>
+            div[data-testid="stButton"] button[kind="primary"] {
+                background: linear-gradient(135deg, #2563eb 0%, #7c3aed 100%);
+                color: #ffffff;
+                border: 1px solid #8b5cf6;
+                font-weight: 700;
+                box-shadow: 0 8px 20px rgba(79, 70, 229, 0.28);
+            }
+            div[data-testid="stButton"] button[kind="primary"]:hover {
+                border-color: #c4b5fd;
+                filter: brightness(1.08);
+            }
+            </style>
+            """,
+            unsafe_allow_html=True,
+        )
+        if st.button("Atualizar Versão", key="home_update_version", use_container_width=True, type="primary", icon=":material/system_update:"):
+            with st.spinner("A instalar a versão mais recente…"):
+                st.session_state["home_update_result"] = update_to_latest(APP_VERSION)
+    with version_area:
+        cache_key = "home_update_version_check"
+        checked_at_key = "home_update_version_checked_at"
+        if not st.session_state.get(cache_key) or time.monotonic() - float(st.session_state.get(checked_at_key, 0)) > 300:
+            st.session_state[cache_key] = check_version(APP_VERSION)
+            st.session_state[checked_at_key] = time.monotonic()
+        version_status = st.session_state[cache_key]
+        if version_status.update_available:
+            st.info(f"Nova versão disponível: {version_status.latest_version}. A versão actual é {APP_VERSION or 'desconhecida'}.")
+        elif version_status.error:
+            st.caption(f"Versão actual: {APP_VERSION or 'desconhecida'} · verificação de actualização indisponível.")
+        else:
+            st.caption(f"Versão actual: {APP_VERSION or 'desconhecida'} · já está actualizada ({version_status.latest_version}).")
+    update_result = st.session_state.get("home_update_result")
+    if update_result is not None:
+        if update_result.ok:
+            st.success(update_result.message)
+        else:
+            st.error(update_result.message)
     st.title("Thunderbolt")
     st.caption(ui_text("Interface local para operação e automação de conteúdo faceless", ui_language))
     summary = pipeline_summary()
@@ -2607,20 +2652,75 @@ def render_music_creation():
     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:
+    generated_fields = st.session_state.pop("music_task_generated_fields", None)
+    if isinstance(generated_fields, dict):
+        for state_key, generated_key in (
+            ("music_task_title", "title"),
+            ("music_task_language", "language"),
+            ("music_task_genre", "genre"),
+            ("music_task_vocal", "vocal"),
+            ("music_task_references", "references"),
+            ("music_task_prompt", "prompt"),
+        ):
+            st.session_state[state_key] = str(generated_fields.get(generated_key) or "")
+    provider_label = st.selectbox("Provider de geração musical", ["Suno AI", "Google Lyria"], key="music_task_provider")
+    theme = st.text_input("Tema / assunto principal", key="music_task_theme", placeholder="Ex.: uma viagem nocturna pela costa portuguesa")
+    title = st.text_input("Título da música", key="music_task_title")
+    language = st.selectbox(
+        "Idioma da letra/música",
+        list(LANGUAGE_CODES),
+        index=list(LANGUAGE_CODES).index(str(st.session_state.get("music_task_language") or "pt")) if str(st.session_state.get("music_task_language") or "pt") in LANGUAGE_CODES else list(LANGUAGE_CODES).index("pt"),
+        format_func=language_label,
+        key="music_task_language",
+    )
+    genre = st.selectbox("Género musical", list(MUSIC_GENRES), key="music_task_genre")
+    vocal = st.selectbox("Vocal", list(MUSIC_VOCAL_OPTIONS), key="music_task_vocal")
+    references = st.text_area(
+        "Referências culturais, paisagens, clima ou artistas similares (opcional)",
+        key="music_task_references",
+        placeholder="Ex.: pôr do sol mediterrânico, estrada molhada, nostalgia suave e arranjos acústicos contemporâneos",
+        height=90,
+    )
+    if st.button("Gerar campos musicais com IA", key="music_task_generate_fields", use_container_width=True, icon=":material/auto_awesome:"):
         try:
-            task = create_music_task(provider_label, prompt, title, lyria_model)
-            st.success(f"Música adicionada ao Music Backlog: {task['title']}")
+            with st.spinner("A criar título, letra e prompt musical originais…"):
+                generated = generate_music_fields(
+                    settings,
+                    theme=theme,
+                    language=language,
+                    genre=genre,
+                    vocal=vocal,
+                    references=references,
+                )
+            st.session_state["music_task_generated_fields"] = generated
+            st.rerun()
+        except CreativeGenerationError as exc:
+            st.error(str(exc))
+    prompt = st.text_area(
+        "Prompt musical",
+        placeholder="Use Gerar campos musicais com IA para criar letra e estilo completos, ou escreva um prompt próprio.",
+        key="music_task_prompt",
+        height=300,
+    )
+    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")
+    if st.button("Gerar Música", key="music_task_submit", type="primary", use_container_width=True, icon=":material/music_note:"):
+        try:
+            task = create_music_task(
+                provider_label,
+                prompt,
+                title,
+                lyria_model,
+                language=language,
+                genre=genre,
+                vocal=vocal,
+                references=references,
+                theme=theme,
+            )
+            st.success(f"Música criada no Music Backlog: {task['title']}")
             st.rerun()
         except ValueError as exc:
             st.error(str(exc))

package/hermes_ui/music.py

@@ -97,7 +97,14 @@ def materialize_suno_audio(data: dict[str, Any], title: str = "suno-generated.mp
     return store_music_file(title, response.content)
 
 
-def request_suno_generation(settings: dict[str, Any], prompt: str, title: str = "", duration_seconds: int = 120) -> dict[str, Any]:
+def request_suno_generation(
+    settings: dict[str, Any],
+    prompt: str,
+    title: str = "",
+    duration_seconds: int = 120,
+    *,
+    make_instrumental: bool = True,
+) -> dict[str, Any]:
     """Request music from a configured Suno-compatible endpoint.
 
     Suno-compatible deployments expose different endpoint paths; the UI therefore
@@ -109,7 +116,12 @@ def request_suno_generation(settings: dict[str, Any], prompt: str, title: str =
     if not api_key or not base_url:
         return {"ok": False, "message": "Configure Suno API Key e Suno API Base URL em Configurações antes de solicitar uma música.", "data": {}}
     url = endpoint if endpoint.startswith("http") else f"{base_url}/{endpoint.lstrip('/')}"
-    payload = {"prompt": prompt.strip(), "title": title.strip(), "duration": max(120, int(duration_seconds)), "make_instrumental": True}
+    payload = {
+        "prompt": prompt.strip(),
+        "title": title.strip(),
+        "duration": max(120, int(duration_seconds)),
+        "make_instrumental": bool(make_instrumental),
+    }
     try:
         response = requests.post(url, json=payload, headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}, timeout=30)
         if response.status_code >= 400:
@@ -132,7 +144,18 @@ 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]:
+def create_music_task(
+    provider: str,
+    prompt: str,
+    title: str,
+    model: str = "",
+    *,
+    language: str = "",
+    genre: str = "",
+    vocal: str = "",
+    references: str = "",
+    theme: 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:
@@ -145,6 +168,12 @@ def create_music_task(provider: str, prompt: str, title: str, model: str = "") -
         "model": str(model or "").strip(),
         "title": str(title or "Música sem título").strip() or "Música sem título",
         "prompt": cleaned_prompt,
+        "language": str(language or "").strip(),
+        "genre": str(genre or "").strip(),
+        "vocal": str(vocal or "").strip(),
+        "references": str(references or "").strip(),
+        "theme": str(theme or "").strip(),
+        "duration_seconds": 120,
         "state": "to_do",
         "stage": "music_generation",
         "progress": 0,
@@ -240,7 +269,13 @@ def run_music_task(task_id: str, settings: dict[str, Any]) -> dict[str, Any] | N
         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 ""))
+        result = request_suno_generation(
+            settings,
+            str(task.get("prompt") or ""),
+            str(task.get("title") or ""),
+            int(task.get("duration_seconds") or 120),
+            make_instrumental=not bool(str(task.get("vocal") or "").strip()),
+        )
         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 "")

package/hermes_ui/music_generation.py

@@ -0,0 +1,88 @@
+"""Structured, original music briefs generated through the configured LLM pool."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from .creative_generation import CreativeGenerationError, _chat_json
+from .languages import language_code
+
+
+MUSIC_GENRES = (
+    "Pop", "Rock", "Hip Hop", "EDM (Eletrônica)", "Techno", "Country", "Folk", "Indie", "K-pop", "Jazz",
+    "Reggae", "Classical", "Metal", "Punk", "Afrobeat (Nigéria)", "Ambient (Reino Unido)", "Anime (Japão)",
+    "Arabic Pop / Khaleeji (Mundo Árabe)", "Austropop (Áustria)", "Ballad (Internacional)", "Banda (México)",
+    "Blues (EUA)", "Bollywood / Indian (Índia)", "City Pop (Japão)", "Corridos Tumbados (México)", "C-pop (China)",
+    "Cumbia (Colômbia)", "Dangdut (Indonésia)", "Dansband (Suécia)", "Deutschrap (Alemanha)",
+    "Disco Polo (Polônia)", "Drum & Bass (Reino Unido)", "Entechno (Grécia)", "Fado (Portugal)",
+    "Flamenco (Espanha)", "Forró (Brasil)", "Funk (Brasil)", "Fusion (Internacional)", "Gamolan (Indonésia)",
+    "Gospel (EUA)", "Grime (Reino Unido)", "Hardstyle (Países Baixos)", "J-Pop (Japão)", "J-Rock (Japão)",
+    "K-Hip Hop (Coreia do Sul)", "Kizomba (Angola)", "Klapa (Croácia)", "Klezmer (Judeu / Europa Oriental)",
+    "Laïko (Grécia)", "Latin (América Latina)", "Mandopop (China / Taiwan)", "Māori (Nova Zelândia)", "MPB (Brasil)",
+    "Mundart (Dialect Pop) (Suíça)", "Pasifika (Pacífico)", "Pimba (Portugal)", "Pop Sueco (Suécia)", "R&B (EUA)",
+    "Rap Francês (França)", "Reggaeton (Porto Rico)", "Regional Mexicano (México)", "Samba / Pagode (Brasil)",
+    "Schlager (Alemanha)", "Sertanejo (Brasil)", "Trot (Coreia do Sul)", "Urbano / Trap (América Latina)",
+    "Variété (França)", "Vocaloid (Japão)",
+)
+MUSIC_VOCAL_OPTIONS = ("Masculino", "Feminina", "Coral")
+
+
+def generate_music_fields(
+    settings: dict[str, Any],
+    *,
+    theme: str,
+    language: str,
+    genre: str,
+    vocal: str,
+    references: str = "",
+) -> dict[str, str]:
+    """Generate original, ready-to-use music fields through the active LLM pool."""
+    cleaned_theme = str(theme or "").strip()
+    if not cleaned_theme:
+        raise CreativeGenerationError("Escreva o tema ou assunto principal antes de gerar os campos musicais com IA.")
+    selected_genre = str(genre or "").strip()
+    selected_vocal = str(vocal or "").strip()
+    selected_language = language_code(language)
+    system = (
+        "És um compositor e produtor musical. Cria uma canção inteiramente original, sem reproduzir letras, melodias, "
+        "frases distintivas ou a identidade de artistas existentes. As referências fornecidas servem apenas para atributos "
+        "de alto nível, como instrumentação, clima, contexto cultural e energia. Responde apenas com JSON válido contendo "
+        "as chaves title, language, genre, vocal, cultural_references e music_prompt. "
+        "music_prompt deve ser Markdown legível, pronto para uma ferramenta de geração musical, com exactamente estas secções: "
+        "# 1. Nome da Música, # 2. Idioma da Música, # 3. Letra / Lyrics, # 4. Estilo / Style Prompt. "
+        "A letra deve ser original, incluir [Intro], [Verse 1], [Pre-Chorus], [Chorus], [Verse 2], [Bridge], "
+        "[Instrumental Solo], [Final Chorus] e [Outro], ter uma estrutura que vise pelo menos dois minutos, e o estilo deve "
+        "informar subgénero, vocal, instrumentação, BPM, clima, produção e estrutura."
+    )
+    user = json.dumps(
+        {
+            "theme": cleaned_theme,
+            "selected_language_code": selected_language,
+            "selected_genre": selected_genre,
+            "selected_vocal": selected_vocal,
+            "cultural_landscape_weather_or_artist_references": str(references or "").strip(),
+            "available_genres": list(MUSIC_GENRES),
+            "available_vocals": list(MUSIC_VOCAL_OPTIONS),
+            "requirements": {
+                "minimum_target_duration_seconds": 120,
+                "preserve_selected_language_genre_and_vocal_when_present": True,
+                "output_original_content_only": True,
+            },
+        },
+        ensure_ascii=False,
+    )
+    result = _chat_json(settings, system, user)
+    music_prompt = str(result.get("music_prompt") or "").strip()
+    if not music_prompt:
+        raise CreativeGenerationError("O provider LLM não devolveu um prompt musical válido.")
+    generated_genre = str(result.get("genre") or selected_genre).strip()
+    generated_vocal = str(result.get("vocal") or selected_vocal).strip()
+    return {
+        "title": str(result.get("title") or cleaned_theme).strip()[:180],
+        "language": language_code(result.get("language"), default=selected_language),
+        "genre": generated_genre if generated_genre in MUSIC_GENRES else selected_genre,
+        "vocal": generated_vocal if generated_vocal in MUSIC_VOCAL_OPTIONS else selected_vocal,
+        "references": str(result.get("cultural_references") or references or "").strip()[:800],
+        "prompt": music_prompt[:16000],
+    }

package/hermes_ui/update_manager.py

@@ -0,0 +1,108 @@
+"""Verificação e actualização local da versão distribuída pelo NPM.
+
+O módulo não recebe nem manipula credenciais. A instalação só é iniciada após o
+clique explícito do utilizador na interface local.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from dataclasses import dataclass
+from typing import Any, Callable
+
+import requests
+
+
+PACKAGE_NAME = "@danhachuel/thunderbolt"
+REGISTRY_URL = "https://registry.npmjs.org/@danhachuel/thunderbolt/latest"
+UPDATE_TIMEOUT_SECONDS = 20 * 60
+
+
+@dataclass(frozen=True)
+class VersionCheck:
+    """Version information displayed on the local home page."""
+
+    current_version: str
+    latest_version: str = ""
+    error: str = ""
+
+    @property
+    def update_available(self) -> bool:
+        return bool(self.latest_version and self.current_version and self.latest_version != self.current_version)
+
+
+@dataclass(frozen=True)
+class UpdateResult:
+    """Sanitised result of an explicit local package update request."""
+
+    ok: bool
+    latest_version: str = ""
+    message: str = ""
+
+
+def latest_package_version(*, timeout: int = 8, get: Callable[..., Any] = requests.get) -> str:
+    """Return the latest public package version without sending local configuration."""
+    response = get(REGISTRY_URL, timeout=timeout)
+    response.raise_for_status()
+    payload = response.json()
+    version = str(payload.get("version") or "").strip() if isinstance(payload, dict) else ""
+    if not version:
+        raise ValueError("O registry NPM não devolveu uma versão válida.")
+    return version
+
+
+def check_version(current_version: str, *, timeout: int = 8, get: Callable[..., Any] = requests.get) -> VersionCheck:
+    """Fetch only the package metadata needed for the version badge."""
+    current = str(current_version or "").strip()
+    try:
+        return VersionCheck(current_version=current, latest_version=latest_package_version(timeout=timeout, get=get))
+    except (requests.RequestException, ValueError) as exc:
+        return VersionCheck(current_version=current, error=f"Não foi possível verificar actualizações agora ({type(exc).__name__}).")
+
+
+def update_command() -> list[str]:
+    """Build the same cross-platform install command documented for Thunderbolt."""
+    executable = "npx.cmd" if os.name == "nt" else "npx"
+    return [executable, "--yes", "--prefer-online", PACKAGE_NAME, "install"]
+
+
+def update_to_latest(
+    current_version: str,
+    *,
+    timeout: int = UPDATE_TIMEOUT_SECONDS,
+    get: Callable[..., Any] = requests.get,
+    run: Callable[..., Any] = subprocess.run,
+) -> UpdateResult:
+    """Install the latest package only after an explicit UI action.
+
+    The running local process keeps its current code until it is restarted. No
+    subprocess output is returned to the UI, preventing accidental display of
+    environment values from third-party installers.
+    """
+    status = check_version(current_version, get=get)
+    if status.error:
+        return UpdateResult(False, message=status.error)
+    if not status.update_available:
+        return UpdateResult(True, latest_version=status.latest_version, message="O Thunderbolt já está na versão mais recente.")
+    try:
+        completed = run(
+            update_command(),
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            timeout=timeout,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return UpdateResult(False, latest_version=status.latest_version, message=f"Não foi possível concluir a actualização ({type(exc).__name__}).")
+    if int(getattr(completed, "returncode", 1)) != 0:
+        return UpdateResult(False, latest_version=status.latest_version, message="A actualização não foi concluída. Feche processos Thunderbolt em execução e tente novamente.")
+    return UpdateResult(
+        True,
+        latest_version=status.latest_version,
+        message=(
+            f"A versão {status.latest_version} foi instalada. Reinicie o Thunderbolt para abrir a versão nova; "
+            "os dados e configurações locais foram preservados."
+        ),
+    )

package/package.json

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