@danhachuel/thunderbolt 0.2.13

package/hermes_ui/storage.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[1]
+STORAGE = Path(os.getenv("THUNDERBOLT_STORAGE_DIR") or ROOT / "storage")
+STATE = STORAGE / "state"
+BLUEPRINTS = STORAGE / "blueprints"
+SEED_BLUEPRINTS = ROOT / "seed" / "blueprints"
+
+DEFAULTS: dict[str, Any] = {
+    "channels.json": [],
+    "tasks.json": [],
+    "queues.json": {"niche": [], "blueprint": [], "brand": [], "script": [], "title": [], "thumbnail": [], "video": [], "edit": [], "upload": []},
+    "batches.json": [],
+    "uploads.json": [],
+    "metadata_edits.json": [],
+    "settings.json": {
+        "port": 3030,
+        "moneyprinter_path": "",
+        "script_interval_minutes": 10,
+        "llm_rpm_limit": 40,
+        "video_concurrency": 3,
+        "upload_concurrency": 2,
+        "youtube_api_key": "",
+        "llm_provider": "moonshot",
+        "moonshot_api_key": "",
+        "moonshot_base_url": "",
+        "moonshot_model_name": "",
+        "shengsuanyun_api_key": "",
+        "shengsuanyun_base_url": "",
+        "shengsuanyun_model_name": "",
+        "openai_api_key": "",
+        "openai_base_url": "",
+        "openai_model_name": "",
+        "gemini_api_key": "",
+        "gemini_model_name": "",
+        "deepseek_api_key": "",
+        "deepseek_base_url": "",
+        "deepseek_model_name": "",
+        "qwen_api_key": "",
+        "qwen_model_name": "",
+        "azure_api_key": "",
+        "azure_base_url": "",
+        "azure_model_name": "",
+        "azure_api_version": "2024-02-15-preview",
+        "volcengine_api_key": "",
+        "volcengine_base_url": "",
+        "volcengine_model_name": "",
+        "grok_api_key": "",
+        "grok_base_url": "",
+        "grok_model_name": "",
+        "minimax_api_key": "",
+        "minimax_base_url": "",
+        "minimax_model_name": "",
+        "mimo_api_key": "",
+        "mimo_base_url": "",
+        "mimo_model_name": "",
+        "cloudflare_api_key": "",
+        "cloudflare_account_id": "",
+        "cloudflare_gateway_id": "",
+        "cloudflare_model_name": "",
+        "modelscope_api_key": "",
+        "modelscope_base_url": "",
+        "modelscope_model_name": "",
+        "aihubmix_api_key": "",
+        "aihubmix_base_url": "",
+        "aihubmix_model_name": "",
+        "aimlapi_api_key": "",
+        "aimlapi_base_url": "",
+        "aimlapi_model_name": "",
+        "evolink_api_key": "",
+        "evolink_base_url": "",
+        "evolink_model_name": "",
+        "ollama_base_url": "",
+        "ollama_model_name": "",
+        "oneapi_api_key": "",
+        "oneapi_base_url": "",
+        "oneapi_model_name": "",
+        "litellm_model_name": "",
+        "groq_api_key": "",
+        "groq_base_url": "",
+        "groq_model_name": "",
+        "pollinations_api_key": "",
+        "pollinations_base_url": "",
+        "pollinations_model_name": "",
+        "log_level": "DEBUG",
+        "listen_host": "127.0.0.1",
+        "listen_port": 8080,
+        "video_source": "pexels",
+        "match_materials_to_script": False,
+        "endpoint": "",
+        "proxy_http": "",
+        "proxy_https": "",
+        "pexels_api_keys": "",
+        "pixabay_api_keys": "",
+        "coverr_api_keys": "",
+        "twelvelabs_api_keys": "",
+        "sonilo_api_key": "",
+        "subtitle_provider": "edge",
+        "ffmpeg_path": "",
+        "video_codec": "",
+        "material_directory": "",
+        "whisper_model_size": "large-v3",
+        "whisper_device": "cpu",
+        "whisper_compute_type": "int8",
+        "azure_speech_key": "",
+        "azure_speech_region": "",
+        "siliconflow_tts_api_key": "",
+        "minimax_tts_api_key": "",
+        "minimax_tts_base_url": "",
+        "minimax_tts_model_id": "speech-2.8-hd",
+        "minimax_tts_voice_id": "English_expressive_narrator",
+        "elevenlabs_api_key": "",
+        "elevenlabs_model_id": "eleven_multilingual_v2",
+        "chatterbox_base_url": "http://127.0.0.1:4123/v1",
+        "chatterbox_api_key": "",
+        "chatterbox_model_id": "chatterbox",
+        "upload_post_enabled": False,
+        "upload_post_api_key": "",
+        "upload_post_username": "",
+        "upload_post_platforms": "tiktok,instagram",
+        "upload_post_auto_upload": False,
+        "tiktok_client_key": "",
+        "tiktok_client_secret": "",
+        "tiktok_redirect_uri": "http://localhost:3030/oauth/tiktok/callback",
+        "tiktok_scopes": "user.info.basic,video.publish,video.upload",
+        "tiktok_access_token": "",
+        "tiktok_connection_status": "not_configured",
+    },
+}
+
+
+def now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def seed_blueprints() -> None:
+    """Copy packaged seed Blueprints without overwriting local user files."""
+    if not SEED_BLUEPRINTS.exists():
+        return
+    destination = BLUEPRINTS / "importados"
+    destination.mkdir(parents=True, exist_ok=True)
+    for source in sorted(SEED_BLUEPRINTS.glob("*.json")):
+        target = destination / source.name
+        if not target.exists():
+            shutil.copy2(source, target)
+
+
+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"]:
+        path.mkdir(parents=True, exist_ok=True)
+    seed_blueprints()
+    for filename, default in DEFAULTS.items():
+        target = STATE / filename
+        if not target.exists():
+            atomic_write(target, default)
+
+
+def atomic_write(path: Path, data: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, temp_name = tempfile.mkstemp(prefix=f".{path.name}.", dir=path.parent)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            json.dump(data, handle, ensure_ascii=False, indent=2)
+            handle.write("\n")
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temp_name, path)
+    finally:
+        if os.path.exists(temp_name):
+            os.unlink(temp_name)
+
+
+def read_json(name: str, default: Any | None = None) -> Any:
+    ensure_storage()
+    path = STATE / name
+    try:
+        with path.open("r", encoding="utf-8") as handle:
+            return json.load(handle)
+    except (json.JSONDecodeError, OSError):
+        backup = path.with_suffix(path.suffix + f".corrupt-{datetime.now().strftime('%Y%m%d%H%M%S')}")
+        if path.exists():
+            shutil.copy2(path, backup)
+        fallback = DEFAULTS.get(name, [] if default is None else default)
+        atomic_write(path, fallback)
+        return fallback
+
+
+def write_json(name: str, data: Any) -> None:
+    ensure_storage()
+    atomic_write(STATE / name, data)
+
+
+def append_json(name: str, item: dict[str, Any]) -> dict[str, Any]:
+    entries = read_json(name, [])
+    if not isinstance(entries, list):
+        entries = []
+    entries.append(item)
+    write_json(name, entries)
+    return item
+
+
+def list_blueprint_files() -> list[Path]:
+    ensure_storage()
+    return sorted(BLUEPRINTS.rglob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)
+
+
+def load_blueprint_file(path: Path) -> dict[str, Any]:
+    with path.open("r", encoding="utf-8") as handle:
+        data = json.load(handle)
+    if not isinstance(data, dict):
+        raise ValueError("O blueprint deve ser um objecto JSON.")
+    return data

package/integrations/local_runtime.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+
+class MoneyPrinterRuntime:
+    """Detecta apenas a instalação local do MoneyPrinterTurbo."""
+
+    def __init__(self, settings: dict[str, Any]):
+        self.settings = settings
+        self.moneyprinter_path = Path(settings.get("moneyprinter_path", "") or os.getenv("MONEYPRINTER_PATH", ""))
+
+    def moneyprinter_available(self) -> bool:
+        return bool(self.moneyprinter_path and self.moneyprinter_path.exists())
+
+    def status(self) -> dict[str, Any]:
+        available = self.moneyprinter_available()
+        return {
+            "moneyprinter": available,
+            "mode": "moneyprinter" if available else "not_configured",
+            "moneyprinter_path": str(self.moneyprinter_path) if self.moneyprinter_path else "",
+        }

package/integrations/moneyprinter_config.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+try:
+    import toml
+except ImportError:  # pragma: no cover - installation fallback
+    toml = None
+
+
+def _list_value(value: Any) -> list[str]:
+    if isinstance(value, list):
+        return [str(item).strip() for item in value if str(item).strip()]
+    return [item.strip() for item in str(value or "").replace("\n", ",").split(",") if item.strip()]
+
+
+def _set_if_present(target: dict[str, Any], key: str, value: Any) -> None:
+    if value is not None:
+        target[key] = value
+
+
+def build_moneyprinter_config(settings: dict[str, Any], existing: dict[str, Any] | None = None) -> dict[str, Any]:
+    config = dict(existing or {})
+    app = dict(config.get("app") or {})
+    whisper = dict(config.get("whisper") or {})
+    azure = dict(config.get("azure") or {})
+    siliconflow = dict(config.get("siliconflow") or {})
+    minimax_tts = dict(config.get("minimax_tts") or {})
+    elevenlabs = dict(config.get("elevenlabs") or {})
+    chatterbox = dict(config.get("chatterbox") or {})
+    proxy = dict(config.get("proxy") or {})
+
+    app_map = {
+        "llm_provider": "llm_provider",
+        "moonshot_api_key": "moonshot_api_key",
+        "moonshot_base_url": "moonshot_base_url",
+        "moonshot_model_name": "moonshot_model_name",
+        "shengsuanyun_api_key": "shengsuanyun_api_key",
+        "shengsuanyun_base_url": "shengsuanyun_base_url",
+        "shengsuanyun_model_name": "shengsuanyun_model_name",
+        "openai_api_key": "openai_api_key",
+        "openai_base_url": "openai_base_url",
+        "openai_model_name": "openai_model_name",
+        "gemini_api_key": "gemini_api_key",
+        "gemini_model_name": "gemini_model_name",
+        "deepseek_api_key": "deepseek_api_key",
+        "deepseek_base_url": "deepseek_base_url",
+        "deepseek_model_name": "deepseek_model_name",
+        "qwen_api_key": "qwen_api_key",
+        "qwen_model_name": "qwen_model_name",
+        "azure_api_key": "azure_api_key",
+        "azure_base_url": "azure_base_url",
+        "azure_model_name": "azure_model_name",
+        "azure_api_version": "azure_api_version",
+        "volcengine_api_key": "volcengine_api_key",
+        "volcengine_base_url": "volcengine_base_url",
+        "volcengine_model_name": "volcengine_model_name",
+        "grok_api_key": "grok_api_key",
+        "grok_base_url": "grok_base_url",
+        "grok_model_name": "grok_model_name",
+        "minimax_api_key": "minimax_api_key",
+        "minimax_base_url": "minimax_base_url",
+        "minimax_model_name": "minimax_model_name",
+        "mimo_api_key": "mimo_api_key",
+        "mimo_base_url": "mimo_base_url",
+        "mimo_model_name": "mimo_model_name",
+        "cloudflare_api_key": "cloudflare_api_key",
+        "cloudflare_account_id": "cloudflare_account_id",
+        "cloudflare_gateway_id": "cloudflare_gateway_id",
+        "cloudflare_model_name": "cloudflare_model_name",
+        "modelscope_api_key": "modelscope_api_key",
+        "modelscope_base_url": "modelscope_base_url",
+        "modelscope_model_name": "modelscope_model_name",
+        "aihubmix_api_key": "aihubmix_api_key",
+        "aihubmix_base_url": "aihubmix_base_url",
+        "aihubmix_model_name": "aihubmix_model_name",
+        "aimlapi_api_key": "aimlapi_api_key",
+        "aimlapi_base_url": "aimlapi_base_url",
+        "aimlapi_model_name": "aimlapi_model_name",
+        "evolink_api_key": "evolink_api_key",
+        "evolink_base_url": "evolink_base_url",
+        "evolink_model_name": "evolink_model_name",
+        "ollama_base_url": "ollama_base_url",
+        "ollama_model_name": "ollama_model_name",
+        "oneapi_api_key": "oneapi_api_key",
+        "oneapi_base_url": "oneapi_base_url",
+        "oneapi_model_name": "oneapi_model_name",
+        "litellm_model_name": "litellm_model_name",
+        "groq_api_key": "groq_api_key",
+        "groq_base_url": "groq_base_url",
+        "groq_model_name": "groq_model_name",
+        "pollinations_api_key": "pollinations_api_key",
+        "pollinations_base_url": "pollinations_base_url",
+        "pollinations_model_name": "pollinations_model_name",
+        "log_level": "log_level",
+        "listen_host": "listen_host",
+        "listen_port": "listen_port",
+        "video_source": "video_source",
+        "endpoint": "endpoint",
+        "material_directory": "material_directory",
+        "match_materials_to_script": "match_materials_to_script",
+        "sonilo_api_key": "sonilo_api_key",
+        "sonilo_base_url": "sonilo_base_url",
+        "subtitle_provider": "subtitle_provider",
+        "ffmpeg_path": "ffmpeg_path",
+        "video_codec": "video_codec",
+        "material_directory": "material_directory",
+        "match_materials_to_script": "match_materials_to_script",
+        "twelvelabs_rerank_terms": "twelvelabs_rerank_terms",
+    }
+    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])
+    config["app"] = app
+
+    whisper["model_size"] = settings.get("whisper_model_size", whisper.get("model_size", "large-v3"))
+    whisper["device"] = settings.get("whisper_device", whisper.get("device", "cpu"))
+    whisper["compute_type"] = settings.get("whisper_compute_type", whisper.get("compute_type", "int8"))
+    config["whisper"] = whisper
+
+    azure["speech_key"] = settings.get("azure_speech_key", azure.get("speech_key", ""))
+    azure["speech_region"] = settings.get("azure_speech_region", azure.get("speech_region", ""))
+    config["azure"] = azure
+
+    siliconflow["api_key"] = settings.get("siliconflow_tts_api_key", siliconflow.get("api_key", ""))
+    config["siliconflow"] = siliconflow
+
+    for source, target in {
+        "minimax_tts_api_key": "api_key",
+        "minimax_tts_base_url": "base_url",
+        "minimax_tts_model_id": "model_id",
+        "minimax_tts_voice_id": "voice_id",
+    }.items():
+        if source in settings:
+            minimax_tts[target] = settings[source]
+    config["minimax_tts"] = minimax_tts
+
+    elevenlabs["api_key"] = settings.get("elevenlabs_api_key", elevenlabs.get("api_key", ""))
+    elevenlabs["model_id"] = settings.get("elevenlabs_model_id", elevenlabs.get("model_id", "eleven_multilingual_v2"))
+    config["elevenlabs"] = elevenlabs
+
+    chatterbox["base_url"] = settings.get("chatterbox_base_url", chatterbox.get("base_url", "http://127.0.0.1:4123/v1"))
+    chatterbox["api_key"] = settings.get("chatterbox_api_key", chatterbox.get("api_key", ""))
+    chatterbox["model_id"] = settings.get("chatterbox_model_id", chatterbox.get("model_id", "chatterbox"))
+    config["chatterbox"] = chatterbox
+
+    if settings.get("proxy_http"):
+        proxy["http"] = settings["proxy_http"]
+    if settings.get("proxy_https"):
+        proxy["https"] = settings["proxy_https"]
+    if proxy:
+        config["proxy"] = proxy
+    return config
+
+
+def sync_moneyprinter_config(settings: dict[str, Any], moneyprinter_path: str) -> Path | None:
+    if not moneyprinter_path or toml is None:
+        return None
+    root = Path(moneyprinter_path).expanduser()
+    if not root.exists():
+        return None
+    target = root / "config.toml"
+    existing: dict[str, Any] = {}
+    if target.exists():
+        try:
+            existing = toml.load(target)
+        except Exception:
+            existing = {}
+    payload = build_moneyprinter_config(settings, existing)
+    target.write_text(toml.dumps(payload), encoding="utf-8")
+    return target

package/integrations/platforms.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import requests
+
+
+@dataclass
+class IntegrationResult:
+    ok: bool
+    message: str
+    data: dict[str, Any]
+
+
+class YouTubeAdapter:
+    def __init__(self, api_key: str = ""):
+        self.api_key = api_key or os.getenv("YOUTUBE_API_KEY", "")
+
+    @staticmethod
+    def extract_channel_ref(value: str) -> str:
+        value = value.strip()
+        match = re.search(r"(?:channel/|@)([A-Za-z0-9_.-]+)", value)
+        return match.group(1) if match else value
+
+    def fetch_channel(self, value: str) -> IntegrationResult:
+        ref = self.extract_channel_ref(value)
+        if not self.api_key:
+            return IntegrationResult(False, "YOUTUBE_API_KEY não configurada; preencha os dados manualmente.", {"url": value, "handle": ref})
+        try:
+            params = {"part": "snippet,statistics", "key": self.api_key}
+            if ref.startswith("UC"):
+                params["id"] = ref
+            else:
+                params["forHandle"] = ref if ref.startswith("@") else f"@{ref}"
+            response = requests.get("https://www.googleapis.com/youtube/v3/channels", params=params, timeout=15)
+            response.raise_for_status()
+            items = response.json().get("items", [])
+            if not items:
+                return IntegrationResult(False, "Canal não encontrado pela API do YouTube.", {})
+            item = items[0]
+            snippet = item.get("snippet", {})
+            stats = item.get("statistics", {})
+            data = {
+                "youtube_id": item.get("id", ""),
+                "name": snippet.get("title", ""),
+                "handle": snippet.get("customUrl", ""),
+                "description": snippet.get("description", ""),
+                "thumbnail_url": snippet.get("thumbnails", {}).get("high", {}).get("url", ""),
+                "subscriber_count": int(stats["subscriberCount"]) if stats.get("subscriberCount") else None,
+                "video_count": int(stats["videoCount"]) if stats.get("videoCount") else None,
+                "view_count": int(stats["viewCount"]) if stats.get("viewCount") else None,
+                "metrics_source": "youtube_data_api",
+            }
+            return IntegrationResult(True, "Canal importado do YouTube.", data)
+        except requests.RequestException as exc:
+            return IntegrationResult(False, f"Falha ao consultar o YouTube: {exc}", {})
+
+
+class TikTokAdapter:
+    def __init__(self, settings: dict[str, Any]):
+        self.client_key = settings.get("tiktok_client_key", "")
+        self.client_secret = settings.get("tiktok_client_secret", "")
+        # Redirect URI, scopes, OAuth e access token são geridos no TikTok for Developers Playground.
+        # A UI guarda apenas as credenciais da aplicação.
+        self.access_token = os.getenv("TIKTOK_ACCESS_TOKEN", "")
+
+    @property
+    def configured(self) -> bool:
+        return bool(self.client_key and self.client_secret)
+
+    def status(self) -> IntegrationResult:
+        if not self.configured:
+            return IntegrationResult(False, "TikTok ainda não configurado.", {"status": "not_configured"})
+        return IntegrationResult(True, "TikTok Client ID e Client Secret configurados; autorização e publicação são geridas no TikTok for Developers Playground.", {"status": "configured"})
+
+    def upload_video(self, video_path: str, title: str = "", privacy_level: str = "SELF_ONLY") -> IntegrationResult:
+        path = Path(video_path)
+        if not path.exists():
+            return IntegrationResult(False, "Ficheiro de vídeo não encontrado.", {"path": video_path})
+        if not self.configured:
+            return IntegrationResult(False, "Configure TikTok Client ID e Client Secret.", {"path": video_path})
+        if not self.access_token:
+            return IntegrationResult(False, "Conclua a autorização no TikTok for Developers Playground; o token de publicação deve ser fornecido pelo ambiente de execução.", {"path": str(path), "status": "requires_playground_authorization"})
+        try:
+            size = path.stat().st_size
+            payload = {"post_info": {"title": title[:2200], "privacy_level": privacy_level, "disable_duet": False, "disable_comment": False, "disable_stitch": False}, "source_info": {"source": "FILE_UPLOAD", "video_size": size, "chunk_size": size, "total_chunk_count": 1}}
+            response = requests.post("https://open.tiktokapis.com/v2/post/publish/video/init/", headers={"Authorization": f"Bearer {self.access_token}", "Content-Type": "application/json; charset=UTF-8"}, json=payload, timeout=30)
+            response.raise_for_status()
+            body = response.json()
+            error = body.get("error", {})
+            if error.get("code") not in (None, "ok"):
+                return IntegrationResult(False, f"TikTok rejeitou a inicialização: {error.get('message', error.get('code'))}", {"error": error})
+            data = body.get("data", {})
+            publish_id = data.get("publish_id", "")
+            upload_url = data.get("upload_url", "")
+            if not upload_url or not publish_id:
+                return IntegrationResult(False, "TikTok não devolveu upload_url e publish_id.", {"response": body})
+            with path.open("rb") as handle:
+                upload = requests.put(upload_url, headers={"Content-Type": "video/mp4", "Content-Length": str(size), "Content-Range": f"bytes 0-{size - 1}/{size}"}, data=handle, timeout=300)
+            upload.raise_for_status()
+            return IntegrationResult(True, "Vídeo enviado para processamento no TikTok.", {"publish_id": publish_id, "status": "processing"})
+        except requests.RequestException as exc:
+            return IntegrationResult(False, f"Falha no upload TikTok: {exc}", {"status": "failed"})

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@danhachuel/thunderbolt",
+  "version": "0.2.13",
+  "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
+  "main": "scripts/cli.mjs",
+  "type": "module",
+  "bin": {
+    "thunderbolt": "scripts/cli.mjs"
+  },
+  "files": [
+    "app/main.py",
+    "hermes_ui/*.py",
+    "integrations/*.py",
+    "scripts/*.mjs",
+    "storage/blueprints/**/*.json",
+    "seed/blueprints/**/*.json",
+    "README.md",
+    "MANUAL-INSTALACAO.md",
+    "requirements.txt",
+    "package.json"
+  ],
+  "scripts": {
+    "start": "node scripts/cli.mjs",
+    "check": "node scripts/cli.mjs --check",
+    "pack:check": "npm pack --dry-run"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/requirements.txt

@@ -0,0 +1,5 @@
+streamlit>=1.37,<2
+requests>=2.31,<3
+pandas>=2.0,<3
+imageio-ffmpeg>=0.6,<1
+toml>=0.10,<1