@danhachuel/thunderbolt 0.2.18 → 0.2.20

package/hermes_ui/domain.py

@@ -34,8 +34,13 @@ def create_channel(name: str, url: str = "", metadata: dict[str, Any] | None = N
         "last_youtube_sync": None,
         "language": "Português",
         "blueprint_id": "",
+        "default_blueprint_id": "",
         "style_wide": "pexels",
         "voice": "",
+        "default_voice": "",
+        "delegated_session_id": "",
+        "automation_on": False,
+        "automation_time": "00:00",
         "active": True,
         "daily_limit": 1,
         "backlog_total": 0,
@@ -61,6 +66,17 @@ def update_channel(channel_id: str, updates: dict[str, Any]) -> dict[str, Any] |
     return None
 
 
+def delete_channel(channel_id: str) -> dict[str, Any] | None:
+    """Remove apenas o cadastro do canal, preservando tarefas e artefactos."""
+    channels = read_json("channels.json", [])
+    remaining = [channel for channel in channels if channel.get("id") != channel_id]
+    if len(remaining) == len(channels):
+        return None
+    removed = next(channel for channel in channels if channel.get("id") == channel_id)
+    write_json("channels.json", remaining)
+    return removed
+
+
 def create_batch(mode: str, channel_ids: list[str], topic: str, quantity: int, options: dict[str, Any]) -> dict[str, Any]:
     batch = {
         "id": make_id("batch"),
@@ -97,6 +113,15 @@ def create_tasks_for_batch(batch: dict[str, Any]) -> list[dict[str, Any]]:
                 "language": batch["options"].get("language", channel.get("language", "Português")),
                 "format": batch["options"].get("format", "wide"),
                 "style_wide": batch["options"].get("style_wide", channel.get("style_wide", "pexels")),
+                "style_ia": batch["options"].get("style_ia", ""),
+                "music_mode": batch["options"].get("music_mode", False),
+                "music_path": batch["options"].get("music_path", ""),
+                "music_source": batch["options"].get("music_source", ""),
+                "background_mode": batch["options"].get("background_mode", "stock"),
+                "blueprint_id": channel.get("default_blueprint_id") or channel.get("blueprint_id", ""),
+                "voice": channel.get("default_voice") or channel.get("voice", ""),
+                "automation_on": bool(channel.get("automation_on", False)),
+                "automation_time": channel.get("automation_time", "00:00"),
                 "stage": "script",
                 "state": "to_do",
                 "progress": 0,
@@ -115,6 +140,17 @@ def create_tasks_for_batch(batch: dict[str, Any]) -> list[dict[str, Any]]:
     return created
 
 
+def update_task(task_id: str, updates: dict[str, Any]) -> dict[str, Any] | None:
+    tasks = read_json("tasks.json", [])
+    for task in tasks:
+        if task.get("id") == task_id:
+            task.update(updates)
+            task["updated_at"] = now()
+            write_json("tasks.json", tasks)
+            return task
+    return None
+
+
 def transition_task(task_id: str, state: str | None = None, stage: str | None = None, error: str | None = None) -> dict[str, Any] | None:
     if state and state not in VALID_STATES:
         raise ValueError(f"Estado inválido: {state}")

package/hermes_ui/mcp.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import requests
+
+from . import storage
+
+
+SKILL_FILENAME = "moneyprinterturbo-video.md"
+
+MCP_DEFAULTS: list[dict[str, Any]] = [
+    {
+        "id": "short-video-maker",
+        "name": "Short Video Maker",
+        "repository": "https://github.com/gyoridavid/short-video-maker",
+        "protocol": "MCP + REST",
+        "description": "Servidor externo para criação de vídeos curtos, com MCP e API REST.",
+        "port": 3123,
+        "active": False,
+        "endpoint_note": "Porta documentada pelo projecto: 3123.",
+    },
+    {
+        "id": "autovio",
+        "name": "AutoVio",
+        "repository": "https://github.com/Auto-Vio/autovio",
+        "protocol": "MCP + REST",
+        "description": "Pipeline externo de vídeo com API REST e servidor MCP separado.",
+        "port": 3001,
+        "active": False,
+        "endpoint_note": "Porta padrão da API backend documentada pelo projecto: 3001.",
+    },
+    {
+        "id": "openmontage",
+        "name": "OpenMontage",
+        "repository": "https://github.com/calesthio/OpenMontage",
+        "protocol": "Agente local",
+        "description": "Sistema externo de produção agentic de vídeo; o README não documenta um servidor MCP/HTTP padrão.",
+        "port": 8000,
+        "active": False,
+        "endpoint_note": "Porta editável de referência; o projecto não documenta uma porta local padrão.",
+    },
+    {
+        "id": "opencut",
+        "name": "OpenCut",
+        "repository": "https://github.com/opencut-app/opencut",
+        "protocol": "API em desenvolvimento",
+        "description": "Editor externo; o README actual indica API/MCP em desenvolvimento e documenta um servidor API local.",
+        "port": 8787,
+        "active": False,
+        "endpoint_note": "Porta padrão da API documentada pelo projecto: 8787; frontend usa 5173.",
+    },
+]
+
+
+def _merge_defaults(saved: Any) -> list[dict[str, Any]]:
+    saved_by_id = {
+        str(item.get("id")): item
+        for item in (saved if isinstance(saved, list) else [])
+        if isinstance(item, dict) and item.get("id")
+    }
+    merged: list[dict[str, Any]] = []
+    for default in MCP_DEFAULTS:
+        item = {**default, **saved_by_id.get(default["id"], {})}
+        try:
+            item["port"] = max(1, min(65535, int(item.get("port", default["port"]))))
+        except (TypeError, ValueError):
+            item["port"] = default["port"]
+        item["active"] = bool(item.get("active", False))
+        merged.append(item)
+    return merged
+
+
+def load_integrations() -> list[dict[str, Any]]:
+    return _merge_defaults(storage.read_json("mcp_integrations.json", MCP_DEFAULTS))
+
+
+def save_integrations(integrations: list[dict[str, Any]]) -> None:
+    cleaned: list[dict[str, Any]] = []
+    allowed = {item["id"] for item in MCP_DEFAULTS}
+    for item in integrations:
+        if not isinstance(item, dict) or item.get("id") not in allowed:
+            continue
+        copy = dict(item)
+        try:
+            copy["port"] = max(1, min(65535, int(copy.get("port", 1))))
+        except (TypeError, ValueError):
+            continue
+        copy["active"] = bool(copy.get("active", False))
+        cleaned.append(copy)
+    storage.write_json("mcp_integrations.json", _merge_defaults(cleaned))
+
+
+def update_integration(integration_id: str, **updates: Any) -> list[dict[str, Any]]:
+    integrations = load_integrations()
+    for item in integrations:
+        if item.get("id") == integration_id:
+            item.update(updates)
+            break
+    save_integrations(integrations)
+    return load_integrations()
+
+
+def detect_local_service(integration: dict[str, Any], timeout: float = 0.35) -> dict[str, Any]:
+    """Detecta apenas um serviço local já iniciado; nunca inicia ou instala processos."""
+    port = integration.get("port")
+    try:
+        port = int(port)
+    except (TypeError, ValueError):
+        return {"available": False, "message": "Porta inválida."}
+    try:
+        response = requests.get(f"http://127.0.0.1:{port}/", timeout=timeout)
+        return {
+            "available": True,
+            "message": f"Serviço respondeu em localhost:{port} (HTTP {response.status_code}).",
+        }
+    except requests.RequestException:
+        return {"available": False, "message": f"Nenhum serviço detectado em localhost:{port}."}
+
+
+def skill_source_path() -> Path:
+    return Path(__file__).resolve().parents[1] / "seed" / "skills" / SKILL_FILENAME
+
+
+def skill_destination_path() -> Path:
+    return storage.STORAGE / "skills" / SKILL_FILENAME
+
+
+def install_skill_locally(*, overwrite: bool = True) -> Path:
+    source = skill_source_path()
+    if not source.exists():
+        raise FileNotFoundError("A skill MoneyPrinterTurbo não está disponível no pacote local.")
+    destination = skill_destination_path()
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    if overwrite or not destination.exists():
+        destination.write_bytes(source.read_bytes())
+    return destination
+
+
+def read_packaged_skill() -> bytes:
+    source = skill_source_path()
+    if not source.exists():
+        raise FileNotFoundError("A skill MoneyPrinterTurbo não está disponível no pacote local.")
+    return source.read_bytes()

package/hermes_ui/music.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any
+
+import requests
+
+from . import storage
+
+MUSIC_EXTENSIONS = {".mp3", ".wav", ".m4a", ".aac", ".flac", ".ogg"}
+
+
+def music_directory() -> Path:
+    directory = storage.STORAGE / "music"
+    directory.mkdir(parents=True, exist_ok=True)
+    return directory
+
+
+def list_music_files() -> list[Path]:
+    return sorted((path for path in music_directory().iterdir() if path.is_file() and path.suffix.lower() in MUSIC_EXTENSIONS), key=lambda path: path.stat().st_mtime, reverse=True)
+
+
+def safe_music_name(name: str) -> str:
+    stem = re.sub(r"[^\w\-. ]+", "_", Path(name).stem, flags=re.UNICODE).strip() or "music"
+    suffix = Path(name).suffix.lower()
+    if suffix not in MUSIC_EXTENSIONS:
+        suffix = ".mp3"
+    return f"{stem}{suffix}"
+
+
+def store_music_file(name: str, content: bytes) -> Path:
+    if not content:
+        raise ValueError("O ficheiro de música está vazio.")
+    target = music_directory() / safe_music_name(name)
+    target.write_bytes(content)
+    return target
+
+
+def materialize_suno_audio(data: dict[str, Any], title: str = "suno-generated.mp3") -> Path | None:
+    candidates: list[str] = []
+    for key in ("audio_url", "audioUrl", "download_url", "downloadUrl", "url"):
+        value = data.get(key) if isinstance(data, dict) else None
+        if isinstance(value, str) and value.startswith("http"):
+            candidates.append(value)
+    clips = data.get("clips") if isinstance(data, dict) else None
+    if isinstance(clips, list):
+        for clip in clips:
+            if isinstance(clip, dict):
+                for key in ("audio_url", "audioUrl", "download_url", "downloadUrl", "url"):
+                    value = clip.get(key)
+                    if isinstance(value, str) and value.startswith("http"):
+                        candidates.append(value)
+    if not candidates:
+        return None
+    response = requests.get(candidates[0], timeout=120)
+    response.raise_for_status()
+    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]:
+    """Request music from a configured Suno-compatible endpoint.
+
+    Suno-compatible deployments expose different endpoint paths; the UI therefore
+    requires an explicit base URL and never invents a public credential or endpoint.
+    """
+    api_key = str(settings.get("suno_api_key", "") or "").strip()
+    base_url = str(settings.get("suno_api_base_url", "") or "").strip().rstrip("/")
+    endpoint = str(settings.get("suno_api_endpoint", "/api/generate") or "/api/generate").strip()
+    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}
+    try:
+        response = requests.post(url, json=payload, headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}, timeout=30)
+        if response.status_code >= 400:
+            return {"ok": False, "message": f"Suno devolveu HTTP {response.status_code}: {response.text[:240]}", "data": {"status_code": response.status_code}}
+        body = response.json() if response.content else {}
+        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": {}}

package/hermes_ui/storage.py

@@ -21,6 +21,48 @@ DEFAULTS: dict[str, Any] = {
     "batches.json": [],
     "uploads.json": [],
     "metadata_edits.json": [],
+    "mcp_integrations.json": [
+        {
+            "id": "short-video-maker",
+            "name": "Short Video Maker",
+            "repository": "https://github.com/gyoridavid/short-video-maker",
+            "protocol": "MCP + REST",
+            "description": "Servidor externo para criação de vídeos curtos, com MCP e API REST.",
+            "port": 3123,
+            "active": False,
+            "endpoint_note": "Porta documentada pelo projecto: 3123.",
+        },
+        {
+            "id": "autovio",
+            "name": "AutoVio",
+            "repository": "https://github.com/Auto-Vio/autovio",
+            "protocol": "MCP + REST",
+            "description": "Pipeline externo de vídeo com API REST e servidor MCP separado.",
+            "port": 3001,
+            "active": False,
+            "endpoint_note": "Porta padrão da API backend documentada pelo projecto: 3001.",
+        },
+        {
+            "id": "openmontage",
+            "name": "OpenMontage",
+            "repository": "https://github.com/calesthio/OpenMontage",
+            "protocol": "Agente local",
+            "description": "Sistema externo de produção agentic de vídeo; não documenta um servidor MCP/HTTP padrão.",
+            "port": 8000,
+            "active": False,
+            "endpoint_note": "Porta editável de referência; o projecto não documenta uma porta local padrão.",
+        },
+        {
+            "id": "opencut",
+            "name": "OpenCut",
+            "repository": "https://github.com/opencut-app/opencut",
+            "protocol": "API em desenvolvimento",
+            "description": "Editor externo; a documentação actual indica API/MCP em desenvolvimento.",
+            "port": 8787,
+            "active": False,
+            "endpoint_note": "Porta padrão da API documentada pelo projecto: 8787; frontend usa 5173.",
+        },
+    ],
     "settings.json": {
         "port": 3030,
         "moneyprinter_path": "",
@@ -135,6 +177,19 @@ DEFAULTS: dict[str, Any] = {
         "tiktok_scopes": "user.info.basic,video.publish,video.upload",
         "tiktok_access_token": "",
         "tiktok_connection_status": "not_configured",
+        "suno_api_key": "",
+        "suno_api_base_url": "",
+        "suno_api_endpoint": "/api/generate",
+        "voice_preview_provider": "edge",
+        "voice_preview_rate": "+0%",
+        "direct_cookie_sid": "",
+        "direct_cookie_ssid": "",
+        "direct_cookie_hsid": "",
+        "direct_cookie_apisid": "",
+        "direct_cookie_sapisid": "",
+        "direct_session_info": "",
+        "direct_innertube_api_key": "",
+        "direct_chunk_size": 262144,
     },
 }
 
@@ -156,7 +211,7 @@ def seed_blueprints() -> None:
 
 
 def ensure_storage() -> None:
-    for path in [STATE, BLUEPRINTS / "canais", BLUEPRINTS / "nichos", BLUEPRINTS / "importados", BLUEPRINTS / "brandings", STORAGE / "brand", STORAGE / "scripts", STORAGE / "thumbnails", STORAGE / "videos", STORAGE / "artifacts", STORAGE / "metadata_cleaner", STORAGE / "metadata_cleaner" / "outputs"]:
+    for path in [STATE, BLUEPRINTS / "canais", BLUEPRINTS / "nichos", BLUEPRINTS / "importados", BLUEPRINTS / "brandings", STORAGE / "brand", STORAGE / "scripts", STORAGE / "thumbnails", STORAGE / "videos", STORAGE / "artifacts", STORAGE / "skills", STORAGE / "metadata_cleaner", STORAGE / "metadata_cleaner" / "outputs", STORAGE / "music", STORAGE / "voice_previews"]:
         path.mkdir(parents=True, exist_ok=True)
     seed_blueprints()
     for filename, default in DEFAULTS.items():

package/hermes_ui/voice_preview.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import asyncio
+import base64
+import inspect
+import json
+import uuid
+from pathlib import Path
+from typing import Any
+
+import requests
+
+from . import storage
+
+DEFAULT_SAMPLE = "Esta é uma amostra de voz do Thunderbolt. O resultado é apenas um teste e não altera nenhum vídeo ou tarefa da pipeline."
+
+
+def preview_directory() -> Path:
+    directory = storage.STORAGE / "voice_previews"
+    directory.mkdir(parents=True, exist_ok=True)
+    return directory
+
+
+def _edge_voice_name(value: str) -> str:
+    return str(value or "en-US-AriaNeural-Female").split("-Female", 1)[0].split("-Male", 1)[0]
+
+
+async def _save_edge_async(text: str, voice: str, output: Path, rate: str) -> None:
+    import edge_tts
+
+    kwargs: dict[str, Any] = {"rate": rate}
+    if "boundary" in inspect.signature(edge_tts.Communicate).parameters:
+        kwargs["boundary"] = "WordBoundary"
+    communicate = edge_tts.Communicate(text, _edge_voice_name(voice), **kwargs)
+    if hasattr(communicate, "save"):
+        result = communicate.save(str(output))
+        if inspect.isawaitable(result):
+            await result
+        return
+    raise RuntimeError("A versão instalada de edge-tts não possui save().")
+
+
+def _save_edge(text: str, voice: str, output: Path, rate: str) -> None:
+    asyncio.run(_save_edge_async(text, voice, output, rate))
+
+
+def _save_azure_speech(text: str, voice: str, output: Path, settings: dict[str, Any], rate: str) -> None:
+    key = str(settings.get("azure_speech_key", "") or "").strip()
+    region = str(settings.get("azure_speech_region", "") or "").strip()
+    if not key or not region:
+        raise RuntimeError("Configure Azure Speech key e região antes de testar Azure Speech.")
+    endpoint = f"https://{region}.tts.speech.microsoft.com/cognitiveservices/v1"
+    ssml = f"<speak version='1.0' xml:lang='pt-BR'><voice name='{_edge_voice_name(voice)}'><prosody rate='{rate}'>{text}</prosody></voice></speak>"
+    response = requests.post(endpoint, data=ssml.encode("utf-8"), headers={"Ocp-Apim-Subscription-Key": key, "Content-Type": "application/ssml+xml", "X-Microsoft-OutputFormat": "audio-24khz-96kbitrate-mono-mp3"}, timeout=45)
+    response.raise_for_status()
+    output.write_bytes(response.content)
+
+
+def _save_openai_compatible(text: str, voice: str, output: Path, settings: dict[str, Any], provider: str) -> None:
+    if provider == "elevenlabs":
+        api_key = str(settings.get("elevenlabs_api_key", "") or "").strip()
+        base = "https://api.elevenlabs.io/v1/text-to-speech"
+        voice_id = voice.split("|", 1)[-1] if "|" in voice else voice
+        endpoint = f"{base}/{voice_id or '21m00Tcm4TlvDq8ikWAM'}"
+        headers = {"xi-api-key": api_key, "Content-Type": "application/json"}
+        payload = {"text": text, "model_id": settings.get("elevenlabs_model_id", "eleven_multilingual_v2")}
+    elif provider == "minimax":
+        api_key = str(settings.get("minimax_tts_api_key", "") or "").strip()
+        endpoint = str(settings.get("minimax_tts_base_url", "") or "").strip().rstrip("/")
+        endpoint = f"{endpoint}/v1/t2a_v2" if endpoint and not endpoint.endswith("/t2a_v2") else endpoint
+        headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+        payload = {"model": settings.get("minimax_tts_model_id", "speech-2.8-hd"), "text": text, "voice_setting": {"voice_id": voice or settings.get("minimax_tts_voice_id", "English_expressive_narrator"), "speed": 1, "vol": 1, "pitch": 0}}
+    else:
+        api_key = str(settings.get(f"{provider}_tts_api_key", "") or settings.get(f"{provider}_api_key", "") or "").strip()
+        endpoint = str(settings.get(f"{provider}_tts_base_url", "") or settings.get(f"{provider}_base_url", "") or "").strip().rstrip("/")
+        headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+        payload = {"model": settings.get(f"{provider}_model_id", settings.get(f"{provider}_model_name", "")), "input": text, "voice": voice}
+    if not api_key or not endpoint:
+        raise RuntimeError(f"Configure a API key e o endpoint de {provider} antes do teste.")
+    response = requests.post(endpoint, json=payload, headers=headers, timeout=60)
+    response.raise_for_status()
+    content_type = response.headers.get("content-type", "")
+    if "application/json" in content_type:
+        body = response.json()
+        audio = body.get("audio") or body.get("audio_base64") or body.get("data")
+        if isinstance(audio, dict):
+            audio = audio.get("audio") or audio.get("url")
+        if isinstance(audio, str) and audio.startswith("http"):
+            audio_response = requests.get(audio, timeout=60)
+            audio_response.raise_for_status()
+            output.write_bytes(audio_response.content)
+        elif isinstance(audio, str):
+            output.write_bytes(base64.b64decode(audio))
+        else:
+            raise RuntimeError("O provider devolveu JSON sem áudio reconhecível.")
+    else:
+        output.write_bytes(response.content)
+
+
+def synthesize_preview(text: str, provider: str, voice: str, settings: dict[str, Any], rate: str = "+0%") -> Path:
+    text = (text or "").strip()
+    if not text:
+        raise ValueError("Introduza um texto para testar a voz.")
+    if len(text) > 1000:
+        raise ValueError("O texto de teste deve ter no máximo 1000 caracteres.")
+    provider = provider.lower().strip()
+    extension = ".mp3"
+    output = preview_directory() / f"voice-preview-{uuid.uuid4().hex[:10]}{extension}"
+    if provider in {"edge", "azure_v1"}:
+        _save_edge(text, voice, output, rate)
+    elif provider == "azure_speech":
+        _save_azure_speech(text, voice, output, settings, rate)
+    elif provider in {"elevenlabs", "minimax", "siliconflow", "gemini", "chatterbox"}:
+        _save_openai_compatible(text, voice, output, settings, provider)
+    else:
+        raise ValueError(f"Provider de preview não suportado: {provider}")
+    if not output.exists() or output.stat().st_size == 0:
+        raise RuntimeError("O provider não gerou um ficheiro de áudio válido.")
+    return output