@danhachuel/thunderbolt 0.4.55 → 0.4.57

package/MANUAL-INSTALACAO.md

@@ -825,3 +825,13 @@ 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.

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():
@@ -7048,20 +7124,70 @@ def render_settings():
         with st.expander("Contas Google", expanded=False):
             render_google_accounts(include_innertube=False)
         with st.expander("API Innertube", expanded=False):
-            st.caption("INNERTUBE_API_KEY global usada pelo Upload directo para todas as contas Google/YouTube.")
-            upload_innertube = st.text_input("INNERTUBE_API_KEY", value=str(settings.get("direct_innertube_api_key") or settings.get("INNERTUBE_API_KEY") or ""), type="password", key="upload_api_innertube_key")
-            if st.button("Guardar INNERTUBE_API_KEY", type="primary", use_container_width=True, key="upload_save_innertube"):
+            st.markdown("### INNERTUBE_API_KEY")
+            st.caption("Esta é uma chave API global do YouTube: aplica-se a todas as contas Google/YouTube e a todo o sistema. Não é associada a uma conta específica, não faz parte dos documentos de cookies/credenciais e não é editada no separador API Keys.")
+            upload_batch_accounts = [item for item in settings.get("youtube_batch_accounts", []) if isinstance(item, dict) and item.get("id")]
+            current_upload_innertube = str(settings.get("direct_innertube_api_key") or settings.get("INNERTUBE_API_KEY") or "").strip()
+            if not current_upload_innertube:
+                for legacy_account in upload_batch_accounts:
+                    current_upload_innertube = str(legacy_account.get("innertube_api_key") or legacy_account.get("INNERTUBE_API_KEY") or "").strip()
+                    if current_upload_innertube:
+                        break
+                if current_upload_innertube:
+                    settings["direct_innertube_api_key"] = current_upload_innertube
+                    settings.pop("INNERTUBE_API_KEY", None)
+                    for legacy_account in upload_batch_accounts:
+                        legacy_account.pop("innertube_api_key", None)
+                        legacy_account.pop("INNERTUBE_API_KEY", None)
+                    settings["youtube_batch_accounts"] = upload_batch_accounts
+                    write_json("settings.json", settings)
+            innertube_upload_status = st.columns([3.2, 1.2])
+            with innertube_upload_status[0]:
+                st.caption("Estado da chave global")
+            with innertube_upload_status[1]:
+                _render_credential_status(current_upload_innertube)
+            with st.form("upload_innertube_api_key_form"):
+                upload_innertube = st.text_input("INNERTUBE_API_KEY", value=current_upload_innertube, type="password", key="upload_api_innertube_key", help="Chave global usada pelo Upload directo para todas as contas Google/YouTube. Guarde-a na configuração global, separada dos documentos de cookies.")
+                _render_api_test_control(settings, "innertube_upload", lambda: test_innertube_api_key(upload_innertube), widget_key="api_test_innertube_upload")
+                save_upload_innertube = st.form_submit_button("Guardar INNERTUBE_API_KEY global", type="primary", use_container_width=True)
+            if save_upload_innertube:
                 settings["direct_innertube_api_key"] = upload_innertube.strip()
                 settings.pop("INNERTUBE_API_KEY", None)
+                for legacy_account in upload_batch_accounts:
+                    legacy_account.pop("innertube_api_key", None)
+                    legacy_account.pop("INNERTUBE_API_KEY", None)
+                settings["youtube_batch_accounts"] = upload_batch_accounts
                 write_json("settings.json", settings)
-                st.success("INNERTUBE_API_KEY guardada.")
+                st.success("INNERTUBE_API_KEY global guardada para todas as contas Google/YouTube e para todo o sistema.")
                 st.rerun()
         with st.expander("API Tiktok", expanded=False):
             render_tiktok_api_cards(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_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.")
+            _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_api_key": composio_api_key.strip(), "composio_user_id": composio_user_id.strip() or "thunderbolt-local", "composio_toolkit": composio_toolkit.strip()})
+                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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/thunderbolt",
-  "version": "0.4.55",
+  "version": "0.4.57",
   "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();