@danhachuel/thunderbolt 0.2.19 → 0.2.21

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

@@ -177,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,
     },
 }
 
@@ -198,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 / "skills", 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

package/integrations/platforms.py

@@ -3,9 +3,11 @@ from __future__ import annotations
 import json
 import os
 import re
+import xml.etree.ElementTree as ET
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
+from urllib.parse import urlparse
 
 import requests
 
@@ -106,6 +108,72 @@ def _thumbnail_from_metadata(metadata: dict[str, Any]) -> str:
     return ""
 
 
+def _meta_content(document: str, *names: str) -> str:
+    for name in names:
+        pattern = rf'<meta[^>]+(?:name|property)=["\']{re.escape(name)}["\'][^>]+content=["\']([^"\']*)["\']'
+        match = re.search(pattern, document, flags=re.IGNORECASE)
+        if match:
+            return match.group(1).strip()
+        reverse_pattern = rf'<meta[^>]+content=["\']([^"\']*)["\'][^>]+(?:name|property)=["\']{re.escape(name)}["\']'
+        match = re.search(reverse_pattern, document, flags=re.IGNORECASE)
+        if match:
+            return match.group(1).strip()
+    return ""
+
+
+def _public_page_candidates(source: str) -> list[str]:
+    source = source.strip()
+    if source.startswith(("http://", "https://")):
+        parsed = urlparse(source)
+        base = f"https://{parsed.netloc}{parsed.path}".rstrip("/")
+        if parsed.netloc.lower().endswith("youtube.com"):
+            base = base.replace("/about", "").replace("/videos", "")
+    elif source.startswith("UC"):
+        base = f"https://www.youtube.com/channel/{source}"
+    else:
+        handle = source if source.startswith("@") else f"@{source}"
+        base = f"https://www.youtube.com/{handle}"
+    return list(dict.fromkeys([
+        f"{base}/about?hl=pt-BR&gl=BR",
+        f"{base}?hl=pt-BR&gl=BR",
+        f"{base}/videos?hl=pt-BR&gl=BR",
+    ]))
+
+
+def _channel_id_from_document(document: str, canonical_url: str = "") -> str:
+    patterns = [
+        r'"externalId"\s*:\s*"(UC[A-Za-z0-9_-]+)"',
+        r'"channelId"\s*:\s*"(UC[A-Za-z0-9_-]+)"',
+        r"/channel/(UC[A-Za-z0-9_-]+)",
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, document)
+        if match:
+            return match.group(1)
+    match = re.search(r"/channel/(UC[A-Za-z0-9_-]+)", canonical_url)
+    return match.group(1) if match else ""
+
+
+def _public_feed_data(channel_id: str, headers: dict[str, str]) -> dict[str, Any]:
+    if not channel_id:
+        return {}
+    try:
+        response = requests.get(
+            f"https://www.youtube.com/feeds/videos.xml?channel_id={channel_id}",
+            headers=headers,
+            timeout=12,
+        )
+        response.raise_for_status()
+        root = ET.fromstring(response.text)
+        namespace = {"yt": "http://www.youtube.com/xml/schemas/2015", "atom": "http://www.w3.org/2005/Atom"}
+        title = root.findtext("atom:title", default="", namespaces=namespace).strip()
+        feed_id = root.findtext("yt:channelId", default=channel_id, namespaces=namespace).strip()
+        entries = root.findall("atom:entry", namespace)
+        return {"name": title, "youtube_id": feed_id, "video_count": len(entries) if entries else None}
+    except (requests.RequestException, ET.ParseError, ValueError):
+        return {}
+
+
 @dataclass
 class IntegrationResult:
     ok: bool
@@ -125,70 +193,72 @@ class YouTubeAdapter:
         return match.group(1) if match else value
 
     def fetch_channel_public(self, value: str) -> IntegrationResult:
-        """Fetch public channel metadata from YouTube HTML without an API key."""
+        """Fetch public channel metadata without requiring a YouTube Data API key."""
         source = (value or "").strip()
         if not source:
             return IntegrationResult(False, "Introduza o nome, handle, URL ou ID do canal.", {})
-        try:
-            if source.startswith("http://") or source.startswith("https://"):
-                page_url = source.rstrip("/")
-            elif source.startswith("UC"):
-                page_url = f"https://www.youtube.com/channel/{source}"
-            else:
-                handle = source if source.startswith("@") else f"@{source}"
-                page_url = f"https://www.youtube.com/{handle}"
-            if not page_url.endswith("/about"):
-                page_url = f"{page_url}/about"
-            response = requests.get(
-                page_url,
-                headers={
-                    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/124 Safari/537.36",
-                    "Accept-Language": "pt-BR,pt;q=0.9,en;q=0.8",
-                },
-                timeout=20,
-            )
-            response.raise_for_status()
-            document = response.text
-            initial_data = _extract_json_assignment(document, "ytInitialData")
-            metadata = _find_first_key(initial_data or {}, "channelMetadataRenderer") or {}
-            header = _find_first_key(initial_data or {}, "pageHeaderViewModel") or {}
-            if not metadata and not header:
-                return IntegrationResult(False, "O YouTube não disponibilizou dados públicos para este canal. Confirme o link ou tente a aba Cadastro manual.", {"url": page_url})
+        headers = {
+            "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/124 Safari/537.36",
+            "Accept-Language": "pt-BR,pt;q=0.9,en;q=0.8",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        }
+        last_url = source
+        last_error = ""
+        for page_url in _public_page_candidates(source):
+            last_url = page_url
+            try:
+                response = requests.get(page_url, headers=headers, timeout=20)
+                response.raise_for_status()
+            except requests.RequestException as exc:
+                last_error = str(exc)
+                continue
+            document = response.text or ""
+            initial_data = _extract_json_assignment(document, "ytInitialData") or {}
+            metadata = _find_first_key(initial_data, "channelMetadataRenderer") or {}
+            header = _find_first_key(initial_data, "pageHeaderViewModel") or {}
+            canonical_url = _meta_content(document, "og:url", "twitter:url") or page_url.split("?", 1)[0].rstrip("/")
             owner_urls = metadata.get("ownerUrls", []) if isinstance(metadata, dict) else []
-            canonical_url = owner_urls[0] if owner_urls else page_url.removesuffix("/about")
-            canonical_url = canonical_url.replace("http://", "https://")
-            handle_match = re.search(r"/@([^/?]+)", canonical_url)
-            handle = f"@{handle_match.group(1)}" if handle_match else ""
+            if owner_urls:
+                canonical_url = str(owner_urls[0])
+            canonical_url = canonical_url.replace("http://", "https://").removesuffix("/about")
+            youtube_id = str(metadata.get("externalId", "")) if isinstance(metadata, dict) else ""
+            if not youtube_id:
+                youtube_id = _channel_id_from_document(document, canonical_url)
+            feed = _public_feed_data(youtube_id, headers)
             title = _text_from_node(metadata.get("title")) if isinstance(metadata, dict) else ""
             if not title and isinstance(header, dict):
                 title = _text_from_node(header.get("title"))
                 if not title:
                     title = _text_from_node(_find_first_key(header, "dynamicTextViewModel"))
+            if not title:
+                title = _meta_content(document, "og:title", "twitter:title") or feed.get("name", "")
             description = _text_from_node(metadata.get("description")) if isinstance(metadata, dict) else ""
-            youtube_id = str(metadata.get("externalId", "")) if isinstance(metadata, dict) else ""
-            if not youtube_id:
-                id_match = re.search(r"/channel/(UC[A-Za-z0-9_-]+)", canonical_url)
-                youtube_id = id_match.group(1) if id_match else ""
-            subscriber_value = _find_first_key(initial_data or {}, "subscriberCountText")
-            video_value = _find_first_key(initial_data or {}, "videoCountText")
+            description = description or _meta_content(document, "description", "og:description")
+            thumbnail_url = _thumbnail_from_metadata(metadata) or _meta_content(document, "og:image", "twitter:image")
+            handle_match = re.search(r"/@([^/?]+)", canonical_url)
+            handle = f"@{handle_match.group(1)}" if handle_match else ""
+            if not handle:
+                handle_match = re.search(r"/@([^/?]+)", document)
+                handle = f"@{handle_match.group(1)}" if handle_match else ""
+            subscriber_value = _find_first_key(initial_data, "subscriberCountText")
+            video_value = _find_first_key(initial_data, "videoCountText")
             data = {
-                "youtube_id": youtube_id,
+                "youtube_id": youtube_id or feed.get("youtube_id", ""),
                 "name": title,
                 "handle": handle,
                 "url": canonical_url,
                 "description": description,
-                "thumbnail_url": _thumbnail_from_metadata(metadata),
+                "thumbnail_url": thumbnail_url,
                 "subscriber_count": _parse_public_count(subscriber_value),
-                "video_count": _parse_public_count(video_value),
+                "video_count": _parse_public_count(video_value) or feed.get("video_count"),
                 "view_count": None,
                 "metrics_source": "youtube_public_page",
                 "public_lookup": True,
             }
-            return IntegrationResult(True, "Canal encontrado publicamente no YouTube, sem API Key. Reveja os dados antes de guardar.", data)
-        except requests.RequestException as exc:
-            return IntegrationResult(False, f"Não foi possível consultar a página pública do YouTube: {exc}", {"url": source})
-        except (json.JSONDecodeError, TypeError, ValueError) as exc:
-            return IntegrationResult(False, f"A página pública do YouTube mudou ou não pôde ser interpretada: {exc}", {"url": source})
+            if data["name"] or data["youtube_id"] or data["thumbnail_url"]:
+                return IntegrationResult(True, "Canal encontrado publicamente no YouTube, sem API Key. Reveja os dados antes de guardar.", data)
+            last_error = "A página respondeu sem metadados reconhecíveis."
+        return IntegrationResult(False, f"Não foi possível obter dados públicos do YouTube sem API Key. Confirme o URL/handle ou use Cadastro manual. {last_error}".strip(), {"url": last_url, "public_lookup": True})
 
     def fetch_channel(self, value: str) -> IntegrationResult:
         ref = self.extract_channel_ref(value)

package/integrations/youtube_direct_upload.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import secrets
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+from urllib.parse import quote
+
+import requests
+
+
+CHUNK_GRANULARITY = 262144
+SUPPORTED_EXTENSIONS = {".mp4", ".mov", ".webm", ".avi", ".mpeg", ".mpg", ".flv", ".wmv", ".3gpp"}
+COOKIE_KEYS = ("SID", "SSID", "HSID", "APISID", "SAPISID")
+
+
+@dataclass
+class DirectUploadResult:
+    ok: bool
+    message: str
+    data: dict[str, Any]
+
+
+def _cookie_settings(settings: dict[str, Any]) -> dict[str, str]:
+    return {key: str(settings.get(f"direct_cookie_{key.lower()}", "") or "").strip() for key in COOKIE_KEYS}
+
+
+def _cookie_header(cookies: dict[str, str]) -> str:
+    return ";".join(["CONSENT=YES+cb"] + [f"{key}={value}" for key, value in cookies.items() if value])
+
+
+def _sapishash(sapisid: str, origin: str = "https://studio.youtube.com") -> str:
+    timestamp = int(time.time())
+    digest = hashlib.sha1(f"{timestamp} {sapisid} {origin}".encode("utf-8")).hexdigest()
+    return f"{timestamp}_{digest}"
+
+
+def _innertube_id() -> str:
+    return f"innertube_studio:{secrets.token_hex(18)}:0"
+
+
+def _header(response: requests.Response, name: str) -> str:
+    wanted = name.lower()
+    for key, value in response.headers.items():
+        if key.lower() == wanted:
+            return str(value)
+    return ""
+
+
+def validate_direct_upload(video_path: str | Path, channel: dict[str, Any], settings: dict[str, Any]) -> str | None:
+    path = Path(video_path)
+    if not path.exists() or not path.is_file():
+        return "Ficheiro de vídeo não encontrado."
+    if path.suffix.lower() not in SUPPORTED_EXTENSIONS:
+        return "Formato de vídeo não suportado pelo upload directo."
+    if path.stat().st_size <= 0:
+        return "O ficheiro de vídeo está vazio."
+    missing_cookies = [key for key, value in _cookie_settings(settings).items() if not value]
+    if missing_cookies:
+        return f"Faltam cookies de sessão para upload directo: {', '.join(missing_cookies)}."
+    if not str(settings.get("direct_session_info", "") or "").strip():
+        return "Configure o token sessionInfo do upload directo."
+    if not str(settings.get("direct_innertube_api_key", "") or "").strip():
+        return "Configure o INNERTUBE_API_KEY do upload directo."
+    if not str(channel.get("delegated_session_id", "") or "").strip():
+        return "Este canal não tem DELEGATED_SESSION_ID configurado."
+    return None
+
+
+class YouTubeDirectUploader:
+    def __init__(self, settings: dict[str, Any], channel: dict[str, Any], *, session: requests.Session | None = None):
+        self.settings = settings
+        self.channel = channel
+        self.session = session or requests.Session()
+        self.cookies = _cookie_settings(settings)
+        self.cookie_header = _cookie_header(self.cookies)
+        self.user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/124 Safari/537.36"
+        self.inner_tube = _innertube_id()
+        self.google_upload: dict[str, str] = {}
+        self.video_id = ""
+
+    def _base_headers(self) -> dict[str, str]:
+        return {
+            "User-Agent": self.user_agent,
+            "Origin": "https://studio.youtube.com",
+            "Referer": "https://studio.youtube.com/",
+            "Cookie": self.cookie_header,
+        }
+
+    def describe_file(self, path: Path) -> None:
+        headers = {
+            **self._base_headers(),
+            "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
+            "X-Goog-Upload-File-Name": path.name,
+            "X-Goog-Upload-Header-Content-Length": str(path.stat().st_size),
+            "X-Goog-Upload-Command": "start",
+            "X-Goog-Upload-Protocol": "resumable",
+        }
+        response = self.session.post("https://upload.youtube.com/upload/studio?authuser=0", headers=headers, data={"frontendUploadId": self.inner_tube}, timeout=60)
+        response.raise_for_status()
+        self.google_upload = {
+            "resource_id": _header(response, "x-goog-upload-header-scotty-resource-id"),
+            "upload_url": _header(response, "x-goog-upload-url"),
+            "upload_id": _header(response, "x-guploader-uploadid"),
+        }
+        if not self.google_upload["upload_url"] or not self.google_upload["resource_id"]:
+            raise RuntimeError("O YouTube não devolveu uma sessão de upload directo válida.")
+
+    def create_video(self, title: str, description: str, visibility: str) -> None:
+        payload = {
+            "resourceId": {"scottyResourceId": {"id": self.google_upload["resource_id"]}},
+            "frontendUploadId": self.inner_tube,
+            "initialMetadata": {
+                "title": {"newTitle": title},
+                "description": {"newDescription": description},
+                "privacy": {"newPrivacy": visibility},
+                "draftState": {"isDraft": False},
+                "targetedAudience": {"operation": "MDE_TARGETED_AUDIENCE_UPDATE_OPERATION_SET", "newTargetedAudience": "MDE_TARGETED_AUDIENCE_TYPE_ALL"},
+            },
+            "botguardClientResponse": f"${hashlib.sha1(os.urandom(16)).hexdigest()}",
+            "context": {
+                "client": {"clientName": 62, "clientVersion": "1.20210806.02.00", "hl": "pt-BR", "gl": "BR", "experimentsToken": "", "utcOffsetMinutes": 0},
+                "request": {"sessionInfo": {"token": str(self.settings.get("direct_session_info", ""))}},
+                "user": {"onBehalfOfUser": str(self.channel.get("delegated_session_id", ""))},
+            },
+        }
+        api_key = str(self.settings.get("direct_innertube_api_key", "")).strip()
+        endpoint = f"https://studio.youtube.com/youtubei/v1/upload/createvideo?alt=json&key={quote(api_key)}"
+        headers = {**self._base_headers(), "Content-Type": "application/json", "X-Youtube-Client-Name": "62", "X-Youtube-Client-Version": "1.20210806.02.00", "X-Goog-PageId": str(self.channel.get("delegated_session_id", "")), "Authorization": f"SAPISIDHASH {_sapishash(self.cookies['SAPISID'])}"}
+        response = self.session.post(endpoint, headers=headers, data=json.dumps(payload), timeout=60)
+        response.raise_for_status()
+        body = response.json() if response.content else {}
+        self.video_id = str(body.get("videoId") or body.get("video_id") or "")
+        if not self.video_id:
+            raise RuntimeError("O YouTube não devolveu o videoId após createvideo.")
+
+    def upload_chunks(self, path: Path, chunk_size: int = CHUNK_GRANULARITY) -> None:
+        chunk_size = max(CHUNK_GRANULARITY, int(chunk_size))
+        chunk_size -= chunk_size % CHUNK_GRANULARITY
+        if chunk_size == 0:
+            chunk_size = CHUNK_GRANULARITY
+        offset = 0
+        with path.open("rb") as handle:
+            while True:
+                chunk = handle.read(chunk_size)
+                if not chunk:
+                    break
+                last = offset + len(chunk) >= path.stat().st_size
+                headers = {**self._base_headers(), "Content-Type": "application/x-www-form-urlencoded;charset=utf-8", "X-Goog-Upload-Command": "upload, finalize" if last else "upload", "X-Goog-Upload-Offset": str(offset), "X-Goog-Upload-File-Name": quote(path.name)}
+                response = self.session.post(self.google_upload["upload_url"], headers=headers, data=chunk, timeout=180)
+                response.raise_for_status()
+                offset += len(chunk)
+
+    def upload(self, video_path: str | Path, *, title: str, description: str = "", visibility: str = "private", chunk_size: int = CHUNK_GRANULARITY) -> DirectUploadResult:
+        path = Path(video_path)
+        validation_error = validate_direct_upload(path, self.channel, self.settings)
+        if validation_error:
+            return DirectUploadResult(False, validation_error, {"mechanism": "youtube-frontend-direct"})
+        try:
+            self.describe_file(path)
+            self.create_video(title, description, visibility)
+            self.upload_chunks(path, chunk_size)
+            return DirectUploadResult(True, f"Upload directo concluído: {self.video_id}", {"mechanism": "youtube-frontend-direct", "video_id": self.video_id, "page_id": self.channel.get("delegated_session_id", "")})
+        except (requests.RequestException, OSError, ValueError, RuntimeError) as exc:
+            return DirectUploadResult(False, f"Upload directo falhou: {exc}", {"mechanism": "youtube-frontend-direct", "video_id": self.video_id})

package/package.json

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

package/requirements.txt

@@ -6,3 +6,4 @@ toml>=0.10,<1
 google-auth>=2.29,<3
 google-auth-oauthlib>=1.2,<2
 google-api-python-client>=2.120,<3
+edge-tts>=7.0,<8

package/scripts/cli.mjs

@@ -77,6 +77,8 @@ function ensureRuntimeStorage() {
     join(storageRoot, "metadata_cleaner", "originals"),
     join(storageRoot, "metadata_cleaner", "outputs"),
     join(storageRoot, "skills"),
+    join(storageRoot, "music"),
+    join(storageRoot, "voice_previews"),
   ];
   for (const directory of directories) mkdirSync(directory, { recursive: true });
   const seedRoot = resolve(root, "seed", "blueprints");
@@ -96,7 +98,7 @@ function check() {
     console.error(`Python não encontrado. Execute: npx.cmd --yes @danhachuel/thunderbolt install`);
     process.exit(1);
   }
-  const requiredModules = ["streamlit", "requests", "pandas", "toml", "imageio_ffmpeg"];
+  const requiredModules = ["streamlit", "requests", "pandas", "toml", "imageio_ffmpeg", "edge_tts"];
   const missing = requiredModules.filter((moduleName) => !moduleAvailable(moduleName));
   const ffmpeg = moduleAvailable("imageio_ffmpeg");
   const mptPath = configuredMoneyPrinterPath();