@danhachuel/thunderbolt 0.4.56 → 0.4.58

package/MANUAL-INSTALACAO.md

@@ -825,3 +825,15 @@ Na interface, uma tarefa em execução mostra a última actividade do helper e o
 A partir da versão 0.3.78, o card **Backlog Vídeos** mostra a causa terminal e disponibiliza **Ver diagnóstico completo**. As mensagens `Pexels key validation completed`, `installing or verifying project dependencies with uv` e `TASK_DIR` são apenas progresso ou metadados; não são, por si só, uma falha.
 
 Se o `uv` falhar, o erro inclui o detalhe seguro do resolver. Se a CLI do MoneyPrinterTurbo falhar, o resumo inclui `MPT_ERROR` e mantém `Log completo` e `Manifesto`. A interface não exibe chaves, cookies ou tokens. O tempo limite da verificação de dependências é de 15 minutos; a etapa é encerrada em vez de ficar indefinidamente sem resposta.
+
+## 18. Upload via Composio
+
+Em **Pipeline Vídeos > Upload > Upload via Composio**, o Thunderbolt permite descobrir ferramentas de upload disponíveis no projecto Composio Platform, seleccionar um toolkit e enviar um vídeo pronto da pipeline. Como cada provider expõe ferramentas e campos diferentes, o slug da ferramenta e o campo que recebe o vídeo são escolhidos explicitamente na interface; nenhum destino é assumido automaticamente.
+
+Configure primeiro **Configurações > Configuração API > API Keys Upload > Composio**. Active a integração, introduza a API key de projecto Composio Platform e defina um `user ID` estável para associar as contas conectadas. A chave permanece no storage local e não é incluída no histórico, nos logs nem no repositório. O botão de teste faz apenas descoberta read-only.
+
+Quando o provider ainda não estiver conectado, use **Autorizar toolkit no Composio**. O Thunderbolt apresenta o Connect Link devolvido pelo Composio; conclua a autorização nesse link e repita o envio. O Thunderbolt não implementa nem armazena um fluxo OAuth próprio.
+
+Antes de clicar em **Enviar vídeo via Composio**, confirme o vídeo, o toolkit, o slug da ferramenta, o campo do ficheiro e os argumentos JSON. O resultado guarda apenas um registo local mínimo com o estado e, quando devolvido, o `log_id` do Composio. URLs presigned, tokens, headers e a API key não são guardados no histórico.
+
+Na **Automação Youtube**, Composio é a rota padrão quando a integração está activa e tem API key, slug da ferramenta e campo do ficheiro configurados. A ordem automática passa a ser **Composio → API Oficial → Upload directo → Postiz**. Se Composio falhar ou não estiver configurado, o worker tenta os fallbacks disponíveis e mantém o comportamento de publicação existente.

package/app/main.py

@@ -98,6 +98,7 @@ from integrations.youtube_batch import account_key as youtube_batch_account_key,
 from integrations.local_runtime import MoneyPrinterRuntime
 from integrations.moneyprinter_config import sync_moneyprinter_config
 from integrations.openai_model_discovery import DEFAULT_NVIDIA_NIM_BASE_URL
+from integrations.composio_upload import ComposioUploadError, authorize_toolkit, discover_tools, execute_upload, parse_arguments, test_configuration
 
 DEFAULT_UI_LANGUAGE = "en"
 
@@ -5302,7 +5303,7 @@ def render_music_upload() -> None:
 
 def render_upload():
     st.title("Upload")
-    upload_tab, direct_tab, postiz_tab, upload_post_tab = render_localized_tabs(["Upload convencional", "Upload directo", "Postiz", "Upload-Post"])
+    upload_tab, direct_tab, postiz_tab, upload_post_tab, composio_tab = render_localized_tabs(["Upload convencional", "Upload directo", "Postiz", "Upload-Post", "Upload via Composio"])
     with direct_tab:
         render_upload_direct()
     with postiz_tab:
@@ -5311,6 +5312,81 @@ def render_upload():
         render_upload_post()
     with upload_tab:
         render_upload_conventional()
+    with composio_tab:
+        render_upload_composio()
+
+
+def render_upload_composio():
+    st.subheader("Upload via Composio")
+    st.caption("Descubra uma ferramenta de upload Composio, ligue a conta do provider quando necessário e envie um vídeo seleccionado. O slug e o campo do ficheiro são sempre escolhidos explicitamente.")
+    settings = read_json("settings.json", {})
+    api_key = str(settings.get("composio_api_key") or "").strip()
+    user_id = str(settings.get("composio_user_id") or "").strip()
+    if not settings.get("composio_enabled", False) or not api_key:
+        st.warning("Composio está desactivado ou sem API key. Configure-o em Configuração API > API Keys Upload > Composio.")
+        return
+    query = st.text_input("Pesquisar ferramenta Composio", value="upload a video file", key="composio_upload_query")
+    toolkit_filter = st.text_input("Toolkit preferido (opcional)", value=str(settings.get("composio_toolkit") or ""), key="composio_upload_toolkit")
+    if st.button("Descobrir ferramentas", key="composio_upload_discover", use_container_width=True):
+        try:
+            st.session_state["composio_upload_tools"] = discover_tools(api_key, user_id, query, toolkit_filter)
+            if not st.session_state["composio_upload_tools"]:
+                st.info("Nenhuma ferramenta encontrada. Tente uma pesquisa mais específica ou deixe o toolkit vazio.")
+            else:
+                st.success(f"{len(st.session_state['composio_upload_tools'])} ferramenta(s) encontrada(s).")
+        except ComposioUploadError as exc:
+            st.error(str(exc))
+    tools = [item for item in st.session_state.get("composio_upload_tools", []) if isinstance(item, dict) and item.get("slug")]
+    if not tools:
+        st.info("Clique em Descobrir ferramentas para carregar os destinos disponíveis na sua conta Composio.")
+        return
+    tool_slugs = [str(item["slug"]) for item in tools]
+    selected_slug = st.selectbox("Ferramenta de upload", tool_slugs, format_func=lambda slug: next((f"{item.get('name') or slug} — {item.get('toolkit') or 'toolkit desconhecido'}" for item in tools if item.get("slug") == slug), slug), key="composio_upload_slug")
+    selected_tool = next((item for item in tools if item.get("slug") == selected_slug), tools[0])
+    if selected_tool.get("description"):
+        st.caption(str(selected_tool["description"]))
+    schema = selected_tool.get("schema") or {}
+    with st.expander("Schema da ferramenta", expanded=False):
+        st.json(schema)
+    file_field = st.text_input("Campo que recebe o vídeo", value=str(st.session_state.get("composio_upload_file_field") or "file"), key="composio_upload_file_field")
+    arguments_json = st.text_area("Argumentos JSON adicionais", value=str(st.session_state.get("composio_upload_arguments") or "{}"), height=150, key="composio_upload_arguments")
+    if st.button("Autorizar toolkit no Composio", key="composio_upload_authorize", use_container_width=True):
+        try:
+            auth = authorize_toolkit(api_key, user_id, str(selected_tool.get("toolkit") or ""))
+            if auth.get("redirect_url"):
+                st.success("Connect Link criado. Abra o link para autorizar a conta e depois repita o envio.")
+                st.markdown(f"[Abrir Connect Link do Composio]({auth['redirect_url']})")
+            else:
+                st.info("O Composio não devolveu um Connect Link; confirme o estado da conta no dashboard.")
+        except ComposioUploadError as exc:
+            st.error(str(exc))
+    tasks = [task for task in read_json("tasks.json", []) if task.get("state") == "done" or task.get("artifacts", {}).get("video")]
+    if not tasks:
+        st.info("Não há vídeos prontos para enviar via Composio.")
+        return
+    task_options = {str(task.get("id")): task for task in tasks if task.get("id")}
+    selected_task_id = st.selectbox("Vídeo", list(task_options), format_func=lambda task_id: f"{task_options[task_id].get('topic') or 'Vídeo Thunderbolt'} — {task_options[task_id].get('artifacts', {}).get('video') or 'sem ficheiro'}", key="composio_upload_task")
+    task = task_options[selected_task_id]
+    video_path = str((task.get("artifacts", {}) or {}).get("video") or "")
+    st.caption(video_path or "Sem caminho de vídeo registado")
+    st.info(f"Resumo: `{selected_slug}` · toolkit `{selected_tool.get('toolkit') or 'não indicado'}` · campo `{file_field or 'não indicado'}`")
+    if st.button("Enviar vídeo via Composio", type="primary", key=f"composio_upload_send_{selected_task_id}", use_container_width=True):
+        try:
+            parse_arguments(arguments_json)
+            result = execute_upload(api_key, user_id, selected_slug, video_path, file_field, arguments_json)
+            record = {"id": uuid.uuid4().hex, "task_id": task.get("id"), "destination": "Composio", "target": {"toolkit": selected_tool.get("toolkit"), "slug": selected_slug, "file_field": file_field}, "status": "published" if result.get("successful") else "failed", "message": result.get("error") or "Upload Composio concluído.", "data": result.get("data") or {}, "log_id": result.get("log_id") or "", "created_at": now()}
+            uploads = read_json("uploads.json", [])
+            uploads.append(record)
+            write_json("uploads.json", uploads)
+            reconcile_persisted_notifications()
+            if result.get("successful"):
+                st.success(record["message"])
+            else:
+                st.error(record["message"])
+            if result.get("log_id"):
+                st.caption(f"Composio log ID: {result['log_id']}")
+        except ComposioUploadError as exc:
+            st.error(str(exc))
 
 
 def render_upload_postiz():
@@ -7089,7 +7165,33 @@ def render_settings():
         with st.expander("API Bilibili", expanded=False):
             render_bilibili_api_cards(settings)
         with st.expander("Composio", expanded=False):
-            st.info("Secção reservada para uma futura integração Composio.")
+            st.caption("A API key é guardada apenas no storage local. O slug da ferramenta e o provider são descobertos no Upload via Composio; a autenticação da conta é feita pelo Connect Link do Composio.")
+            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_toolkit = st.text_input("Toolkit preferido (opcional)", value=str(settings.get("composio_toolkit") or ""), key="upload_composio_toolkit", help="Deixe vazio para descobrir ferramentas em todos os toolkits.")
+            composio_tool_slug = st.text_input("Slug da ferramenta para Automação Youtube", value=str(settings.get("composio_tool_slug") or ""), key="upload_composio_tool_slug", help="Depois de descobrir uma ferramenta em Upload via Composio, copie aqui o slug para a Automação Youtube.")
+            composio_file_field = st.text_input("Campo do ficheiro na ferramenta", value=str(settings.get("composio_file_field") or "file"), key="upload_composio_file_field")
+            composio_arguments_json = st.text_area("Argumentos JSON da Automação Youtube", value=str(settings.get("composio_arguments_json") or "{}"), key="upload_composio_arguments_json", height=120)
+            _render_credential_status(composio_api_key)
+            composio_action_cols = st.columns(2)
+            with composio_action_cols[0]:
+                save_composio = st.button("Guardar Composio", type="primary", use_container_width=True, key="upload_composio_save")
+            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.strip(), "composio_tool_slug": composio_tool_slug.strip(), "composio_file_field": composio_file_field.strip() or "file", "composio_arguments_json": composio_arguments_json.strip() or "{}"})
+                write_json("settings.json", settings)
+                st.success("Configuração Composio guardada.")
+                st.rerun()
+            if test_composio:
+                try:
+                    result = test_configuration(composio_api_key, composio_user_id)
+                    found = len((result.get("data") or {}).get("tools", []))
+                    st.success(f"Configuração Composio válida; {found} ferramenta(s) de upload encontradas.")
+                except ComposioUploadError as exc:
+                    st.error(str(exc))
         with st.expander("Upload-Post", expanded=False):
             upload_post_enabled_upload = st.checkbox("Activar Upload-Post", bool(settings.get("upload_post_enabled", False)), key="upload_tab_upload_post_enabled")
             upload_post_key_upload = st.text_input("Upload-Post API key", value=str(settings.get("upload_post_api_key") or ""), type="password", key="upload_tab_upload_post_key")

package/hermes_ui/pipeline_worker.py

@@ -1474,9 +1474,10 @@ def _run_task(task: dict[str, Any]) -> dict[str, Any]:
         return _update(task_id, stage="upload", state="done", progress=100, artifacts=artifacts, video_ready=True, error=None)
 
     configured_account_id = str(channel.get("google_account_id") or "").strip()
+    configured_composio = bool(settings.get("composio_enabled", False)) and bool(settings.get("composio_auto_upload", True)) and bool(settings.get("composio_api_key")) and bool(settings.get("composio_tool_slug"))
     configured_upload_post = bool(settings.get("upload_post_enabled", False)) and bool(settings.get("upload_post_auto_upload", False))
     configured_postiz = bool(settings.get("postiz_enabled", False)) and bool(settings.get("postiz_auto_publish", False))
-    if not (configured_account_id or configured_upload_post or configured_postiz):
+    if not (configured_composio or configured_account_id or configured_upload_post or configured_postiz):
         artifacts["upload"] = {
             "route": "local",
             "status": "skipped",

package/hermes_ui/storage.py

@@ -287,6 +287,14 @@ DEFAULTS: dict[str, Any] = {
         "upload_post_username": "",
         "upload_post_platforms": "tiktok,instagram",
         "upload_post_auto_upload": False,
+        "composio_enabled": True,
+        "composio_auto_upload": True,
+        "composio_api_key": "",
+        "composio_user_id": "thunderbolt-local",
+        "composio_toolkit": "",
+        "composio_tool_slug": "",
+        "composio_file_field": "file",
+        "composio_arguments_json": "{}",
         "postiz_enabled": False,
         "postiz_api_key": "",
         "postiz_base_url": "https://api.postiz.com/public/v1",

package/integrations/composio_upload.py

@@ -0,0 +1,174 @@
+"""Composio Platform adapter for user-selected video upload tools."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+class ComposioUploadError(ValueError):
+    """Safe, user-facing validation or integration error."""
+
+
+def _safe_value(value: Any) -> Any:
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    if isinstance(value, dict):
+        return {str(key): _safe_value(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_safe_value(item) for item in value]
+    for method in ("model_dump", "to_dict", "dict"):
+        converter = getattr(value, method, None)
+        if callable(converter):
+            try:
+                return _safe_value(converter())
+            except Exception:
+                pass
+    attributes = getattr(value, "__dict__", None)
+    if isinstance(attributes, dict):
+        return {str(key): _safe_value(item) for key, item in attributes.items()}
+    return str(value)
+
+
+def _tool_item(tool: Any) -> dict[str, Any]:
+    raw = _safe_value(tool)
+    if isinstance(raw, dict) and isinstance(raw.get("function"), dict):
+        function = raw["function"]
+        return {
+            "slug": str(function.get("name") or raw.get("name") or ""),
+            "name": str(function.get("name") or raw.get("name") or ""),
+            "description": str(function.get("description") or raw.get("description") or ""),
+            "toolkit": str(raw.get("toolkit") or ""),
+            "schema": function.get("parameters") or {},
+        }
+    if isinstance(raw, dict):
+        toolkit = raw.get("toolkit")
+        if isinstance(toolkit, dict):
+            toolkit = toolkit.get("slug") or toolkit.get("name") or ""
+        return {
+            "slug": str(raw.get("slug") or raw.get("name") or ""),
+            "name": str(raw.get("name") or raw.get("slug") or ""),
+            "description": str(raw.get("description") or ""),
+            "toolkit": str(toolkit or ""),
+            "schema": raw.get("input_parameters") or raw.get("parameters") or {},
+        }
+    return {"slug": "", "name": "", "description": "", "toolkit": "", "schema": {}}
+
+
+def _response(result: Any) -> dict[str, Any]:
+    raw = _safe_value(result)
+    if not isinstance(raw, dict):
+        raw = {"data": raw}
+    error = raw.get("error")
+    return {
+        "successful": not bool(error),
+        "data": raw.get("data") or {},
+        "error": str(error) if error else "",
+        "log_id": str(raw.get("log_id") or raw.get("request_id") or ""),
+    }
+
+
+def _require_api_key(api_key: str) -> str:
+    value = str(api_key or "").strip()
+    if len(value) < 10 or value.lower() in {"placeholder", "your_composio_api_key"}:
+        raise ComposioUploadError("Configure uma API key válida do Composio em Configuração API > API Keys Upload > Composio.")
+    return value
+
+
+def _require_user_id(user_id: str) -> str:
+    value = str(user_id or "").strip()
+    if not value:
+        raise ComposioUploadError("Indique um Composio user ID estável antes de continuar.")
+    return value
+
+
+def _client(api_key: str, *, upload_dir: Path | None = None):
+    try:
+        from composio import Composio
+    except ImportError as exc:
+        raise ComposioUploadError("A SDK Python composio não está instalada. Execute a instalação do Thunderbolt novamente.") from exc
+    kwargs: dict[str, Any] = {"api_key": _require_api_key(api_key), "allow_tracking": False}
+    if upload_dir is not None:
+        kwargs.update({
+            "dangerously_allow_auto_upload_download_files": True,
+            "file_upload_dirs": [str(upload_dir.resolve())],
+        })
+    return Composio(**kwargs)
+
+
+def discover_tools(api_key: str, user_id: str, query: str, toolkit: str = "") -> list[dict[str, Any]]:
+    client = _client(api_key)
+    try:
+        tools = client.tools.get(
+            _require_user_id(user_id),
+            search=(query or "upload a video file").strip(),
+            toolkits=[toolkit.strip()] if toolkit.strip() else None,
+            limit=10,
+        )
+        return [item for item in (_tool_item(tool) for tool in tools) if item.get("slug")]
+    except ComposioUploadError:
+        raise
+    except Exception as exc:
+        raise ComposioUploadError(f"Não foi possível descobrir ferramentas Composio: {type(exc).__name__}: {exc}") from exc
+
+
+def authorize_toolkit(api_key: str, user_id: str, toolkit: str) -> dict[str, Any]:
+    toolkit = str(toolkit or "").strip()
+    if not toolkit:
+        raise ComposioUploadError("Seleccione uma ferramenta descoberta para saber qual toolkit deve ser autorizado.")
+    client = _client(api_key)
+    try:
+        request = client.create(user_id=_require_user_id(user_id)).authorize(toolkit)
+        return {"connected_account_id": str(getattr(request, "id", "") or ""), "redirect_url": str(getattr(request, "redirect_url", "") or "")}
+    except ComposioUploadError:
+        raise
+    except Exception as exc:
+        raise ComposioUploadError(f"Não foi possível criar o Connect Link do Composio: {type(exc).__name__}: {exc}") from exc
+
+
+def parse_arguments(arguments_json: str) -> dict[str, Any]:
+    try:
+        parsed = json.loads(arguments_json or "{}")
+    except json.JSONDecodeError as exc:
+        raise ComposioUploadError(f"Os argumentos da ferramenta não são JSON válido: {exc.msg}.") from exc
+    if not isinstance(parsed, dict):
+        raise ComposioUploadError("Os argumentos da ferramenta devem ser um objecto JSON.")
+    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]:
+    path = Path(str(video_path or "").strip()).expanduser()
+    slug = str(slug or "").strip()
+    file_field = str(file_field or "").strip()
+    if not path.is_file():
+        raise ComposioUploadError("O ficheiro de vídeo seleccionado não existe ou não é um ficheiro.")
+    if path.stat().st_size <= 0:
+        raise ComposioUploadError("O ficheiro de vídeo seleccionado está vazio.")
+    if not slug:
+        raise ComposioUploadError("Seleccione ou indique o slug de uma ferramenta Composio.")
+    if not file_field:
+        raise ComposioUploadError("Indique o campo de argumentos que recebe o ficheiro.")
+    arguments = parse_arguments(arguments_json)
+    if file_field in arguments and arguments[file_field] not in (None, "", str(path)):
+        raise ComposioUploadError(f"O campo `{file_field}` já contém um valor. Remova-o antes de injectar o vídeo.")
+    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,
+        )
+        return _response(result)
+    except ComposioUploadError:
+        raise
+    except Exception as exc:
+        safe_message = str(exc).replace(str(api_key), "[REDACTED]")
+        raise ComposioUploadError(f"A ferramenta Composio falhou: {type(exc).__name__}: {safe_message}") from exc
+
+
+def test_configuration(api_key: str, user_id: str) -> dict[str, Any]:
+    tools = discover_tools(api_key, user_id, "upload a video file")
+    return {"successful": True, "data": {"tools": tools}, "error": "", "log_id": ""}

package/integrations/upload_routing.py

@@ -1,9 +1,10 @@
 """Ordered YouTube upload routing for Thunderbolt.
 
 The route is intentionally deterministic:
-1. Official YouTube API, up to five successful sends per Google account/day.
-2. Internal browser-session upload, when the account document is complete.
-3. Postiz, when configured with an API key and integration ID.
+1. Composio, when the configured upload tool is available.
+2. Official YouTube API, up to five successful sends per Google account/day.
+3. Internal browser-session upload, when the account document is complete.
+4. Postiz, when configured with an API key and integration ID.
 """
 
 from __future__ import annotations
@@ -17,6 +18,7 @@ from integrations.postiz import PostizAdapter
 from integrations.session_info_health import check_account_session_info_health, emit_session_info_health_alerts
 from integrations.youtube_direct_credentials import document_status
 from integrations.youtube_direct_upload import YouTubeDirectUploader
+from integrations.composio_upload import ComposioUploadError, execute_upload
 from hermes_ui.storage import read_json, write_json
 
 OFFICIAL_DAILY_LIMIT = 5
@@ -91,8 +93,32 @@ def upload_with_default_route(
     official_uploader: Callable[..., IntegrationResult] | None = None,
     direct_uploader: Callable[..., IntegrationResult] | None = None,
     postiz_publisher: Callable[..., IntegrationResult] | None = None,
+    composio_publisher: Callable[..., IntegrationResult] | None = None,
 ) -> IntegrationResult:
     attempts: list[dict[str, Any]] = []
+    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:
+        composio_result = IntegrationResult(False, "Composio está activo, mas falta API key ou slug da ferramenta de upload.", {})
+        attempts.append(_attempt_record("Composio", composio_result, skipped=True))
+    elif composio_ready:
+        composio_publisher = composio_publisher or _composio_upload
+        try:
+            composio_result = composio_publisher(
+                settings,
+                video_path=video_path,
+                title=title,
+                description=description,
+                tags=tags or [],
+                thumbnail_path=thumbnail_path,
+                captions_path=captions_path,
+            )
+        except Exception as exc:
+            composio_result = IntegrationResult(False, f"Composio falhou: {type(exc).__name__}: {exc}", {})
+        attempts.append(_attempt_record("Composio", composio_result))
+        if composio_result.ok:
+            return _result_with_attempts(composio_result, attempts, "Composio")
+
     quota_count = official_upload_count(channel, account)
     if quota_count >= OFFICIAL_DAILY_LIMIT:
         quota_result = IntegrationResult(False, f"Limite local de {OFFICIAL_DAILY_LIMIT} envios oficiais por conta Google atingido hoje; a tentar o próximo método.", {"count": quota_count, "limit": OFFICIAL_DAILY_LIMIT})
@@ -184,3 +210,22 @@ def upload_with_default_route(
             return _result_with_attempts(postiz_result, attempts, "Postiz")
 
     return IntegrationResult(False, "Nenhum método de envio conseguiu publicar o vídeo.", {"attempts": attempts, "route": "none"})
+
+
+def _composio_upload(settings: dict[str, Any], **kwargs: Any) -> IntegrationResult:
+    try:
+        result = execute_upload(
+            str(settings.get("composio_api_key") or ""),
+            str(settings.get("composio_user_id") or ""),
+            str(settings.get("composio_tool_slug") or ""),
+            str(kwargs.get("video_path") or ""),
+            str(settings.get("composio_file_field") or "file"),
+            str(settings.get("composio_arguments_json") or "{}"),
+        )
+    except ComposioUploadError as exc:
+        return IntegrationResult(False, str(exc), {})
+    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 ""},
+    )

package/package.json

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

package/requirements.txt

@@ -22,3 +22,4 @@ kagglehub>=0.3,<1
 supabase>=2.4,<3
 bilibili-api-python>=17.4,<18
 playwright>=1.45,<2
+composio>=0.21,<1

package/scripts/cli.mjs

@@ -116,7 +116,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", "edge_tts", "sklearn", "mlxtend", "plotly", "seaborn", "kagglehub"];
+  const requiredModules = ["streamlit", "requests", "pandas", "toml", "imageio_ffmpeg", "edge_tts", "sklearn", "mlxtend", "plotly", "seaborn", "kagglehub", "composio"];
   const missing = requiredModules.filter((moduleName) => !moduleAvailable(moduleName));
   const ffmpeg = moduleAvailable("imageio_ffmpeg");
   const mptPath = configuredMoneyPrinterPath();