@danhachuel/thunderbolt 0.6.8 → 0.6.10

package/app/main.py

@@ -124,6 +124,7 @@ from integrations.youtube_direct_credentials import delete_credentials_document,
 from integrations.session_info_health import check_account_session_info_health
 from integrations.youtube_session_manager import renew_account_session
 from integrations.youtube_batch import account_key as youtube_batch_account_key, account_status as youtube_batch_account_status, authorize_account as authorize_youtube_batch_account, delete_account_token as delete_youtube_batch_token, list_my_channels as list_youtube_batch_channels, loopback_redirect_uri
+from integrations.youtube_upload import authorize_youtube_agent
 from integrations.youtube_growth_api import find_account_for_channel as find_youtube_growth_account
 from integrations.local_runtime import MoneyPrinterRuntime
 from integrations.moneyprinter_config import sync_moneyprinter_config
@@ -6767,7 +6768,7 @@ def render_google_accounts(*, include_innertube: bool = True):
                 document_save = st.button("Guardar documento nesta conta", key=f"save_direct_account_{account_id}", use_container_width=True)
 
                 account_status = youtube_batch_account_status(batch_account, STORAGE)
-                status_cols = st.columns(3)
+                status_cols = st.columns(4)
                 with status_cols[0]:
                     (st.success if account_status.ok else st.warning)(account_status.message)
                 with status_cols[1]:
@@ -6777,6 +6778,12 @@ def render_google_accounts(*, include_innertube: bool = True):
                         if result.ok:
                             st.rerun()
                 with status_cols[2]:
+                    if st.button("Autorizar upload YouTube", key=f"batch_authorize_upload_{account_id}", use_container_width=True, help="Autoriza esta conta com o escopo de publicação YouTube; é separado da autorização de leitura/listagem dos canais." ):
+                        result = authorize_youtube_agent(settings, STORAGE, account=batch_account)
+                        (st.success if result.ok else st.error)(result.message)
+                        if result.ok:
+                            st.rerun()
+                with status_cols[3]:
                     if st.button("Apagar conta", icon=":material/delete:", key=f"batch_remove_settings_{account_id}", use_container_width=True):
                         delete_youtube_batch_token(batch_account, STORAGE)
                         delete_credentials_document(STORAGE, batch_account)
@@ -8034,7 +8041,8 @@ def render_settings():
             composio_enabled = st.checkbox("Activar Composio", value=bool(settings.get("composio_enabled", False)), key="upload_composio_enabled")
             composio_auto_upload = st.checkbox("Usar Composio por defeito na Automação Youtube", value=bool(settings.get("composio_auto_upload", True)), key="upload_composio_auto_upload", help="Quando estiver configurado, Composio é tentado antes da API Oficial, Upload directo e Postiz.")
             composio_api_key = st.text_input("Composio API key", value=str(settings.get("composio_api_key") or ""), type="password", key="upload_composio_api_key", help="Use a API key de projecto do Composio Platform. Nunca coloque esta chave no GitHub, em URLs ou em mensagens.")
-            composio_user_id = st.text_input("Composio user ID", value=str(settings.get("composio_user_id") or "thunderbolt-local"), key="upload_composio_user_id", help="Identidade estável usada para associar as contas conectadas no Composio.")
+            composio_user_id = st.text_input("Composio user ID", value=str(settings.get("composio_user_id") or "thunderbolt-local"), key="upload_composio_user_id", help="Tem de ser o mesmo user ID usado quando as contas YouTube foram ligadas no Composio.")
+            composio_connected_account_id = st.text_input("Connected account YouTube (ID ou alias)", value=str(settings.get("composio_connected_account_id") or ""), key="upload_composio_connected_account_id", help="Opcional. Selecciona uma conta activa do Composio. Use o ID exacto ou alias configurado.")
             current_tool_slug = str(settings.get("composio_tool_slug") or "upload_video")
             if current_tool_slug not in composio_operation_slugs:
                 current_tool_slug = "upload_video"
@@ -8068,7 +8076,7 @@ def render_settings():
             with composio_action_cols[1]:
                 test_composio = st.button("Testar configuração", use_container_width=True, key="upload_composio_test")
             if save_composio:
-                settings.update({"composio_enabled": bool(composio_enabled), "composio_auto_upload": bool(composio_auto_upload), "composio_api_key": composio_api_key.strip(), "composio_user_id": composio_user_id.strip() or "thunderbolt-local", "composio_toolkit": composio_toolkit, "composio_tool_slug": composio_tool_slug, "composio_file_field": "videoFilePath", "composio_channel_field": composio_channel_field, "composio_privacy_status": composio_privacy_status, "composio_category_id": composio_category_id, "composio_language": composio_language, "composio_privacy_field": "privacyStatus", "composio_category_field": "categoryId", "composio_language_field": "defaultLanguage", "composio_arguments_json": composio_arguments_json or "{}"})
+                settings.update({"composio_enabled": bool(composio_enabled), "composio_auto_upload": bool(composio_auto_upload), "composio_api_key": composio_api_key.strip(), "composio_user_id": composio_user_id.strip() or "thunderbolt-local", "composio_connected_account_id": composio_connected_account_id.strip(), "composio_toolkit": composio_toolkit, "composio_tool_slug": composio_tool_slug, "composio_file_field": "videoFilePath", "composio_channel_field": composio_channel_field, "composio_privacy_status": composio_privacy_status, "composio_category_id": composio_category_id, "composio_language": composio_language, "composio_privacy_field": "privacyStatus", "composio_category_field": "categoryId", "composio_language_field": "defaultLanguage", "composio_arguments_json": composio_arguments_json or "{}"})
                 write_json("settings.json", settings)
                 st.success("Configuração Composio guardada.")
                 st.rerun()

package/hermes_ui/pipeline_worker.py

@@ -693,7 +693,18 @@ def _material_video_attempts(task: dict[str, Any], settings: dict[str, Any]) ->
     fallback = [item for item in attempts if item[0] != route]
     ordered = preferred + fallback
     if ordered:
-        return ordered
+        # Uma execução do helper já recebe a lista de chaves do provider
+        # configurado; não repetir o mesmo provider por cada cartão/key.
+        # Repetições anteriores reinstalavam dependências e produziam cascatas
+        # como Pexels → Pexels → Pixabay sem acrescentar uma estratégia real.
+        unique: list[tuple[str, str]] = []
+        seen: set[str] = set()
+        for provider, api_key in ordered:
+            if provider in seen:
+                continue
+            seen.add(provider)
+            unique.append((provider, api_key))
+        return unique
     # Legacy settings keep the complete key list in one config field. Let
     # MoneyPrinterTurbo retain its own list handling when no individual cards
     # are available, preserving backwards compatibility for older installs.

package/hermes_ui/storage.py

@@ -291,6 +291,7 @@ DEFAULTS: dict[str, Any] = {
         "composio_auto_upload": True,
         "composio_api_key": "",
         "composio_user_id": "thunderbolt-local",
+        "composio_connected_account_id": "",
         "composio_toolkit": "upload_video",
         "composio_tool_slug": "upload_video",
         "composio_file_field": "videoFilePath",

package/integrations/composio_upload.py

@@ -111,6 +111,35 @@ def _client(api_key: str, *, upload_dir: Path | None = None):
     return Composio(**kwargs)
 
 
+def _connected_account_id(client: Any, user_id: str, toolkit: str, selector: str) -> str:
+    """Resolve a connected-account ID from an ID or UI alias."""
+    value = str(selector or "").strip()
+    if not value:
+        return ""
+    try:
+        response = client.connected_accounts.list(user_ids=[_require_user_id(user_id)], statuses=["ACTIVE"])
+        raw = _safe_value(response)
+        items = raw.get("items", []) if isinstance(raw, dict) else raw
+        if not isinstance(items, list):
+            items = []
+        wanted = value.casefold()
+        for item in items:
+            if not isinstance(item, dict):
+                continue
+            toolkit_value = item.get("toolkit")
+            if isinstance(toolkit_value, dict):
+                toolkit_value = toolkit_value.get("slug") or toolkit_value.get("name")
+            candidates = [item.get("id"), item.get("nanoid"), item.get("alias"), item.get("name")]
+            if str(toolkit or "").strip() and toolkit.casefold() not in str(toolkit_value or "").casefold():
+                continue
+            if any(str(candidate or "").strip().casefold() == wanted for candidate in candidates):
+                return str(item.get("id") or item.get("nanoid") or value).strip()
+    except Exception:
+        # Preserve the original selector so Composio returns its actionable error.
+        return value
+    return value
+
+
 def discover_tools(api_key: str, user_id: str, query: str, toolkit: str = "") -> list[dict[str, Any]]:
     client = _client(api_key)
     try:
@@ -183,7 +212,7 @@ def parse_arguments(arguments_json: str) -> dict[str, Any]:
     return parsed
 
 
-def execute_upload(api_key: str, user_id: str, slug: str, video_path: str, file_field: str, arguments_json: str = "") -> dict[str, Any]:
+def execute_upload(api_key: str, user_id: str, slug: str, video_path: str, file_field: str, arguments_json: str = "", connected_account_id: str = "") -> dict[str, Any]:
     path = Path(str(video_path or "").strip()).expanduser()
     slug = str(slug or "").strip()
     file_field = str(file_field or "").strip()
@@ -201,13 +230,16 @@ def execute_upload(api_key: str, user_id: str, slug: str, video_path: str, file_
     arguments[file_field] = str(path.resolve())
     client = _client(api_key, upload_dir=path.parent)
     try:
-        result = client.tools.execute(
-            slug,
-            arguments=arguments,
-            user_id=_require_user_id(user_id),
-            version="latest",
-            dangerously_skip_version_check=True,
-        )
+        execute_kwargs: dict[str, Any] = {
+            "arguments": arguments,
+            "user_id": _require_user_id(user_id),
+            "version": "latest",
+            "dangerously_skip_version_check": True,
+        }
+        selected_account = _connected_account_id(client, user_id, "youtube", connected_account_id)
+        if selected_account:
+            execute_kwargs["connected_account_id"] = selected_account
+        result = client.tools.execute(slug, **execute_kwargs)
         response = _response(result)
         if not response["successful"] and not response["error"]:
             response["error"] = f"A ferramenta `{slug}` devolveu uma resposta sem sucesso."

package/integrations/upload_routing.py

@@ -338,6 +338,7 @@ def _composio_upload(settings: dict[str, Any], *, channel: dict[str, Any], **kwa
             str(kwargs.get("video_path") or ""),
             file_field,
             json.dumps(parsed_arguments, ensure_ascii=False),
+            str(settings.get("composio_connected_account_id") or channel.get("composio_connected_account_id") or "").strip(),
         )
     except ComposioUploadError as exc:
         return IntegrationResult(False, str(exc), {})

package/integrations/youtube_upload.py

@@ -8,7 +8,7 @@ from pathlib import Path
 from typing import Any, Callable
 
 from integrations.platforms import IntegrationResult
-from integrations.youtube_batch import loopback_host, loopback_port, loopback_redirect_uri, token_path as batch_token_path
+from integrations.youtube_batch import account_key, loopback_host, loopback_port, loopback_redirect_uri, token_path as batch_token_path
 
 
 # O fluxo de upload precisa apenas do scope de publicação; Analytics e leitura
@@ -27,6 +27,13 @@ def _safe_text(value: Any, default: str = "") -> str:
     return str(value if value is not None else default).strip()
 
 
+def _upload_account_token_path(storage_root: Path, account: dict[str, Any] | None, purpose: str) -> Path | None:
+    if not isinstance(account, dict) or not (account.get("id") or account.get("email")):
+        return None
+    safe_purpose = str(purpose or "upload").strip().lower() or "upload"
+    return Path(storage_root) / "state" / "youtube_upload_tokens" / f"{account_key(account)}-{safe_purpose}.json"
+
+
 def _path_value(value: Any) -> Path | None:
     if isinstance(value, dict):
         value = value.get("path") or value.get("file") or value.get("filepath")
@@ -103,8 +110,16 @@ class _GoogleYouTubeBase:
         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]
+        paths: list[Path] = []
+        account_token = _upload_account_token_path(self.token_path.parents[1], self.account, self.__class__.__name__)
+        if account_token is not None:
+            paths.append(account_token)
+        if not self.account:
+            paths.append(self.token_path)
         if self.account:
+            # Compatibilidade com autorizações de publicação antigas guardadas
+            # no caminho global; o token de leitura/listagem continua separado.
+            paths.append(self.token_path)
             paths.append(batch_token_path(self.token_path.parents[1], self.account))
         if self.alternate_token_path and self.alternate_token_path not in paths:
             paths.append(self.alternate_token_path)
@@ -146,19 +161,20 @@ class _GoogleYouTubeBase:
         return credentials
 
     def _save_credentials(self, credentials: Any, *, nested: bool = False) -> None:
-        self.token_path.parent.mkdir(parents=True, exist_ok=True)
+        destination = _upload_account_token_path(self.token_path.parents[1], self.account, self.__class__.__name__) or self.token_path
+        destination.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 = destination.with_name(f".{destination.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)
+        temporary.replace(destination)
         try:
-            os.chmod(self.token_path, 0o600)
+            os.chmod(destination, 0o600)
         except OSError:
             pass
 
@@ -382,12 +398,12 @@ def upload_youtube_with_fallback(
     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_agent(settings: dict[str, Any], storage_root: Path, *, account: dict[str, Any] | None = None, open_browser: bool = True) -> IntegrationResult:
+    return YouTubeAutomationAgentUploader(settings, storage_root, account=account).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 authorize_youtube_fallback(settings: dict[str, Any], storage_root: Path, *, account: dict[str, Any] | None = None, open_browser: bool = True) -> IntegrationResult:
+    return DirectYouTubeOAuthUploader(settings, storage_root, account=account).authorize(open_browser=open_browser)
 
 
 def youtube_upload_status(settings: dict[str, Any], storage_root: Path) -> dict[str, IntegrationResult]:

package/package.json

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

package/seed/skills/mpt_agent.py

@@ -697,7 +697,7 @@ def ensure_moviepy(root: Path, uv: str) -> None:
             MOVIEPY_REQUIREMENT,
             "python",
             "-c",
-            "import moviepy; assert moviepy.__version__ == '2.2.1'",
+            "import importlib.metadata; print(f\"moviepy {importlib.metadata.version('moviepy')}\")",
         ],
         cwd=root,
     )