@danhachuel/thunderbolt 0.6.6 → 0.6.8

package/app/main.py

@@ -118,7 +118,7 @@ from integrations.upload_post import UploadPostAdapter, UPLOAD_POST_PLATFORM_OPT
 from integrations.bilibili_upload import BilibiliApiAdapter, BILIBILI_DEFAULT_TID, BILIBILI_VIDEO_EXTENSIONS, normalise_bilibili_api_cards
 from integrations.distrokid_upload import DistroKidAdapter, DISTROKID_AUDIO_EXTENSIONS, DISTROKID_COVER_EXTENSIONS, close_distrokid_session
 from integrations.music_uploads import JewelMusicAdapter, PushtunesAdapter, YTMusicApiAdapter, MUSIC_UPLOAD_EXTENSIONS, PUSHTUNES_OPERATIONS, PUSHTUNES_SOURCES, PUSHTUNES_TARGETS, YT_MUSIC_UPLOAD_EXTENSIONS
-from integrations.upload_routing import COMPOSIO_OPERATION_OPTIONS, OFFICIAL_DAILY_LIMIT, official_upload_count, upload_with_default_route
+from integrations.upload_routing import COMPOSIO_OPERATION_OPTIONS, OFFICIAL_DAILY_LIMIT, official_upload_count, resolve_youtube_account, upload_with_default_route
 from integrations.youtube_direct_upload import YouTubeDirectUploader
 from integrations.youtube_direct_credentials import delete_credentials_document, direct_account_status, document_status, ensure_credentials_document, load_credentials_document, merge_credentials_document, parse_credentials_document, save_credentials_document, update_credentials_document_session_info
 from integrations.session_info_health import check_account_session_info_health
@@ -5597,7 +5597,7 @@ def render_upload_direct():
         with st.container(border=True):
             st.write(f"**{task.get('topic', 'Sem tópico')}** — {task.get('channel_name', 'Canal')}")
             st.caption(video_path or "Sem caminho de vídeo registado")
-            account = direct_accounts.get(str(channel.get("google_account_id", "")))
+            account = resolve_youtube_account(settings, channel)
             credential_status = document_status(STORAGE, account, channel, settings, channels) if account else None
             if not account:
                 st.warning("Este canal não tem uma conta Google associada. Associe a conta no cartão deste canal em Canais cadastrados.")
@@ -6364,7 +6364,7 @@ def render_upload_conventional():
             st.caption(video_path or "Sem caminho de vídeo registado")
             selected_youtube_channel = upload_targets.get("YouTube") if "YouTube" in destination else None
             channel = selected_youtube_channel or channel_map.get(str(task.get("channel_id")), {})
-            account = direct_accounts.get(str(channel.get("google_account_id", "")))
+            account = resolve_youtube_account(settings, channel)
             if "YouTube" in destination:
                 detected_language = normalize_video_language(task.get("language") or channel.get("language") or "pt")
                 language_state_key = f"yt_language_{task['id']}"

package/hermes_ui/pipeline_worker.py

@@ -23,7 +23,7 @@ from typing import Any
 
 from integrations.moneyprinter_config import sync_moneyprinter_config
 from integrations.session_info_health import check_all_accounts_session_info_health, emit_session_info_health_alerts
-from integrations.upload_routing import upload_with_default_route
+from integrations.upload_routing import resolve_youtube_account, upload_with_default_route
 from hermes_ui.creative_generation import CreativeGenerationError, generate_creative_package, generate_title_and_keywords, generate_thumbnail_prompt, generate_topic_for_channel
 from hermes_ui.script_documents import save_script_document
 from hermes_ui.script_generation import generate_script_document
@@ -1566,7 +1566,7 @@ def _run_task(task: dict[str, Any]) -> dict[str, Any]:
         settings,
         storage_root=STORAGE,
         channel=channel,
-        account=next((item for item in settings.get("youtube_batch_accounts", []) if isinstance(item, dict) and str(item.get("id")) == str(channel.get("google_account_id"))), None),
+        account=resolve_youtube_account(settings, channel),
         video_path=str(video_path),
         title=title,
         description=str(script.get("summary") or "") + "\n\n" + str(script.get("content") or "")[:5000],

package/integrations/composio_upload.py

@@ -10,6 +10,14 @@ class ComposioUploadError(ValueError):
     """Safe, user-facing validation or integration error."""
 
 
+COMPOSIO_OPERATION_SEARCH = {
+    "upload_video": {"query": "Upload Video", "toolkit": "YOUTUBE"},
+    "update_video": {"query": "Update Video", "toolkit": "YOUTUBE"},
+    "upload_tiktok_video": {"query": "Upload Video", "toolkit": "TIKTOK"},
+    "upload_instagram_media": {"query": "Upload Video Reel Photo", "toolkit": "INSTAGRAM"},
+}
+
+
 def _safe_value(value: Any) -> Any:
     if value is None or isinstance(value, (str, int, float, bool)):
         return value
@@ -119,6 +127,38 @@ def discover_tools(api_key: str, user_id: str, query: str, toolkit: str = "") ->
         raise ComposioUploadError(f"Não foi possível descobrir ferramentas Composio: {type(exc).__name__}: {exc}") from exc
 
 
+def resolve_tool_slug(api_key: str, user_id: str, configured_slug: str, toolkit: str = "") -> str:
+    """Resolve a Thunderbolt operation alias to a real Composio tool slug."""
+    slug = str(configured_slug or "").strip()
+    operation = COMPOSIO_OPERATION_SEARCH.get(slug)
+    if operation is None:
+        return slug
+    search_toolkit = str(operation["toolkit"] or toolkit or "").strip()
+    tools = discover_tools(api_key, user_id, str(operation["query"]), search_toolkit)
+    if not tools:
+        raise ComposioUploadError(
+            f"Não foi encontrada uma ferramenta Composio para `{slug}`. "
+            f"Ligue o toolkit {search_toolkit or 'correspondente'} e use Descobrir ferramentas."
+        )
+
+    def score(item: dict[str, Any]) -> tuple[int, str]:
+        candidate = str(item.get("slug") or "").strip()
+        normalized = candidate.upper().replace("-", "_")
+        if slug == "upload_video":
+            priority = {
+                "YOUTUBE_UPLOAD_VIDEO": 0,
+                "YOUTUBE_MULTIPART_UPLOAD_VIDEO": 1,
+                "YOUTUBE_UPLOAD": 2,
+            }.get(normalized, 3)
+        elif slug == "update_video":
+            priority = 0 if normalized == "YOUTUBE_UPDATE_VIDEO" else 1
+        else:
+            priority = 0 if "VIDEO" in normalized and "UPLOAD" in normalized else 1
+        return priority, candidate
+
+    return min((item for item in tools if item.get("slug")), key=score)["slug"]
+
+
 def authorize_toolkit(api_key: str, user_id: str, toolkit: str) -> dict[str, Any]:
     toolkit = str(toolkit or "").strip()
     if not toolkit:

package/integrations/upload_routing.py

@@ -19,7 +19,7 @@ from integrations.session_info_health import check_account_session_info_health,
 from integrations.youtube_direct_credentials import document_status
 from integrations.youtube_direct_upload import YouTubeDirectUploader
 from integrations.youtube_session_manager import renew_account_session
-from integrations.composio_upload import ComposioUploadError, execute_upload
+from integrations.composio_upload import ComposioUploadError, execute_upload, resolve_tool_slug
 from hermes_ui.storage import read_json, write_json
 from hermes_ui.languages import language_locale
 
@@ -45,11 +45,41 @@ def _attempt_record(name: str, result: IntegrationResult, *, skipped: bool = Fal
     }
 
 
+def resolve_youtube_account(settings: dict[str, Any], channel: dict[str, Any] | None) -> dict[str, Any] | None:
+    """Resolve the configured Google account without relying only on the channel ID.
+
+    Older channel records may retain the account e-mail while the account ID is
+    missing or stale. Prefer an exact ID match, then use a case-insensitive
+    e-mail match, and finally accept a sole configured account only when the
+    channel has no contradictory account reference.
+    """
+    if not isinstance(channel, dict):
+        return None
+    accounts = [item for item in settings.get("youtube_batch_accounts", []) if isinstance(item, dict) and item.get("id")]
+    if not accounts:
+        return None
+    account_id = str(channel.get("google_account_id") or "").strip()
+    if account_id:
+        match = next((item for item in accounts if str(item.get("id") or "").strip() == account_id), None)
+        if match is not None:
+            return match
+    account_email = str(channel.get("google_account_email") or "").strip().casefold()
+    if account_email:
+        match = next((item for item in accounts if str(item.get("email") or "").strip().casefold() == account_email), None)
+        if match is not None:
+            return match
+    if not account_id and not account_email and len(accounts) == 1:
+        return accounts[0]
+    return None
+
+
 def _quota_key(channel: dict[str, Any], account: dict[str, Any] | None) -> str:
     if account and account.get("id"):
         return f"account:{account['id']}"
     if channel.get("google_account_id"):
         return f"account:{channel['google_account_id']}"
+    if channel.get("google_account_email"):
+        return f"account-email:{str(channel['google_account_email']).strip().casefold()}"
     return f"channel:{channel.get('id', 'unknown')}"
 
 
@@ -107,6 +137,7 @@ def upload_with_default_route(
     composio_publisher: Callable[..., IntegrationResult] | None = None,
 ) -> IntegrationResult:
     attempts: list[dict[str, Any]] = []
+    account = account or resolve_youtube_account(settings, channel)
     composio_enabled = bool(settings.get("composio_enabled", False)) and bool(settings.get("composio_auto_upload", True))
     composio_ready = composio_enabled and bool(settings.get("composio_api_key")) and bool(settings.get("composio_tool_slug"))
     if composio_enabled and not composio_ready:
@@ -239,7 +270,16 @@ def upload_with_default_route(
 
 
 def _composio_upload(settings: dict[str, Any], *, channel: dict[str, Any], **kwargs: Any) -> IntegrationResult:
-    slug = str(settings.get("composio_tool_slug") or "").strip()
+    configured_slug = str(settings.get("composio_tool_slug") or "").strip()
+    try:
+        slug = resolve_tool_slug(
+            str(settings.get("composio_api_key") or ""),
+            str(settings.get("composio_user_id") or ""),
+            configured_slug,
+            str(settings.get("composio_toolkit") or ""),
+        )
+    except ComposioUploadError as exc:
+        return IntegrationResult(False, str(exc), {"status": "tool_resolution_failed", "configured_slug": configured_slug})
     normalized_slug = slug.upper().replace("-", "_")
     connected_account_tool = normalized_slug in {"UPLOAD_VIDEO", "UPDATE_VIDEO", "UPLOAD_TIKTOK_VIDEO", "UPLOAD_INSTAGRAM_MEDIA"}
     youtube_upload_tool = normalized_slug in {"UPLOAD_VIDEO", "YOUTUBE_UPLOAD_VIDEO", "YOUTUBE_MULTIPART_UPLOAD_VIDEO"} or ("YOUTUBE" in normalized_slug and "UPLOAD" in normalized_slug and normalized_slug != "YOUTUBE_UPLOAD")
@@ -294,7 +334,7 @@ def _composio_upload(settings: dict[str, Any], *, channel: dict[str, Any], **kwa
         result = execute_upload(
             str(settings.get("composio_api_key") or ""),
             str(settings.get("composio_user_id") or ""),
-            str(settings.get("composio_tool_slug") or ""),
+            slug,
             str(kwargs.get("video_path") or ""),
             file_field,
             json.dumps(parsed_arguments, ensure_ascii=False),
@@ -304,5 +344,5 @@ def _composio_upload(settings: dict[str, Any], *, channel: dict[str, Any], **kwa
     return IntegrationResult(
         bool(result.get("successful")),
         str(result.get("error") or "Upload via Composio concluído."),
-        {"composio_data": result.get("data") or {}, "log_id": result.get("log_id") or "", "tool_slug": result.get("tool_slug") or slug},
+        {"composio_data": result.get("data") or {}, "log_id": result.get("log_id") or "", "tool_slug": result.get("tool_slug") or slug, "configured_tool_slug": configured_slug},
     )

package/integrations/youtube_upload.py

@@ -11,13 +11,9 @@ from integrations.platforms import IntegrationResult
 from integrations.youtube_batch import loopback_host, loopback_port, loopback_redirect_uri, token_path as batch_token_path
 
 
-# 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",
-]
+# O fluxo de upload precisa apenas do scope de publicação; Analytics e leitura
+# são autorizados separadamente e não devem ser enviados neste refresh OAuth.
+AGENT_SCOPES = ["https://www.googleapis.com/auth/youtube.upload"]
 FALLBACK_SCOPES = ["https://www.googleapis.com/auth/youtube.upload"]
 
 
@@ -137,7 +133,9 @@ class _GoogleYouTubeBase:
         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)
+        # Não reenviar self.scopes durante o refresh: o Google deve reutilizar
+        # os scopes efectivamente concedidos no token guardado.
+        credentials = Credentials.from_authorized_user_info(raw, None)
         granted_scopes = {str(scope).strip() for scope in (credentials.scopes or [])}
         if "https://www.googleapis.com/auth/youtube.upload" in self.scopes and granted_scopes and "https://www.googleapis.com/auth/youtube.upload" not in granted_scopes:
             email = _safe_text((self.account or {}).get("email")) or "a conta seleccionada"
@@ -316,7 +314,9 @@ class DirectYouTubeOAuthUploader(_GoogleYouTubeBase):
             settings,
             storage_root / "state" / "youtube_oauth_fallback_token.json",
             FALLBACK_SCOPES,
-            alternate_token_path=storage_root / "state" / "youtube_agent_tokens.json",
+            # Não reutilizar o token do agente: pode conter scopes de leitura/Analytics
+            # que provocam invalid_scope no refresh do fallback de upload.
+            alternate_token_path=None,
             account=account,
         )
 

package/package.json

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