@danhachuel/thunderbolt 0.2.17 → 0.2.19

package/integrations/platforms.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 import os
 import re
 from dataclasses import dataclass
@@ -9,6 +10,102 @@ from typing import Any
 import requests
 
 
+def _extract_json_assignment(document: str, variable: str) -> dict[str, Any] | None:
+    marker = re.search(rf"(?:var\s+)?{re.escape(variable)}\s*=", document)
+    if not marker:
+        return None
+    start = document.find("{", marker.end())
+    if start < 0:
+        return None
+    depth = 0
+    in_string = False
+    escaped = False
+    for index in range(start, len(document)):
+        character = document[index]
+        if in_string:
+            if escaped:
+                escaped = False
+            elif character == "\\":
+                escaped = True
+            elif character == '"':
+                in_string = False
+            continue
+        if character == '"':
+            in_string = True
+        elif character == "{":
+            depth += 1
+        elif character == "}":
+            depth -= 1
+            if depth == 0:
+                try:
+                    parsed = json.loads(document[start:index + 1])
+                except json.JSONDecodeError:
+                    return None
+                return parsed if isinstance(parsed, dict) else None
+    return None
+
+
+def _find_first_key(value: Any, key: str) -> Any:
+    if isinstance(value, dict):
+        if key in value:
+            return value[key]
+        for child in value.values():
+            found = _find_first_key(child, key)
+            if found is not None:
+                return found
+    elif isinstance(value, list):
+        for child in value:
+            found = _find_first_key(child, key)
+            if found is not None:
+                return found
+    return None
+
+
+def _text_from_node(value: Any) -> str:
+    if isinstance(value, str):
+        return value.strip()
+    if isinstance(value, dict):
+        for key in ("simpleText", "content", "text"):
+            if isinstance(value.get(key), str):
+                return value[key].strip()
+        runs = value.get("runs")
+        if isinstance(runs, list):
+            return "".join(str(run.get("text", "")) for run in runs if isinstance(run, dict)).strip()
+    return ""
+
+
+def _parse_public_count(value: Any) -> int | None:
+    text = _text_from_node(value).lower().replace(" ", "")
+    if not text:
+        return None
+    match = re.search(r"([0-9][0-9.,]*)(mil|milhões|mi|bi|[kmb])?", text)
+    if not match:
+        return None
+    number = match.group(1)
+    suffix = match.group(2) or ""
+    if suffix == "milhões":
+        suffix = "m"
+    try:
+        if suffix in {"k", "mil"}:
+            return int(float(number.replace(",", ".")) * 1_000)
+        if suffix in {"m", "mi"}:
+            return int(float(number.replace(",", ".")) * 1_000_000)
+        if suffix == "b":
+            return int(float(number.replace(",", ".")) * 1_000_000_000)
+        return int(re.sub(r"[^0-9]", "", number))
+    except ValueError:
+        return None
+
+
+def _thumbnail_from_metadata(metadata: dict[str, Any]) -> str:
+    thumbnails = metadata.get("avatar", {}).get("thumbnails", []) if isinstance(metadata, dict) else []
+    if isinstance(thumbnails, list) and thumbnails:
+        last = thumbnails[-1]
+        if isinstance(last, dict):
+            return str(last.get("url", ""))
+    return ""
+
+
 @dataclass
 class IntegrationResult:
     ok: bool
@@ -17,8 +114,9 @@ class IntegrationResult:
 
 
 class YouTubeAdapter:
-    def __init__(self, api_key: str = ""):
-        self.api_key = api_key or os.getenv("YOUTUBE_API_KEY", "")
+    def __init__(self, api_key: str = "", settings: dict[str, Any] | None = None):
+        self.settings = settings or {}
+        self.api_key = api_key or self.settings.get("youtube_api_key", "") or os.getenv("YOUTUBE_API_KEY", "")
 
     @staticmethod
     def extract_channel_ref(value: str) -> str:
@@ -26,6 +124,72 @@ class YouTubeAdapter:
         match = re.search(r"(?:channel/|@)([A-Za-z0-9_.-]+)", value)
         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."""
+        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})
+            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 ""
+            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"))
+            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")
+            data = {
+                "youtube_id": youtube_id,
+                "name": title,
+                "handle": handle,
+                "url": canonical_url,
+                "description": description,
+                "thumbnail_url": _thumbnail_from_metadata(metadata),
+                "subscriber_count": _parse_public_count(subscriber_value),
+                "video_count": _parse_public_count(video_value),
+                "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})
+
     def fetch_channel(self, value: str) -> IntegrationResult:
         ref = self.extract_channel_ref(value)
         if not self.api_key:
@@ -59,6 +223,36 @@ class YouTubeAdapter:
         except requests.RequestException as exc:
             return IntegrationResult(False, f"Falha ao consultar o YouTube: {exc}", {})
 
+    def upload_video(self, video_path: str, **kwargs: Any) -> IntegrationResult:
+        """Publish through the adapted youtube-automation-agent, then OAuth fallback."""
+        from integrations.youtube_upload import upload_youtube_with_fallback
+        from hermes_ui.storage import STORAGE
+
+        return upload_youtube_with_fallback(
+            self.settings,
+            STORAGE,
+            video_path=video_path,
+            **kwargs,
+        )
+
+    def upload_status(self) -> dict[str, IntegrationResult]:
+        from integrations.youtube_upload import youtube_upload_status
+        from hermes_ui.storage import STORAGE
+
+        return youtube_upload_status(self.settings, STORAGE)
+
+    def authorize_agent(self) -> IntegrationResult:
+        from integrations.youtube_upload import authorize_youtube_agent
+        from hermes_ui.storage import STORAGE
+
+        return authorize_youtube_agent(self.settings, STORAGE)
+
+    def authorize_fallback(self) -> IntegrationResult:
+        from integrations.youtube_upload import authorize_youtube_fallback
+        from hermes_ui.storage import STORAGE
+
+        return authorize_youtube_fallback(self.settings, STORAGE)
+
 
 class TikTokAdapter:
     def __init__(self, settings: dict[str, Any]):

package/integrations/youtube_upload.py

@@ -0,0 +1,367 @@
+from __future__ import annotations
+
+import json
+import os
+import secrets
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+from integrations.platforms import IntegrationResult
+
+
+# Mantemos os mesmos escopos usados pelo youtube-automation-agent.
+AGENT_SCOPES = [
+    "https://www.googleapis.com/auth/youtube.upload",
+    "https://www.googleapis.com/auth/youtube",
+    "https://www.googleapis.com/auth/youtube.readonly",
+    "https://www.googleapis.com/auth/yt-analytics.readonly",
+]
+FALLBACK_SCOPES = ["https://www.googleapis.com/auth/youtube.upload"]
+
+
+@dataclass
+class UploadAttempt:
+    mechanism: str
+    result: IntegrationResult
+
+
+def _safe_text(value: Any, default: str = "") -> str:
+    return str(value if value is not None else default).strip()
+
+
+def _path_value(value: Any) -> Path | None:
+    if isinstance(value, dict):
+        value = value.get("path") or value.get("file") or value.get("filepath")
+    if not value:
+        return None
+    return Path(str(value)).expanduser()
+
+
+def validate_video_file(video_path: str | os.PathLike[str]) -> tuple[bool, str, Path]:
+    """Validate the same real-video conditions used by the agent before publishing."""
+    path = Path(video_path).expanduser()
+    if not path.exists() or not path.is_file():
+        return False, "Ficheiro de vídeo não encontrado; o upload foi recusado.", path
+    if path.suffix.lower() != ".mp4":
+        return False, "O youtube-automation-agent só publica ficheiros MP4 reais.", path
+    if path.stat().st_size <= 0:
+        return False, "O ficheiro de vídeo está vazio; o upload foi recusado.", path
+    return True, "Vídeo válido.", path
+
+
+def build_agent_video_metadata(
+    *,
+    title: str,
+    description: str = "",
+    tags: list[str] | None = None,
+    category_id: str = "22",
+    language: str = "pt-BR",
+    privacy_status: str = "private",
+    publish_at: str | None = None,
+) -> dict[str, Any]:
+    """Build the snippet/status payload used by PublishingSchedulingAgent."""
+    status: dict[str, Any] = {
+        "privacyStatus": privacy_status or "private",
+        "selfDeclaredMadeForKids": False,
+    }
+    if publish_at and status["privacyStatus"] == "private":
+        # YouTube requires a future publishAt with privacyStatus=private.
+        status["publishAt"] = publish_at
+    return {
+        "snippet": {
+            "title": _safe_text(title)[:100] or "Vídeo Thunderbolt",
+            "description": _safe_text(description),
+            "tags": [str(tag).strip() for tag in (tags or []) if str(tag).strip()],
+            "categoryId": _safe_text(category_id, "22"),
+            "defaultLanguage": _safe_text(language, "pt-BR"),
+            "defaultAudioLanguage": _safe_text(language, "pt-BR"),
+        },
+        "status": status,
+    }
+
+
+class _GoogleYouTubeBase:
+    def __init__(self, settings: dict[str, Any], token_path: Path, scopes: list[str], alternate_token_path: Path | None = None):
+        self.settings = settings
+        self.client_id = _safe_text(settings.get("youtube_client_id")) or os.getenv("YOUTUBE_CLIENT_ID", "")
+        self.client_secret = _safe_text(settings.get("youtube_client_secret")) or os.getenv("YOUTUBE_CLIENT_SECRET", "")
+        self.token_path = token_path
+        self.alternate_token_path = alternate_token_path
+        self.scopes = scopes
+
+    @property
+    def configured(self) -> bool:
+        return bool(self.client_id and self.client_secret)
+
+    @property
+    def token_exists(self) -> bool:
+        return any(path.exists() and path.stat().st_size > 0 for path in self._token_candidates())
+
+    def _token_candidates(self) -> list[Path]:
+        paths = [self.token_path]
+        if self.alternate_token_path and self.alternate_token_path not in paths:
+            paths.append(self.alternate_token_path)
+        return paths
+
+    def _client_config(self) -> dict[str, Any]:
+        return {
+            "installed": {
+                "client_id": self.client_id,
+                "client_secret": self.client_secret,
+                "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+                "token_uri": "https://oauth2.googleapis.com/token",
+                "redirect_uris": ["http://localhost"],
+            }
+        }
+
+    def _load_credentials(self) -> Any:
+        try:
+            from google.auth.transport.requests import Request
+            from google.oauth2.credentials import Credentials
+        except ImportError as exc:
+            raise RuntimeError("As dependências Google OAuth ainda não estão instaladas. Execute a instalação do Thunderbolt novamente.") from exc
+        token_source = next((path for path in self._token_candidates() if path.exists() and path.stat().st_size > 0), None)
+        if token_source is None:
+            return None
+        raw = json.loads(token_source.read_text(encoding="utf-8"))
+        if isinstance(raw, dict) and isinstance(raw.get("youtube"), dict):
+            raw = raw["youtube"]
+        credentials = Credentials.from_authorized_user_info(raw, self.scopes)
+        if credentials.expired and credentials.refresh_token:
+            credentials.refresh(Request())
+            self._save_credentials(credentials)
+        return credentials
+
+    def _save_credentials(self, credentials: Any, *, nested: bool = False) -> None:
+        self.token_path.parent.mkdir(parents=True, exist_ok=True)
+        payload = json.loads(credentials.to_json())
+        if nested:
+            payload = {"youtube": payload}
+        temporary = self.token_path.with_name(f".{self.token_path.name}.{secrets.token_hex(6)}.tmp")
+        temporary.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+        try:
+            os.chmod(temporary, 0o600)
+        except OSError:
+            pass
+        temporary.replace(self.token_path)
+        try:
+            os.chmod(self.token_path, 0o600)
+        except OSError:
+            pass
+
+    def _build_client(self, credentials: Any) -> Any:
+        try:
+            from googleapiclient.discovery import build
+        except ImportError as exc:
+            raise RuntimeError("A biblioteca Google API Client ainda não está instalada. Execute a instalação do Thunderbolt novamente.") from exc
+        return build("youtube", "v3", credentials=credentials, cache_discovery=False)
+
+    def authorize(self, *, open_browser: bool = True) -> IntegrationResult:
+        if not self.configured:
+            return IntegrationResult(False, "Preencha o YouTube OAuth Client ID e Client Secret nas Configurações.", {"status": "not_configured"})
+        try:
+            from google_auth_oauthlib.flow import InstalledAppFlow
+        except ImportError as exc:
+            return IntegrationResult(False, "As dependências Google OAuth ainda não estão instaladas. Execute a instalação do Thunderbolt novamente.", {"status": "missing_dependencies", "error": str(exc)})
+        try:
+            flow = InstalledAppFlow.from_client_config(self._client_config(), self.scopes)
+            credentials = flow.run_local_server(
+                host="localhost",
+                port=0,
+                open_browser=open_browser,
+                access_type="offline",
+                prompt="consent",
+                include_granted_scopes="true",
+            )
+            self._save_credentials(credentials, nested=self.__class__.__name__ == "YouTubeAutomationAgentUploader")
+            return IntegrationResult(True, "Conta YouTube autorizada com sucesso.", {"status": "authorized", "token_path": str(self.token_path)})
+        except Exception as exc:
+            return IntegrationResult(False, f"A autorização Google falhou: {exc}", {"status": "authorization_failed"})
+
+    def status(self) -> IntegrationResult:
+        if not self.configured:
+            return IntegrationResult(False, "YouTube OAuth ainda não configurado.", {"status": "not_configured", "authorized": False})
+        if not self.token_exists:
+            return IntegrationResult(False, "YouTube OAuth configurado, mas a conta ainda não foi autorizada.", {"status": "requires_authorization", "authorized": False})
+        try:
+            credentials = self._load_credentials()
+            if credentials and credentials.valid:
+                return IntegrationResult(True, "YouTube autorizado e pronto para publicar.", {"status": "ready", "authorized": True})
+            if credentials and credentials.refresh_token:
+                return IntegrationResult(True, "YouTube autorizado; o token será renovado no próximo uso.", {"status": "ready_refreshable", "authorized": True})
+        except Exception as exc:
+            return IntegrationResult(False, f"Token YouTube inválido ou expirado: {exc}", {"status": "invalid_token", "authorized": False})
+        return IntegrationResult(False, "Token YouTube não está pronto para publicar.", {"status": "requires_authorization", "authorized": False})
+
+    def _upload_common(
+        self,
+        *,
+        video_path: str,
+        title: str,
+        description: str,
+        tags: list[str],
+        category_id: str,
+        language: str,
+        privacy_status: str,
+        publish_at: str | None,
+        thumbnail_path: str | None,
+        captions_path: str | None,
+    ) -> IntegrationResult:
+        valid, message, path = validate_video_file(video_path)
+        if not valid:
+            return IntegrationResult(False, message, {"status": "invalid_video", "path": str(path)})
+        try:
+            credentials = self._load_credentials()
+            if credentials is None:
+                return IntegrationResult(False, "Autorize primeiro a conta YouTube.", {"status": "requires_authorization", "path": str(path)})
+            youtube = self._build_client(credentials)
+            body = build_agent_video_metadata(
+                title=title,
+                description=description,
+                tags=tags,
+                category_id=category_id,
+                language=language,
+                privacy_status=privacy_status,
+                publish_at=publish_at,
+            )
+            try:
+                from googleapiclient.http import MediaFileUpload
+            except ImportError as exc:
+                raise RuntimeError("A biblioteca de upload Google ainda não está instalada.") from exc
+            media = MediaFileUpload(str(path), mimetype="video/mp4", chunksize=8 * 1024 * 1024, resumable=True)
+            request = youtube.videos().insert(part="snippet,status", body=body, media_body=media)
+            response = None
+            while response is None:
+                _, response = request.next_chunk()
+            video_id = response.get("id") if isinstance(response, dict) else None
+            if not video_id:
+                return IntegrationResult(False, "O YouTube não devolveu um ID de vídeo após o upload.", {"status": "upload_failed", "response": response or {}})
+
+            extras: dict[str, Any] = {}
+            thumbnail = _path_value(thumbnail_path)
+            if thumbnail and thumbnail.exists() and thumbnail.is_file():
+                try:
+                    with thumbnail.open("rb") as handle:
+                        youtube.thumbnails().set(videoId=video_id, media_body=handle).execute()
+                    extras["thumbnail_uploaded"] = True
+                except Exception as exc:
+                    extras["thumbnail_warning"] = str(exc)
+            captions = _path_value(captions_path)
+            if captions and captions.exists() and captions.is_file():
+                try:
+                    with captions.open("rb") as handle:
+                        youtube.captions().insert(
+                            part="snippet",
+                            body={"snippet": {"videoId": video_id, "language": language or "pt", "name": "Thunderbolt", "isDraft": False}},
+                            media_body=handle,
+                        ).execute()
+                    extras["captions_uploaded"] = True
+                except Exception as exc:
+                    extras["captions_warning"] = str(exc)
+            return IntegrationResult(
+                True,
+                f"Vídeo publicado no YouTube: https://www.youtube.com/watch?v={video_id}",
+                {"status": "published", "video_id": video_id, "url": f"https://www.youtube.com/watch?v={video_id}", "mechanism": self.__class__.__name__, **extras},
+            )
+        except Exception as exc:
+            return IntegrationResult(False, f"Falha no upload YouTube: {exc}", {"status": "upload_failed", "error": str(exc), "mechanism": self.__class__.__name__})
+
+
+class YouTubeAutomationAgentUploader(_GoogleYouTubeBase):
+    """Adaptation of the source agent's PublishingSchedulingAgent inside Thunderbolt."""
+
+    def __init__(self, settings: dict[str, Any], storage_root: Path):
+        super().__init__(settings, storage_root / "state" / "youtube_agent_tokens.json", AGENT_SCOPES)
+
+    def upload(self, **kwargs: Any) -> IntegrationResult:
+        result = self._upload_common(**kwargs)
+        result.data.setdefault("mechanism", "youtube-automation-agent-adaptado")
+        return result
+
+
+class DirectYouTubeOAuthUploader(_GoogleYouTubeBase):
+    """Independent minimal OAuth upload path used only after the primary path fails."""
+
+    def __init__(self, settings: dict[str, Any], storage_root: Path):
+        super().__init__(
+            settings,
+            storage_root / "state" / "youtube_oauth_fallback_token.json",
+            FALLBACK_SCOPES,
+            alternate_token_path=storage_root / "state" / "youtube_agent_tokens.json",
+        )
+
+    def upload(self, **kwargs: Any) -> IntegrationResult:
+        result = self._upload_common(**kwargs)
+        result.data.setdefault("mechanism", "oauth-direct-fallback")
+        return result
+
+
+def upload_youtube_with_fallback(
+    settings: dict[str, Any],
+    storage_root: Path,
+    *,
+    video_path: str,
+    title: str,
+    description: str = "",
+    tags: list[str] | None = None,
+    category_id: str = "22",
+    language: str = "pt-BR",
+    privacy_status: str = "private",
+    publish_at: str | None = None,
+    thumbnail_path: str | None = None,
+    captions_path: str | None = None,
+    on_attempt: Callable[[UploadAttempt], None] | None = None,
+) -> IntegrationResult:
+    """Run the adapted agent path first and OAuth direct only as redundancy."""
+    kwargs = {
+        "video_path": video_path,
+        "title": title,
+        "description": description,
+        "tags": tags or [],
+        "category_id": category_id,
+        "language": language,
+        "privacy_status": privacy_status,
+        "publish_at": publish_at,
+        "thumbnail_path": thumbnail_path,
+        "captions_path": captions_path,
+    }
+    attempts: list[dict[str, Any]] = []
+    primary = YouTubeAutomationAgentUploader(settings, storage_root)
+    primary_result = primary.upload(**kwargs)
+    primary_result.data.setdefault("mechanism", "youtube-automation-agent-adaptado")
+    primary_attempt = UploadAttempt("youtube-automation-agent-adaptado", primary_result)
+    attempts.append({"mechanism": primary_attempt.mechanism, "ok": primary_result.ok, "message": primary_result.message, "data": primary_result.data})
+    if on_attempt:
+        on_attempt(primary_attempt)
+    if primary_result.ok:
+        primary_result.data["attempts"] = attempts
+        return primary_result
+
+    fallback = DirectYouTubeOAuthUploader(settings, storage_root)
+    fallback_result = fallback.upload(**kwargs)
+    fallback_result.data.setdefault("mechanism", "oauth-direct-fallback")
+    fallback_attempt = UploadAttempt("oauth-direct-fallback", fallback_result)
+    attempts.append({"mechanism": fallback_attempt.mechanism, "ok": fallback_result.ok, "message": fallback_result.message, "data": fallback_result.data})
+    if on_attempt:
+        on_attempt(fallback_attempt)
+    fallback_result.data["attempts"] = attempts
+    if fallback_result.ok:
+        fallback_result.message = f"Upload concluído pelo fallback OAuth directo após falha do agente: {fallback_result.message}"
+        return fallback_result
+    return IntegrationResult(False, f"O agente de upload falhou e o fallback OAuth também falhou. Agente: {primary_result.message} Fallback: {fallback_result.message}", {"status": "all_upload_mechanisms_failed", "attempts": attempts})
+
+
+def authorize_youtube_agent(settings: dict[str, Any], storage_root: Path, *, open_browser: bool = True) -> IntegrationResult:
+    return YouTubeAutomationAgentUploader(settings, storage_root).authorize(open_browser=open_browser)
+
+
+def authorize_youtube_fallback(settings: dict[str, Any], storage_root: Path, *, open_browser: bool = True) -> IntegrationResult:
+    return DirectYouTubeOAuthUploader(settings, storage_root).authorize(open_browser=open_browser)
+
+
+def youtube_upload_status(settings: dict[str, Any], storage_root: Path) -> dict[str, IntegrationResult]:
+    return {
+        "agent": YouTubeAutomationAgentUploader(settings, storage_root).status(),
+        "fallback": DirectYouTubeOAuthUploader(settings, storage_root).status(),
+    }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/thunderbolt",
-  "version": "0.2.17",
+  "version": "0.2.19",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "main": "scripts/cli.mjs",
   "type": "module",
@@ -11,9 +11,11 @@
     "app/main.py",
     "hermes_ui/*.py",
     "integrations/*.py",
+    "integrations/data/*.json",
     "scripts/*.mjs",
     "storage/blueprints/**/*.json",
     "seed/blueprints/**/*.json",
+    "seed/skills/*.md",
     "README.md",
     "MANUAL-INSTALACAO.md",
     "requirements.txt",

package/requirements.txt

@@ -3,3 +3,6 @@ requests>=2.31,<3
 pandas>=2.0,<3
 imageio-ffmpeg>=0.6,<1
 toml>=0.10,<1
+google-auth>=2.29,<3
+google-auth-oauthlib>=1.2,<2
+google-api-python-client>=2.120,<3

package/scripts/cli.mjs

@@ -76,6 +76,7 @@ function ensureRuntimeStorage() {
     join(storageRoot, "metadata_cleaner"),
     join(storageRoot, "metadata_cleaner", "originals"),
     join(storageRoot, "metadata_cleaner", "outputs"),
+    join(storageRoot, "skills"),
   ];
   for (const directory of directories) mkdirSync(directory, { recursive: true });
   const seedRoot = resolve(root, "seed", "blueprints");

package/scripts/install.mjs

@@ -107,6 +107,7 @@ function ensureDirs() {
     join(storageRoot, "metadata_cleaner", "originals"),
     join(storageRoot, "metadata_cleaner", "outputs"),
     join(storageRoot, "artifacts"),
+    join(storageRoot, "skills"),
   ];
   for (const directory of directories) mkdirSync(directory, { recursive: true });
   copySeedBlueprints(storageRoot);
@@ -287,7 +288,7 @@ function writeSettings(moneyprinterPath) {
 
 function installThunderboltDependencies(python) {
   if (!existsSync(pythonBin)) run(python.command, [...python.args, "-m", "venv", venvPath]);
-  installRequirementIfNeeded(join(root, "requirements.txt"), "thunderbolt_requirements_sha256", ["streamlit", "requests", "pandas", "toml", "imageio_ffmpeg"], "Thunderbolt");
+  installRequirementIfNeeded(join(root, "requirements.txt"), "thunderbolt_requirements_sha256", ["streamlit", "requests", "pandas", "toml", "imageio_ffmpeg", "google.auth", "google_auth_oauthlib", "googleapiclient"], "Thunderbolt");
 }
 
 function installMoneyPrinterDependencies(moneyprinterPath) {