@danhachuel/thunderbolt 0.2.75 → 0.2.77

package/app/modules/niche_finder/apify.py

@@ -37,7 +37,7 @@ def _json_response(response: requests.Response, action: str) -> Any:
 def _headers(token: str) -> dict[str, str]:
     token = str(token or "").strip()
     if not token:
-        raise ApifyError("Configure o Apify API Token em Configurações Técnicas antes de iniciar.")
+        raise ApifyError("Configure o Apify API Token em Configuração API > API Keys > Serviços e modelos antes de iniciar.")
     return {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
 
 

package/hermes_ui/creative_generation.py

@@ -38,15 +38,15 @@ def _provider_config(settings: dict[str, Any]) -> tuple[str, str, str, str]:
         base_url = base_url or "http://127.0.0.1:11434/v1"
     if not base_url:
         raise CreativeGenerationError(
-            f"O provider LLM '{provider}' não tem Base URL configurada em Configurações Técnicas > API Keys."
+            f"O provider LLM '{provider}' não tem Base URL configurada em Configuração API > API Keys > Serviços e modelos."
         )
     if not model:
         raise CreativeGenerationError(
-            f"O provider LLM '{provider}' não tem modelo configurado em Configurações Técnicas > API Keys."
+            f"O provider LLM '{provider}' não tem modelo configurado em Configuração API > API Keys > Serviços e modelos."
         )
     if provider not in {"ollama", "litellm"} and not key:
         raise CreativeGenerationError(
-            f"Configure a API key do provider LLM '{provider}' em Configurações Técnicas > API Keys."
+            f"Configure a API key do provider LLM '{provider}' em Configuração API > API Keys > Serviços e modelos."
         )
     return provider, key, base_url.rstrip("/"), model
 

package/hermes_ui/material_sources.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+MATERIAL_SOURCE_CATALOG: tuple[dict[str, str], ...] = (
+    {"code": "pexels", "label": "Pexels", "description": "Banco de vídeos e imagens para materiais da pipeline.", "legacy_key": "pexels_api_keys"},
+    {"code": "pixabay", "label": "Pixabay", "description": "Banco de vídeos e imagens para materiais da pipeline.", "legacy_key": "pixabay_api_keys"},
+    {"code": "coverr", "label": "Coverr", "description": "Fonte de vídeos de stock com API própria.", "legacy_key": "coverr_api_keys"},
+    {"code": "wavespeed", "label": "WaveSpeed AI", "description": "Geração de clips por IA; requer um serviço configurado.", "legacy_key": "wavespeed_api_keys"},
+    {"code": "loomloom", "label": "LoomLoom", "description": "Fonte paga de materiais; requer confirmação no fluxo de criação.", "legacy_key": "loomloom_api_keys"},
+    {"code": "twelvelabs", "label": "TwelveLabs", "description": "Ranking e análise semântica opcional dos materiais.", "legacy_key": "twelvelabs_api_keys"},
+)
+
+
+def _as_key_list(value: Any) -> list[str]:
+    if isinstance(value, list):
+        values = value
+    else:
+        values = str(value or "").replace("\n", ",").split(",")
+    result: list[str] = []
+    seen: set[str] = set()
+    for item in values:
+        key = str(item or "").strip()
+        if key and key not in seen:
+            result.append(key)
+            seen.add(key)
+    return result
+
+
+def material_source_catalog() -> list[dict[str, str]]:
+    return [dict(item) for item in MATERIAL_SOURCE_CATALOG]
+
+
+def material_api_keys(settings: dict[str, Any], source: str) -> list[str]:
+    code = str(source or "").strip().lower()
+    saved = settings.get("material_api_keys", {})
+    if isinstance(saved, dict) and code in saved:
+        return _as_key_list(saved.get(code))
+    legacy_key = next((item["legacy_key"] for item in MATERIAL_SOURCE_CATALOG if item["code"] == code), f"{code}_api_keys")
+    return _as_key_list(settings.get(legacy_key, ""))
+
+
+def all_material_api_keys(settings: dict[str, Any]) -> dict[str, list[str]]:
+    return {item["code"]: material_api_keys(settings, item["code"]) for item in MATERIAL_SOURCE_CATALOG}
+
+
+def update_material_api_keys(settings: dict[str, Any], source: str, keys: list[str]) -> dict[str, Any]:
+    code = str(source or "").strip().lower()
+    if code not in {item["code"] for item in MATERIAL_SOURCE_CATALOG}:
+        raise ValueError("Fonte de materiais inválida.")
+    cleaned = _as_key_list(keys)
+    mapping = all_material_api_keys(settings)
+    mapping[code] = cleaned
+    settings["material_api_keys"] = mapping
+    source_entry = next(item for item in MATERIAL_SOURCE_CATALOG if item["code"] == code)
+    settings[source_entry["legacy_key"]] = cleaned
+    return settings
+
+
+def selected_material_source(settings: dict[str, Any]) -> str:
+    source = str(settings.get("video_source") or "pexels").strip().lower()
+    valid = {item["code"] for item in MATERIAL_SOURCE_CATALOG} | {"local"}
+    return source if source in valid else "pexels"

package/hermes_ui/notifications.py

@@ -36,6 +36,7 @@ EVENT_CATALOG: tuple[dict[str, str], ...] = (
     {"code": "upload_instagram_success", "category": "Upload", "label": "Upload Instagram concluído", "description": "Quando um vídeo for publicado num perfil Instagram."},
     {"code": "upload_facebook_pages_success", "category": "Upload", "label": "Upload Facebook Pages concluído", "description": "Quando um vídeo for publicado numa Facebook Page."},
     {"code": "upload_postiz_success", "category": "Upload", "label": "Upload Postiz concluído", "description": "Quando um vídeo for enviado e publicado através do Postiz."},
+    {"code": "upload_upload_post_success", "category": "Upload", "label": "Upload-Post concluído", "description": "Quando um vídeo for aceite pelo Upload-Post para publicação nas plataformas seleccionadas."},
     {"code": "mcp_operation_completed", "category": "Integrações", "label": "Operação MCP concluída", "description": "Quando uma operação mutável de integração MCP terminar com sucesso."},
 )
 EVENTS_BY_CODE = {item["code"]: item for item in EVENT_CATALOG}
@@ -249,6 +250,8 @@ def _upload_notifications() -> int:
         "facebook pages": "upload_facebook_pages_success",
         "facebook_pages": "upload_facebook_pages_success",
         "postiz": "upload_postiz_success",
+        "upload-post": "upload_upload_post_success",
+        "upload_post": "upload_upload_post_success",
         "youtube direct frontend": "upload_youtube_success",
     }
     for upload in uploads:

package/hermes_ui/storage.py

@@ -115,6 +115,7 @@ DEFAULTS: dict[str, Any] = {
             "upload_instagram_success": True,
             "upload_facebook_pages_success": True,
             "upload_postiz_success": True,
+            "upload_upload_post_success": True,
             "mcp_operation_completed": True,
         },
         "kaggle_username": "",
@@ -197,9 +198,12 @@ DEFAULTS: dict[str, Any] = {
         "endpoint": "",
         "proxy_http": "",
         "proxy_https": "",
+        "material_api_keys": {},
         "pexels_api_keys": "",
         "pixabay_api_keys": "",
         "coverr_api_keys": "",
+        "wavespeed_api_keys": "",
+        "loomloom_api_keys": "",
         "twelvelabs_api_keys": "",
         "sonilo_api_key": "",
         "subtitle_provider": "edge",

package/hermes_ui/thumbnail_generation.py

@@ -87,7 +87,7 @@ def generate_thumbnail_image(
 ) -> Path:
     api_key = str(settings.get("gemini_image_api_key") or "").strip()
     if not api_key:
-        raise ThumbnailGenerationError("Configure a API key Nano Banana em Configurações Técnicas > API Keys.")
+        raise ThumbnailGenerationError("Configure a API key Nano Banana em Configuração API > API Keys > Serviços e modelos.")
     clean_prompt = str(prompt or "").strip()
     if not clean_prompt:
         raise ThumbnailGenerationError("A thumbnail não tem um prompt de imagem para gerar.")

package/integrations/moneyprinter_config.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Any
 
+from hermes_ui.material_sources import all_material_api_keys, selected_material_source
+
 try:
     import toml
 except ImportError:  # pragma: no cover - installation fallback
@@ -112,9 +114,13 @@ def build_moneyprinter_config(settings: dict[str, Any], existing: dict[str, Any]
     for settings_key, config_key in app_map.items():
         if settings_key in settings:
             app[config_key] = settings[settings_key]
-    for key in ("pexels_api_keys", "pixabay_api_keys", "coverr_api_keys", "twelvelabs_api_keys"):
-        if key in settings:
-            app[key] = _list_value(settings[key])
+    # A UI can store the canonical mapping while older installations still
+    # expose one legacy field per source.  Export every supported source as a
+    # TOML array so MoneyPrinterTurbo can rotate keys without CSV parsing.
+    canonical_material_keys = all_material_api_keys(settings)
+    for source, keys in canonical_material_keys.items():
+        app[f"{source}_api_keys"] = _list_value(keys)
+    app["video_source"] = selected_material_source(settings)
     config["app"] = app
 
     whisper["model_size"] = settings.get("whisper_model_size", whisper.get("model_size", "large-v3"))

package/integrations/postiz.py

@@ -33,7 +33,7 @@ class PostizAdapter:
 
     def status(self) -> IntegrationResult:
         if not self.api_key:
-            return self._error("Postiz não configurado: adicione a API key em Configurações Técnicas.")
+            return self._error("Postiz não configurado: adicione a API key em Configuração API > API Keys > Serviços e modelos.")
         return IntegrationResult(True, f"Postiz configurado em {self.base_url}.", {"base_url": self.base_url, "mcp_url": self.mcp_url})
 
     def list_integrations(self) -> IntegrationResult:

package/integrations/upload_post.py

@@ -0,0 +1,152 @@
+"""Upload-Post API adapter for publishing local video artefacts."""
+
+from __future__ import annotations
+
+import mimetypes
+from pathlib import Path
+from typing import Any
+
+import requests
+
+from .platforms import IntegrationResult
+
+
+DEFAULT_UPLOAD_POST_BASE_URL = "https://api.upload-post.com/api"
+UPLOAD_POST_PLATFORM_OPTIONS = (
+    "tiktok",
+    "instagram",
+    "youtube",
+    "facebook",
+    "linkedin",
+    "x",
+    "threads",
+    "pinterest",
+    "reddit",
+    "bluesky",
+    "discord",
+    "telegram",
+)
+_PLATFORM_ALIASES = {
+    "facebook pages": "facebook",
+    "facebook_pages": "facebook",
+    "twitter": "x",
+    "x (twitter)": "x",
+}
+
+
+def normalize_upload_post_platforms(value: Any) -> list[str]:
+    """Return stable Upload-Post platform slugs without duplicates."""
+    values = value if isinstance(value, (list, tuple, set)) else str(value or "").replace("\n", ",").split(",")
+    result: list[str] = []
+    seen: set[str] = set()
+    supported = set(UPLOAD_POST_PLATFORM_OPTIONS)
+    for item in values:
+        platform = str(item or "").strip().lower()
+        platform = _PLATFORM_ALIASES.get(platform, platform)
+        if platform in supported and platform not in seen:
+            result.append(platform)
+            seen.add(platform)
+    return result
+
+
+class UploadPostAdapter:
+    """Small deterministic client for Upload-Post's ``POST /upload`` endpoint."""
+
+    def __init__(self, settings: dict[str, Any] | None = None):
+        self.settings = settings or {}
+        self.api_key = str(self.settings.get("upload_post_api_key") or "").strip()
+        self.enabled = bool(self.settings.get("upload_post_enabled", False))
+        self.username = str(self.settings.get("upload_post_username") or "").strip()
+        self.platforms = normalize_upload_post_platforms(self.settings.get("upload_post_platforms", ""))
+        self.base_url = str(self.settings.get("upload_post_base_url") or DEFAULT_UPLOAD_POST_BASE_URL).strip().rstrip("/")
+
+    def _headers(self) -> dict[str, str]:
+        return {"Authorization": f"Apikey {self.api_key}"}
+
+    def _error(self, message: str, data: dict[str, Any] | None = None) -> IntegrationResult:
+        return IntegrationResult(False, message, data or {})
+
+    def status(self) -> IntegrationResult:
+        if not self.enabled:
+            return self._error("Upload-Post está desactivado em Configuração API.")
+        if not self.api_key:
+            return self._error("Upload-Post não configurado: adicione a API key em Configuração API > API Keys > Serviços e modelos.")
+        if not self.username:
+            return self._error("Upload-Post não configurado: adicione o username/perfil em Configuração API.")
+        if not self.platforms:
+            return self._error("Upload-Post não configurado: indique pelo menos uma plataforma em Configuração API.")
+        return IntegrationResult(
+            True,
+            f"Upload-Post configurado para {self.username} ({', '.join(self.platforms)}).",
+            {"base_url": self.base_url, "username": self.username, "platforms": self.platforms},
+        )
+
+    def upload_video(
+        self,
+        video_path: str | Path,
+        *,
+        title: str,
+        description: str = "",
+        user: str | None = None,
+        platforms: list[str] | None = None,
+        async_upload: bool = False,
+    ) -> IntegrationResult:
+        """Upload a local video to one or more connected Upload-Post platforms."""
+        if not self.enabled:
+            return self._error("Upload-Post está desactivado em Configuração API.")
+        if not self.api_key:
+            return self._error("Upload-Post não configurado: adicione a API key em Configuração API.")
+        path = Path(video_path)
+        if not path.is_file():
+            return self._error(f"Vídeo não encontrado para o Upload-Post: {path}")
+        selected_user = str(user or self.username).strip()
+        selected_platforms = normalize_upload_post_platforms(platforms or self.platforms)
+        if not selected_user:
+            return self._error("Indique o username/perfil ligado ao Upload-Post antes de publicar.")
+        if not selected_platforms:
+            return self._error("Seleccione pelo menos uma plataforma do Upload-Post antes de publicar.")
+
+        form_data: list[tuple[str, str]] = [
+            ("user", selected_user),
+            *[("platform[]", platform) for platform in selected_platforms],
+            ("title", str(title or "Vídeo Thunderbolt").strip()[:500] or "Vídeo Thunderbolt"),
+            ("description", str(description or "").strip()),
+            ("async_upload", "true" if async_upload else "false"),
+        ]
+        content_type = mimetypes.guess_type(path.name)[0] or "video/mp4"
+        try:
+            with path.open("rb") as handle:
+                response = requests.post(
+                    f"{self.base_url}/upload",
+                    headers=self._headers(),
+                    data=form_data,
+                    files={"video": (path.name, handle, content_type)},
+                    timeout=240,
+                )
+        except requests.RequestException as exc:
+            return self._error(f"Não foi possível contactar o Upload-Post: {exc}", {"platforms": selected_platforms, "user": selected_user})
+        if response.status_code >= 400:
+            return self._error(
+                f"Upload-Post rejeitou o vídeo (HTTP {response.status_code}): {response.text[:500]}",
+                {"platforms": selected_platforms, "user": selected_user},
+            )
+        try:
+            payload: Any = response.json()
+        except ValueError:
+            return self._error("Upload-Post devolveu uma resposta que não é JSON.", {"response": response.text[:2000]})
+        payload_dict = payload if isinstance(payload, dict) else {"response": payload}
+        request_id = str(payload_dict.get("request_id") or payload_dict.get("requestId") or "").strip()
+        message = "Upload-Post aceitou o vídeo para publicação."
+        if request_id:
+            message += f" Request ID: {request_id}."
+        return IntegrationResult(
+            True,
+            message,
+            {
+                "payload": payload_dict,
+                "request_id": request_id,
+                "user": selected_user,
+                "platforms": selected_platforms,
+                "async_upload": bool(async_upload),
+            },
+        )

package/integrations/upload_routing.py

@@ -154,7 +154,7 @@ def upload_with_default_route(
 
     postiz = PostizAdapter(settings)
     if not bool(settings.get("postiz_enabled", False)):
-        postiz_result = IntegrationResult(False, "Postiz está desactivado em Configurações Técnicas.", {})
+        postiz_result = IntegrationResult(False, "Postiz está desactivado em Configuração API > API Keys > Serviços e modelos.", {})
         attempts.append(_attempt_record("Postiz", postiz_result, skipped=True))
     else:
         postiz_publisher = postiz_publisher or postiz.publish_video

package/package.json

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