@danhachuel/thunderbolt 0.2.76 → 0.2.77

package/MANUAL-INSTALACAO.md

@@ -100,13 +100,13 @@ Execute:
 Windows PowerShell ou MobaXterm:
 
 ```powershell
-npx.cmd --yes @danhachuel/thunderbolt@0.2.76 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.77 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes @danhachuel/thunderbolt@0.2.76 install
+npx --yes @danhachuel/thunderbolt@0.2.77 install
 ```
 
 A instalação normal é **segura para actualizações**: preserva `storage`, Blueprints, Brandings, configurações e artefactos do utilizador. Remove apenas `.venv`, o clone técnico do MoneyPrinterTurbo e dependências que serão recriadas. Uma pasta antiga sem dados do utilizador, como `C:\Users\<utilizador>\AppData\Local\hermes` da tentativa incompleta, pode ser removida; uma pasta antiga que contenha Blueprints, Brandings ou storage é preservada e apenas avisada no terminal. Feche processos Python, Node, Streamlit e MobaXterm que estejam a usar as pastas antes de executar.
@@ -436,7 +436,7 @@ Ao abrir a página, o Thunderbolt não prepara dados públicos, não descarrega
 
 Os parâmetros da UI são número de clusters entre 2 e 10, suporte mínimo entre 0,01 e 0,50, país, engagement, intervalo de datas e tags, todos dentro da área principal da aba. O núcleo normaliza os dados, calcula engagement, aplica filtros, faz transformação logarítmica e standardização, executa K-Means e calcula itemsets/regras com FP-Growth. Não são apresentados resultados até ao primeiro clique em **Analisar Nichos**; o mesmo botão aplica alterações posteriores aos filtros. Os resultados são DataFrames de clusters, itemsets frequentes, regras de associação e dados analisados; o gráfico de dispersão é criado nativamente com Plotly.
 
-As dependências adicionais — `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub` — são instaladas pelo procedimento normal de `npx`. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.76 install`; o instalador detecta e reutiliza o que já estiver válido.
+As dependências adicionais — `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub` — são instaladas pelo procedimento normal de `npx`. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.77 install`; o instalador detecta e reutiliza o que já estiver válido.
 
 ### Niche Finder Apify
 
@@ -478,16 +478,24 @@ A aba **Automação Youtube**, dentro do menu expansível **Automação**, lista
 
 A área **Teste de vozes**, dentro de **Configurações > Configuração API**, é isolada da pipeline. O preview pode ser reproduzido e descarregado de `storage/voice_previews/`. Caminhos vazios, directórios, ficheiros vazios e previews sem permissões de leitura são ignorados com uma mensagem clara, sem traceback. Se uma instalação antiga mostrar que `edge-tts` está em falta, execute `npx.cmd --yes @danhachuel/thunderbolt install`; o detector reinstala apenas a dependência ausente.
 
-## Upload, Postiz e Upload directo
+## Upload, Postiz, Upload-Post e Upload directo
 
 A subaba **Postiz**, dentro de **Upload**, permite carregar as integrações Postiz, seleccionar o canal ligado e enviar vídeos MP4 através da Public API. Configure **Activar Postiz como fallback final**, **Postiz API key**, **Postiz Public API Base URL**, **Postiz MCP URL** e, opcionalmente, o ID da integração padrão em **Configuração API > API Keys > Serviços e modelos**. A API key é enviada como valor bruto do cabeçalho `Authorization`; o upload usa `POST /upload` e a publicação usa `POST /posts`.
 
-O botão de envio YouTube segue a ordem fixa **1. API Oficial, 2. Upload directo, 3. Postiz**. A API Oficial regista no storage local até cinco envios bem-sucedidos por dia por conta Gmail. Quando a quota é atingida ou o método falha, o Thunderbolt valida o `credentials.json` e tenta o Upload directo. Postiz só é tentado como último recurso e apenas quando está activo, com API key e integração válida.
+O botão de envio YouTube segue a ordem fixa **1. API Oficial, 2. Upload directo, 3. Postiz**. O **Upload-Post** é uma quarta subaba independente e não altera essa rota automática do YouTube. A API Oficial regista no storage local até cinco envios bem-sucedidos por dia por conta Gmail. Quando a quota é atingida ou o método falha, o Thunderbolt valida o `credentials.json` e tenta o Upload directo. Postiz só é tentado como último recurso e apenas quando está activo, com API key e integração válida.
 
 Em **Configurações > Contas Google**, cada conta aparece como um expander identificado por nome e e-mail. Dentro dele existe o uploader **Subir documento de cookies/credenciais** e o input **sessionInfo token desta conta Google**. O documento JSON único contém cookies, INNERTUBE_API_KEY, chunk_size e o mapa de IDs delegados por canal; o sessionInfo preenchido na conta é sincronizado no mesmo ficheiro, guardado em `storage/youtube_direct_accounts/<id-da-conta>/credentials.json`.
 
 Em **Canais Youtube > Canais cadastrados**, a secção **Upload directo — documento da conta deste canal** mostra apenas a conta Google associada e confirma se o documento contém o ID delegado desse canal. O `DELEGATED_SESSION_ID` permanece exclusivamente no mapa do documento; o upload bloqueia a operação se faltar qualquer elemento técnico.
 
+### Upload-Post
+
+A subaba **Upload-Post** usa a API oficial do [Upload-Post](https://docs.upload-post.com/) para publicar vídeos prontos em uma ou mais plataformas ligadas ao perfil configurado. Em **Configuração API > API Keys > Serviços e modelos > Publicação através do Upload-Post**, active a integração, guarde a API key, o username/perfil e as plataformas padrão. Depois abra **Upload > Upload-Post**, confirme ou altere as plataformas, escreva o título e a descrição e clique em **Enviar vídeo pelo Upload-Post**.
+
+A credencial não é duplicada na página de Upload. A integração envia o ficheiro local como `video` em `multipart/form-data`, usa `platform[]` repetido para cada destino e autentica com `Authorization: Apikey ...`. **Processar em segundo plano** envia `async_upload=true`; quando a API devolver `request_id`, este fica visível e é guardado em `uploads.json`. O histórico local também alimenta a notificação **Upload-Post concluído**. O Upload-Post é distinto do Postiz: não usa os endpoints nem a selecção de integrações do Postiz.
+
+### Upload directo
+
 A subaba **Upload directo** adapta o [YouTube-Video-Upload-Frontend-Api](https://github.com/Nojus10/YouTube-Video-Upload-Frontend-Api). Cada conta Google tem um único `credentials.json`, criado automaticamente ao adicionar a conta, com cookies, sessionInfo, INNERTUBE_API_KEY, chunk_size e `delegated_session_ids` por canal. O uploader aceita um documento JSON completo ou parcial; o merge actualiza somente os valores presentes e preserva os restantes. O documento é guardado fora de `storage/state/`, com permissões locais restritas.
 
 Associe cada canal à conta Google correcta em **Canais Youtube**; não introduza o ID delegado na UI. A associação do canal é permitida mesmo que o documento esteja incompleto. No momento do upload, o Thunderbolt lê o documento da conta, encontra o `DELEGATED_SESSION_ID` pela chave do canal e bloqueia apenas a operação se faltar conta, documento válido, cookies, sessionInfo, INNERTUBE_API_KEY, ID delegado ou vídeo elegível. O tamanho de chunk é normalizado para múltiplos de 262144 bytes. O método é uma integração não oficial de sessão do YouTube; não extraia cookies automaticamente, não os coloque no repositório e não os partilhe.

package/README.md

@@ -25,6 +25,14 @@ A primeira versão implementa a camada UI independente com:
 | Configurações | **Contas Google**, **Configuração API** e **Notificações**; API Keys divididas entre **Serviços e modelos** e **Fontes de materiais**, com várias chaves independentes por fonte, além de contas Google/YouTube por cartão, `INNERTUBE_API_KEY` no documento da conta, providers, TTS, Nano Banana, Postiz, TikTok e Upload-Post |
 | Launcher | Execução via `npx`, instalação assistida, diagnóstico e preparação para distribuição |
 
+## Upload-Post — publicação para múltiplas plataformas
+
+A página **Upload** contém quatro subabas: **Upload convencional**, **Upload directo**, **Postiz** e **Upload-Post**. A quarta alternativa usa a API oficial do [Upload-Post](https://docs.upload-post.com/) para enviar um vídeo local para uma ou mais plataformas ligadas ao perfil configurado. Seleccione as plataformas na própria subaba, confirme o título e a descrição e clique em **Enviar vídeo pelo Upload-Post**.
+
+A API key, o username/perfil e a lista inicial de plataformas continuam em **Configuração API > API Keys > Serviços e modelos**, no expander **Publicação através do Upload-Post**. A subaba não pede novamente a credencial. O cliente envia `multipart/form-data` para `https://api.upload-post.com/api/upload`, repete `platform[]` para cada destino e guarda a resposta, o `request_id` e o resultado no histórico local de uploads. A opção **Processar em segundo plano** usa `async_upload=true` quando a API estiver configurada para processamento assíncrono.
+
+O Upload-Post é independente do Postiz: Postiz continua a usar o seu fluxo próprio de asset + post, enquanto Upload-Post publica directamente nas plataformas ligadas ao username configurado. Uma publicação aceite pelo Upload-Post também é reconciliada no centro de **Notificações**.
+
 ## Upload directo — credenciais por conta e por canal
 
 O Upload directo baseado no [YouTube-Video-Upload-Frontend-Api](https://github.com/Nojus10/YouTube-Video-Upload-Frontend-Api) usa um único documento JSON por conta Google. Em **Configurações > Contas Google > Contas Google/YouTube — canais em lote**, cada conta aparece como um cartão expansível identificado por **nome — e-mail**. Dentro do cartão existe o uploader **Subir documento de cookies/credenciais** e o único campo técnico permitido na UI, **sessionInfo token desta conta Google**. Cookies, `INNERTUBE_API_KEY`, `chunk_size` e `delegated_session_ids` continuam exclusivamente no documento.
@@ -38,7 +46,7 @@ Os dados são segredos de sessão. Os valores não aparecem em tabelas ou logs,
 
 Os adaptadores do MoneyPrinterTurbo e de publicação nas plataformas são ligados pelas configurações locais e pelos pontos de integração em `integrations/`. A UI não inventa dados quando um serviço externo ou credencial não está disponível.
 
-## Navegação da UI 0.2.76
+## Navegação da UI 0.2.77
 
 A barra lateral mantém os níveis principais, nesta ordem: **Início**, **Niche Finder**, **Pipeline**, **Pipeline TikTok**, **Automação**, **Edição**, **AI Influencers** e **Configurações**. **Pipeline** é expansível e contém **Criação de Vídeos**, **Criação de Músicas**, **Roteiros** e **Upload**. **Automação** também é expansível e contém **Automação Youtube**. **Edição** é expansível e contém **Limpador de Metadados**, **Cortes**, **Editor Python** e **Download Mídia**, nessa ordem. **AI Influencers** é expansível e contém **Personagens**, **Redes Sociais** e **Tutorial Meta**, nessa ordem. **Niche Finder** é expansível e contém **Niche Finder Kaggle** e **Niche Finder Apify**. **Configurações** é expansível e contém **Canais Youtube**, **Blueprints Youtube**, **MCP**, **Contas Google**, **Configuração API** e **Notificações**. O Início reúne o dashboard e as filas do Pipeline, sem botões de acções rápidas.
 
@@ -169,9 +177,9 @@ thunderbolt
 No Windows PowerShell, se `npx` for bloqueado por `npx.ps1`, use directamente `npx.cmd`:
 
 ```powershell
-npx.cmd --yes @danhachuel/thunderbolt@0.2.76 install
-npx.cmd --yes @danhachuel/thunderbolt@0.2.76 doctor
-npx.cmd --yes @danhachuel/thunderbolt@0.2.76
+npx.cmd --yes @danhachuel/thunderbolt@0.2.77 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.77 doctor
+npx.cmd --yes @danhachuel/thunderbolt@0.2.77
 ```
 
 Como alternativa, pode permitir scripts para o seu utilizador:
@@ -195,7 +203,7 @@ O menu expansível **Niche Finder** contém duas alternativas independentes. **N
 
 A interface apresenta dentro da aba os parâmetros da busca: número de clusters entre 2 e 10, suporte mínimo entre 0,01 e 0,50, país, categoria de engagement, intervalo de datas e tags. A página permanece sem resultados até o primeiro clique em **Analisar Nichos**; depois, se os parâmetros forem alterados, mostra os resultados anteriores e pede novo clique para aplicar os filtros actuais. O núcleo aplica normalização, filtros, `log1p`, `StandardScaler`, K-Means e FP-Growth. Os resultados aparecem em DataFrames para clusters, itemsets frequentes, regras de associação e dados analisados, acompanhados por uma visualização Plotly nativa e pesquisa de palavras nos clusters.
 
-**Niche Finder Apify** é a segunda alternativa e não usa o dataset, filtros, execução ou resultados Kaggle. Define três palavras-chave, período, limite de resultados, Shorts, duração, idioma de legendas e ordenação; depois de clicar em **Pesquisar no Apify**, inicia o actor `streamers~youtube-scraper`, acompanha o run, carrega o dataset, normaliza vídeos, limpa SRT, calcula VSC Ratio e tenta resumir as transcrições com o provider LLM configurado. Os resultados ficam na sessão própria `niche_apify_results`, o histórico pequeno fica em `storage/state/niche_apify_runs.json` e existem exportações JSON/CSV. Configure o **Apify API Token** em **Configuração API > API Keys > Serviços e modelos**. As dependências adicionais são instaladas pelo fluxo normal do pacote: `requests`, `pandas` e os componentes já existentes da análise. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.76 install`; o instalador detecta e reutiliza componentes já válidos.
+**Niche Finder Apify** é a segunda alternativa e não usa o dataset, filtros, execução ou resultados Kaggle. Define três palavras-chave, período, limite de resultados, Shorts, duração, idioma de legendas e ordenação; depois de clicar em **Pesquisar no Apify**, inicia o actor `streamers~youtube-scraper`, acompanha o run, carrega o dataset, normaliza vídeos, limpa SRT, calcula VSC Ratio e tenta resumir as transcrições com o provider LLM configurado. Os resultados ficam na sessão própria `niche_apify_results`, o histórico pequeno fica em `storage/state/niche_apify_runs.json` e existem exportações JSON/CSV. Configure o **Apify API Token** em **Configuração API > API Keys > Serviços e modelos**. As dependências adicionais são instaladas pelo fluxo normal do pacote: `requests`, `pandas` e os componentes já existentes da análise. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.77 install`; o instalador detecta e reutiliza componentes já válidos.
 
 ## Editor Python baseado no PYEdit
 

package/app/main.py

@@ -45,6 +45,7 @@ from hermes_ui.creative_generation import CreativeGenerationError, generate_crea
 from integrations.platforms import IntegrationResult, TikTokAdapter, YouTubeAdapter, fetch_channel_videos_public
 from integrations.tiktok_public import fetch_public_tiktok_profile, normalize_tiktok_reference
 from integrations.postiz import PostizAdapter
+from integrations.upload_post import UploadPostAdapter, UPLOAD_POST_PLATFORM_OPTIONS, normalize_upload_post_platforms
 from integrations.upload_routing import OFFICIAL_DAILY_LIMIT, official_upload_count, 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
@@ -2722,11 +2723,13 @@ def render_upload_direct():
 
 def render_upload():
     st.title("Upload")
-    upload_tab, direct_tab, postiz_tab = st.tabs(["Upload convencional", "Upload directo", "Postiz"])
+    upload_tab, direct_tab, postiz_tab, upload_post_tab = st.tabs(["Upload convencional", "Upload directo", "Postiz", "Upload-Post"])
     with direct_tab:
         render_upload_direct()
     with postiz_tab:
         render_upload_postiz()
+    with upload_post_tab:
+        render_upload_post()
     with upload_tab:
         render_upload_conventional()
 
@@ -2808,6 +2811,78 @@ def render_upload_postiz():
                 (st.success if result.ok else st.error)(result.message)
 
 
+def render_upload_post():
+    st.subheader("Upload-Post")
+    st.caption("Envie um vídeo para uma ou mais plataformas ligadas ao seu perfil Upload-Post. A API key é lida da Configuração API e nunca é mostrada nesta aba.")
+    settings = read_json("settings.json", {})
+    uploader = UploadPostAdapter(settings)
+    status = uploader.status()
+    if not status.ok:
+        st.warning(status.message)
+        if not uploader.enabled:
+            st.info("Active Upload-Post em Configuração API > API Keys > Serviços e modelos e guarde a configuração.")
+        elif not uploader.api_key:
+            st.info("Introduza a API key do Upload-Post em Configuração API > API Keys > Serviços e modelos.")
+        return
+
+    configured_platforms = normalize_upload_post_platforms(uploader.platforms)
+    selected_platforms = st.multiselect(
+        "Plataformas Upload-Post",
+        list(UPLOAD_POST_PLATFORM_OPTIONS),
+        default=configured_platforms,
+        format_func=lambda value: "Facebook Pages" if value == "facebook" else "X (Twitter)" if value == "x" else value.title(),
+        key="upload_post_platforms_selector",
+        help="Seleccione uma ou mais plataformas já ligadas ao perfil Upload-Post.",
+    )
+    async_upload = st.checkbox(
+        "Processar em segundo plano",
+        value=False,
+        key="upload_post_async_upload",
+        help="Envia async_upload=true para a API e mostra o request ID devolvido, quando existir.",
+    )
+    if not selected_platforms:
+        st.info("Seleccione pelo menos uma plataforma antes de publicar.")
+
+    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 pelo Upload-Post.")
+        return
+    for task in tasks:
+        artifacts = task.get("artifacts", {}) or {}
+        video_path = artifacts.get("video", "")
+        with st.container(border=True):
+            st.write(f"**{task.get('topic', 'Vídeo Thunderbolt')}** — {uploader.username}")
+            st.caption(video_path or "Sem caminho de vídeo registado")
+            title = st.text_input("Título Upload-Post", value=task.get("title") or task.get("topic", "Vídeo Thunderbolt"), key=f"upload_post_title_{task['id']}")
+            description = st.text_area("Descrição Upload-Post", value=task.get("description", ""), key=f"upload_post_description_{task['id']}", height=90)
+            if st.button("Enviar vídeo pelo Upload-Post", type="primary", key=f"upload_post_send_{task['id']}", disabled=not selected_platforms):
+                result = uploader.upload_video(
+                    video_path,
+                    title=title,
+                    description=description,
+                    user=uploader.username,
+                    platforms=selected_platforms,
+                    async_upload=async_upload,
+                )
+                record = {
+                    "id": uuid.uuid4().hex,
+                    "task_id": task.get("id"),
+                    "destination": "Upload-Post",
+                    "target": {"username": uploader.username, "platforms": selected_platforms},
+                    "status": "published" if result.ok else "failed",
+                    "message": result.message,
+                    "data": result.data,
+                    "created_at": now(),
+                }
+                uploads = read_json("uploads.json", [])
+                uploads.append(record)
+                write_json("uploads.json", uploads)
+                reconcile_persisted_notifications()
+                (st.success if result.ok else st.error)(result.message)
+                if result.ok and result.data.get("request_id"):
+                    st.caption(f"Request ID Upload-Post: {result.data['request_id']}")
+
+
 UPLOAD_DESTINATION_TARGET_KEYS = {
     "TikTok": "tiktok_accounts",
     "Instagram": "instagram_profiles",

package/app/modules/niche_finder/apify.py

@@ -37,7 +37,7 @@ def _json_response(response: requests.Response, action: str) -> Any:
 def _headers(token: str) -> dict[str, str]:
     token = str(token or "").strip()
     if not token:
-        raise ApifyError("Configure o Apify API Token em Configurações Técnicas antes de iniciar.")
+        raise ApifyError("Configure o Apify API Token em Configuração API > API Keys > Serviços e modelos antes de iniciar.")
     return {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
 
 

package/hermes_ui/creative_generation.py

@@ -38,15 +38,15 @@ def _provider_config(settings: dict[str, Any]) -> tuple[str, str, str, str]:
         base_url = base_url or "http://127.0.0.1:11434/v1"
     if not base_url:
         raise CreativeGenerationError(
-            f"O provider LLM '{provider}' não tem Base URL configurada em Configurações Técnicas > API Keys."
+            f"O provider LLM '{provider}' não tem Base URL configurada em Configuração API > API Keys > Serviços e modelos."
         )
     if not model:
         raise CreativeGenerationError(
-            f"O provider LLM '{provider}' não tem modelo configurado em Configurações Técnicas > API Keys."
+            f"O provider LLM '{provider}' não tem modelo configurado em Configuração API > API Keys > Serviços e modelos."
         )
     if provider not in {"ollama", "litellm"} and not key:
         raise CreativeGenerationError(
-            f"Configure a API key do provider LLM '{provider}' em Configurações Técnicas > API Keys."
+            f"Configure a API key do provider LLM '{provider}' em Configuração API > API Keys > Serviços e modelos."
         )
     return provider, key, base_url.rstrip("/"), model
 

package/hermes_ui/notifications.py

@@ -36,6 +36,7 @@ EVENT_CATALOG: tuple[dict[str, str], ...] = (
     {"code": "upload_instagram_success", "category": "Upload", "label": "Upload Instagram concluído", "description": "Quando um vídeo for publicado num perfil Instagram."},
     {"code": "upload_facebook_pages_success", "category": "Upload", "label": "Upload Facebook Pages concluído", "description": "Quando um vídeo for publicado numa Facebook Page."},
     {"code": "upload_postiz_success", "category": "Upload", "label": "Upload Postiz concluído", "description": "Quando um vídeo for enviado e publicado através do Postiz."},
+    {"code": "upload_upload_post_success", "category": "Upload", "label": "Upload-Post concluído", "description": "Quando um vídeo for aceite pelo Upload-Post para publicação nas plataformas seleccionadas."},
     {"code": "mcp_operation_completed", "category": "Integrações", "label": "Operação MCP concluída", "description": "Quando uma operação mutável de integração MCP terminar com sucesso."},
 )
 EVENTS_BY_CODE = {item["code"]: item for item in EVENT_CATALOG}
@@ -249,6 +250,8 @@ def _upload_notifications() -> int:
         "facebook pages": "upload_facebook_pages_success",
         "facebook_pages": "upload_facebook_pages_success",
         "postiz": "upload_postiz_success",
+        "upload-post": "upload_upload_post_success",
+        "upload_post": "upload_upload_post_success",
         "youtube direct frontend": "upload_youtube_success",
     }
     for upload in uploads:

package/hermes_ui/storage.py

@@ -115,6 +115,7 @@ DEFAULTS: dict[str, Any] = {
             "upload_instagram_success": True,
             "upload_facebook_pages_success": True,
             "upload_postiz_success": True,
+            "upload_upload_post_success": True,
             "mcp_operation_completed": True,
         },
         "kaggle_username": "",

package/hermes_ui/thumbnail_generation.py

@@ -87,7 +87,7 @@ def generate_thumbnail_image(
 ) -> Path:
     api_key = str(settings.get("gemini_image_api_key") or "").strip()
     if not api_key:
-        raise ThumbnailGenerationError("Configure a API key Nano Banana em Configurações Técnicas > API Keys.")
+        raise ThumbnailGenerationError("Configure a API key Nano Banana em Configuração API > API Keys > Serviços e modelos.")
     clean_prompt = str(prompt or "").strip()
     if not clean_prompt:
         raise ThumbnailGenerationError("A thumbnail não tem um prompt de imagem para gerar.")

package/integrations/postiz.py

@@ -33,7 +33,7 @@ class PostizAdapter:
 
     def status(self) -> IntegrationResult:
         if not self.api_key:
-            return self._error("Postiz não configurado: adicione a API key em Configurações Técnicas.")
+            return self._error("Postiz não configurado: adicione a API key em Configuração API > API Keys > Serviços e modelos.")
         return IntegrationResult(True, f"Postiz configurado em {self.base_url}.", {"base_url": self.base_url, "mcp_url": self.mcp_url})
 
     def list_integrations(self) -> IntegrationResult:

package/integrations/upload_post.py

@@ -0,0 +1,152 @@
+"""Upload-Post API adapter for publishing local video artefacts."""
+
+from __future__ import annotations
+
+import mimetypes
+from pathlib import Path
+from typing import Any
+
+import requests
+
+from .platforms import IntegrationResult
+
+
+DEFAULT_UPLOAD_POST_BASE_URL = "https://api.upload-post.com/api"
+UPLOAD_POST_PLATFORM_OPTIONS = (
+    "tiktok",
+    "instagram",
+    "youtube",
+    "facebook",
+    "linkedin",
+    "x",
+    "threads",
+    "pinterest",
+    "reddit",
+    "bluesky",
+    "discord",
+    "telegram",
+)
+_PLATFORM_ALIASES = {
+    "facebook pages": "facebook",
+    "facebook_pages": "facebook",
+    "twitter": "x",
+    "x (twitter)": "x",
+}
+
+
+def normalize_upload_post_platforms(value: Any) -> list[str]:
+    """Return stable Upload-Post platform slugs without duplicates."""
+    values = value if isinstance(value, (list, tuple, set)) else str(value or "").replace("\n", ",").split(",")
+    result: list[str] = []
+    seen: set[str] = set()
+    supported = set(UPLOAD_POST_PLATFORM_OPTIONS)
+    for item in values:
+        platform = str(item or "").strip().lower()
+        platform = _PLATFORM_ALIASES.get(platform, platform)
+        if platform in supported and platform not in seen:
+            result.append(platform)
+            seen.add(platform)
+    return result
+
+
+class UploadPostAdapter:
+    """Small deterministic client for Upload-Post's ``POST /upload`` endpoint."""
+
+    def __init__(self, settings: dict[str, Any] | None = None):
+        self.settings = settings or {}
+        self.api_key = str(self.settings.get("upload_post_api_key") or "").strip()
+        self.enabled = bool(self.settings.get("upload_post_enabled", False))
+        self.username = str(self.settings.get("upload_post_username") or "").strip()
+        self.platforms = normalize_upload_post_platforms(self.settings.get("upload_post_platforms", ""))
+        self.base_url = str(self.settings.get("upload_post_base_url") or DEFAULT_UPLOAD_POST_BASE_URL).strip().rstrip("/")
+
+    def _headers(self) -> dict[str, str]:
+        return {"Authorization": f"Apikey {self.api_key}"}
+
+    def _error(self, message: str, data: dict[str, Any] | None = None) -> IntegrationResult:
+        return IntegrationResult(False, message, data or {})
+
+    def status(self) -> IntegrationResult:
+        if not self.enabled:
+            return self._error("Upload-Post está desactivado em Configuração API.")
+        if not self.api_key:
+            return self._error("Upload-Post não configurado: adicione a API key em Configuração API > API Keys > Serviços e modelos.")
+        if not self.username:
+            return self._error("Upload-Post não configurado: adicione o username/perfil em Configuração API.")
+        if not self.platforms:
+            return self._error("Upload-Post não configurado: indique pelo menos uma plataforma em Configuração API.")
+        return IntegrationResult(
+            True,
+            f"Upload-Post configurado para {self.username} ({', '.join(self.platforms)}).",
+            {"base_url": self.base_url, "username": self.username, "platforms": self.platforms},
+        )
+
+    def upload_video(
+        self,
+        video_path: str | Path,
+        *,
+        title: str,
+        description: str = "",
+        user: str | None = None,
+        platforms: list[str] | None = None,
+        async_upload: bool = False,
+    ) -> IntegrationResult:
+        """Upload a local video to one or more connected Upload-Post platforms."""
+        if not self.enabled:
+            return self._error("Upload-Post está desactivado em Configuração API.")
+        if not self.api_key:
+            return self._error("Upload-Post não configurado: adicione a API key em Configuração API.")
+        path = Path(video_path)
+        if not path.is_file():
+            return self._error(f"Vídeo não encontrado para o Upload-Post: {path}")
+        selected_user = str(user or self.username).strip()
+        selected_platforms = normalize_upload_post_platforms(platforms or self.platforms)
+        if not selected_user:
+            return self._error("Indique o username/perfil ligado ao Upload-Post antes de publicar.")
+        if not selected_platforms:
+            return self._error("Seleccione pelo menos uma plataforma do Upload-Post antes de publicar.")
+
+        form_data: list[tuple[str, str]] = [
+            ("user", selected_user),
+            *[("platform[]", platform) for platform in selected_platforms],
+            ("title", str(title or "Vídeo Thunderbolt").strip()[:500] or "Vídeo Thunderbolt"),
+            ("description", str(description or "").strip()),
+            ("async_upload", "true" if async_upload else "false"),
+        ]
+        content_type = mimetypes.guess_type(path.name)[0] or "video/mp4"
+        try:
+            with path.open("rb") as handle:
+                response = requests.post(
+                    f"{self.base_url}/upload",
+                    headers=self._headers(),
+                    data=form_data,
+                    files={"video": (path.name, handle, content_type)},
+                    timeout=240,
+                )
+        except requests.RequestException as exc:
+            return self._error(f"Não foi possível contactar o Upload-Post: {exc}", {"platforms": selected_platforms, "user": selected_user})
+        if response.status_code >= 400:
+            return self._error(
+                f"Upload-Post rejeitou o vídeo (HTTP {response.status_code}): {response.text[:500]}",
+                {"platforms": selected_platforms, "user": selected_user},
+            )
+        try:
+            payload: Any = response.json()
+        except ValueError:
+            return self._error("Upload-Post devolveu uma resposta que não é JSON.", {"response": response.text[:2000]})
+        payload_dict = payload if isinstance(payload, dict) else {"response": payload}
+        request_id = str(payload_dict.get("request_id") or payload_dict.get("requestId") or "").strip()
+        message = "Upload-Post aceitou o vídeo para publicação."
+        if request_id:
+            message += f" Request ID: {request_id}."
+        return IntegrationResult(
+            True,
+            message,
+            {
+                "payload": payload_dict,
+                "request_id": request_id,
+                "user": selected_user,
+                "platforms": selected_platforms,
+                "async_upload": bool(async_upload),
+            },
+        )

package/integrations/upload_routing.py

@@ -154,7 +154,7 @@ def upload_with_default_route(
 
     postiz = PostizAdapter(settings)
     if not bool(settings.get("postiz_enabled", False)):
-        postiz_result = IntegrationResult(False, "Postiz está desactivado em Configurações Técnicas.", {})
+        postiz_result = IntegrationResult(False, "Postiz está desactivado em Configuração API > API Keys > Serviços e modelos.", {})
         attempts.append(_attempt_record("Postiz", postiz_result, skipped=True))
     else:
         postiz_publisher = postiz_publisher or postiz.publish_video

package/package.json

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