@danhachuel/thunderbolt 0.2.55 → 0.2.56

package/MANUAL-INSTALACAO.md

@@ -2,7 +2,7 @@
 
 Este manual descreve a instalação local da UI Thunderbolt, baseada no MoneyPrinterTurbo, utilizando o pacote npm `@danhachuel/thunderbolt`. O fluxo recomendado instala automaticamente o ambiente Python, as dependências da aplicação, as dependências do MoneyPrinterTurbo, o Streamlit e o suporte FFmpeg através de `imageio-ffmpeg`.
 
-> **Versão deste manual:** 0.2.55
+> **Versão deste manual:** 0.2.56
 > **Pacote npm:** `@danhachuel/thunderbolt`
 > **Porta padrão da UI:** `localhost:3030`  
 > **Repositório:** [github.com/DanHachuel/thunderbolt](https://github.com/DanHachuel/thunderbolt)
@@ -100,13 +100,13 @@ Execute:
 Windows PowerShell ou MobaXterm:
 
 ```powershell
-npx.cmd --yes @danhachuel/thunderbolt@0.2.55 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.56 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes @danhachuel/thunderbolt@0.2.55 install
+npx --yes @danhachuel/thunderbolt@0.2.56 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.
@@ -428,7 +428,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.55 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.56 install`; o instalador detecta e reutiliza o que já estiver válido.
 
 ### Niche Finder Apify
 
@@ -468,7 +468,11 @@ A aba **Automação Youtube**, dentro do menu expansível **Automação**, lista
 
 A área **Teste de vozes**, dentro de **Configurações > Configurações Técnicas**, é 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 directo
+## Upload, Postiz 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ções Técnicas > API Keys**. 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.
 
 Em **Configurações > Configurações Técnicas > Contas Google/YouTube — canais em lote**, 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`.
 

package/README.md

@@ -20,9 +20,9 @@ A primeira versão implementa a camada UI independente com:
 | Models AI | Menu expansível com Personagens e Redes Sociais reservados para desenvolvimento futuro |
 | Niche Finder | Menu expansível com duas alternativas independentes: Niche Finder Kaggle e Niche Finder Apify, com parâmetros, execução e resultados separados |
 | Edição | Menu expansível abaixo de Automação com Limpador de Metadados, Clip Generator local em Cortes e Editor Python inspirado no PYEdit para vídeos e scripts locais |
-| Upload | YouTube via `youtube-automation-agent` adaptado internamente, OAuth directo de redundância, Upload directo via sessão Frontend API com cookies/sessionInfo por conta e DELEGATED_SESSION_ID por canal, TikTok, Instagram e Facebook Pages no front end |
+| Upload | YouTube via `youtube-automation-agent` adaptado internamente, fallback ordenado API Oficial → Upload directo → Postiz, upload de MP4 para Postiz via API key/MCP configurável, TikTok, Instagram e Facebook Pages no front end |
 | MCP | Catálogo local opcional de Short Video Maker, AutoVio, OpenMontage e OpenCut, com portas editáveis e activação |
-| Configurações Técnicas | Provedores LLM, OpenAI/NVIDIA NIM com API key, Base URL e selector de modelos, TTS/voz, preview de vozes, Suno, materiais, Whisper, FFmpeg, OAuth YouTube, contas Google/YouTube para canais em lote com e-mail, Client ID, Client Secret e sessionInfo por conta, cartões expansíveis por nome/e-mail, documento credentials.json criado automaticamente e eliminação individual, cookies SID/SSID/HSID/APISID/SAPISID no documento JSON, Data API Key opcional, Kaggle Username/API Key, Apify API Token/Actor ID/limites, Upload directo, TikTok Client ID/Secret e Upload-Post |
+| Configurações Técnicas | Provedores LLM, OpenAI/NVIDIA NIM com API key, Base URL e selector de modelos, TTS/voz, preview de vozes, Suno, materiais, Whisper, FFmpeg, OAuth YouTube, contas Google/YouTube para canais em lote com e-mail, Client ID, Client Secret e sessionInfo por conta, cartões expansíveis por nome/e-mail, documento credentials.json criado automaticamente e eliminação individual, cookies SID/SSID/HSID/APISID/SAPISID no documento JSON, Data API Key opcional, Kaggle Username/API Key, Apify API Token/Actor ID/limites, Upload directo, Postiz API key/Base URL/MCP URL/integração padrão, TikTok Client ID/Secret e Upload-Post |
 | Launcher | Execução via `npx`, instalação assistida, diagnóstico e preparação para distribuição |
 
 ## Upload directo — credenciais por conta e por canal
@@ -38,7 +38,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.55
+## Navegação da UI 0.2.56
 
 A barra lateral mantém os níveis principais, nesta ordem: **Início**, **Niche Finder**, **Pipeline**, **Automação**, **Edição**, **Models AI** 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** e **Editor Python**, nessa ordem. **Models AI** é expansível e contém **Personagens** e **Redes Sociais**, 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** e **Configurações Técnicas**. O Início reúne o dashboard e as filas do Pipeline, sem botões de acções rápidas.
 
@@ -161,9 +161,9 @@ thunderbolt
 No Windows PowerShell, se `npx` for bloqueado por `npx.ps1`, use directamente `npx.cmd`:
 
 ```powershell
-npx.cmd --yes @danhachuel/thunderbolt@0.2.55 install
-npx.cmd --yes @danhachuel/thunderbolt@0.2.55 doctor
-npx.cmd --yes @danhachuel/thunderbolt@0.2.55
+npx.cmd --yes @danhachuel/thunderbolt@0.2.56 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.56 doctor
+npx.cmd --yes @danhachuel/thunderbolt@0.2.56
 ```
 
 Como alternativa, pode permitir scripts para o seu utilizador:
@@ -187,7 +187,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ções Técnicas. 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.55 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ções Técnicas. 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.56 install`; o instalador detecta e reutiliza componentes já válidos.
 
 ## Editor Python baseado no PYEdit
 
@@ -254,7 +254,7 @@ A aba **Canais Youtube** está dividida em dois fluxos independentes. Em **Impor
 
 Em **Cadastro manual**, nenhum pedido ao YouTube é feito e não existe qualquer dependência de API Key. O utilizador pode preencher nome, URL, handle, descrição, métricas, thumbnail, idioma, estilo, Blueprint padrão, voz padrão, `DELEGATED_SESSION_ID` e configuração de Automação. A importação pública nunca grava automaticamente: os dados aparecem num formulário de revisão antes de guardar. A resolução pública aceita URLs `/channel/UC...`, handles e subpáginas; quando existe um ID mas o HTML não traz todos os dados, tenta o feed RSS público. Se o YouTube responder que o canal não existe ou não fornecer metadados, a UI mostra uma mensagem clara e não mantém o formulário de uma pesquisa anterior. Cada cartão de canal tem **Activo** e, logo abaixo, **Apagar canal**, com confirmação; tarefas e artefactos não são apagados.
 
-## Upload YouTube
+## Upload YouTube e fallback Postiz
 
 O Upload usa como caminho **principal** a lógica do `PublishingSchedulingAgent` do [youtube-automation-agent](https://github.com/darkzOGx/youtube-automation-agent), adaptada para Python e executada dentro do processo Streamlit do Thunderbolt. Não é necessário instalar ou iniciar um segundo servidor Node. O fluxo valida o MP4 real, constrói `snippet/status`, faz upload resumível e tenta enviar thumbnail e legendas.
 
@@ -262,6 +262,10 @@ Na aba **Upload**, configure primeiro apenas o **YouTube OAuth Client ID** e o *
 
 Use **Autorizar fallback OAuth** apenas se precisar de uma autorização separada para o caminho de redundância. Os resultados guardam no histórico local qual mecanismo foi utilizado e as tentativas realizadas, sem guardar segredos.
 
+A subaba **Postiz**, dentro de **Upload**, permite carregar as integrações ligadas através de `GET /integrations`, enviar um MP4 para `POST /upload` e criar o post YouTube em `POST /posts`. A API key é enviada como valor bruto do cabeçalho `Authorization`; a base cloud é `https://api.postiz.com/public/v1` e pode ser substituída por uma instalação self-hosted. O modo MCP guarda também a URL Streamable HTTP configurável para uso futuro/alternativo.
+
+O botão principal de YouTube usa a ordem **API Oficial → Upload directo → Postiz**. A API Oficial tem um contador local de cinco envios bem-sucedidos por dia por conta Gmail; quando a quota é atingida, ou o método falha, o Thunderbolt tenta o documento de sessão do Upload directo. Só depois de esse caminho falhar tenta o Postiz, desde que esteja activo, tenha API key e tenha um ID de integração configurado.
+
 A subaba **Upload directo** adapta o [YouTube-Video-Upload-Frontend-Api](https://github.com/Nojus10/YouTube-Video-Upload-Frontend-Api). Ela usa cookies, `sessionInfo`, `INNERTUBE_API_KEY` e `DELEGATED_SESSION_ID` fornecidos manualmente pelo utilizador, cria o vídeo através do endpoint interno e envia o ficheiro em chunks de 256 KiB. Este caminho é experimental, não extrai cookies automaticamente e fica separado do agente YouTube principal.
 
 ## Pipeline: Criação de Vídeos, Criação de Músicas e Automação Youtube

package/app/main.py

@@ -39,6 +39,8 @@ from hermes_ui.script_generation import generate_script_document
 from hermes_ui.voice_preview import DEFAULT_SAMPLE, load_preview_file, synthesize_preview
 from hermes_ui.creative_generation import CreativeGenerationError, generate_creative_package, generate_topic_for_channel
 from integrations.platforms import IntegrationResult, TikTokAdapter, YouTubeAdapter, fetch_channel_videos_public
+from integrations.postiz import PostizAdapter
+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, merge_credentials_document, parse_credentials_document, save_credentials_document, update_credentials_document_session_info
 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
@@ -2136,17 +2138,99 @@ def render_upload_direct():
 
 def render_upload():
     st.title("Upload")
-    upload_tab, direct_tab = st.tabs(["Upload convencional", "Upload directo"])
+    upload_tab, direct_tab, postiz_tab = st.tabs(["Upload convencional", "Upload directo", "Postiz"])
     with direct_tab:
         render_upload_direct()
+    with postiz_tab:
+        render_upload_postiz()
     with upload_tab:
         render_upload_conventional()
 
 
+def render_upload_postiz():
+    st.subheader("Upload para Postiz")
+    st.caption("O Thunderbolt envia primeiro o MP4 para o Postiz e cria um post na integração seleccionada. A API key e o servidor são configurados em Configurações Técnicas.")
+    settings = read_json("settings.json", {})
+    postiz = PostizAdapter(settings)
+    if not settings.get("postiz_enabled"):
+        st.warning("Postiz está desactivado. Active-o em Configurações Técnicas > API Keys e guarde a API key antes de enviar.")
+    if not postiz.api_key:
+        st.info("Nenhuma API key Postiz configurada.")
+        return
+
+    integration_catalog = st.session_state.get("postiz_integrations", [])
+    integration_ids = [str(item.get("id")) for item in integration_catalog if isinstance(item, dict) and item.get("id")]
+    integration_labels = {
+        str(item.get("id")): " — ".join(str(value) for value in [item.get("name") or item.get("provider") or item.get("type") or "Integração", item.get("username") or item.get("profile") or item.get("identifier") or ""] if value)
+        for item in integration_catalog if isinstance(item, dict) and item.get("id")
+    }
+    integration_default = str(settings.get("postiz_integration_id", "") or "")
+    if st.button("Carregar integrações Postiz", key="postiz_load_integrations"):
+        result = postiz.list_integrations()
+        if result.ok:
+            st.session_state["postiz_integrations"] = result.data.get("integrations", [])
+            st.success(result.message)
+            st.rerun()
+        st.error(result.message)
+    if integration_ids:
+        selected_integration = st.selectbox(
+            "Canal/integração Postiz",
+            integration_ids,
+            index=integration_ids.index(integration_default) if integration_default in integration_ids else 0,
+            format_func=lambda value: integration_labels.get(value, value),
+            key="postiz_upload_integration",
+        )
+        st.caption("Para alterar a integração padrão, guarde o ID seleccionado em Configurações Técnicas.")
+    else:
+        selected_integration = st.text_input("ID da integração Postiz", value=integration_default, key="postiz_upload_integration_manual", help="Carregue as integrações para seleccionar uma conta ou introduza o ID devolvido pela API do Postiz.").strip()
+        st.info("Carregue as integrações para descobrir os canais Postiz ligados à sua conta.")
+
+    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 para o Postiz.")
+        return
+    for task in tasks:
+        artifacts = task.get("artifacts", {}) or {}
+        video_path = artifacts.get("video", "")
+        thumbnail_path = artifacts.get("thumbnail") or artifacts.get("cover", "")
+        with st.container(border=True):
+            st.write(f"**{task.get('topic', 'Vídeo Thunderbolt')}** — {task.get('channel_name', 'Canal')}")
+            st.caption(video_path or "Sem caminho de vídeo registado")
+            title = st.text_input("Título Postiz", value=task.get("title") or task.get("topic", "Vídeo Thunderbolt"), key=f"postiz_title_{task['id']}")
+            description = st.text_area("Descrição Postiz", value=task.get("description", ""), key=f"postiz_description_{task['id']}", height=90)
+            visibility = st.selectbox("Visibilidade YouTube no Postiz", ["private", "unlisted", "public"], key=f"postiz_visibility_{task['id']}")
+            if st.button("Enviar vídeo para Postiz", type="primary", key=f"postiz_upload_{task['id']}"):
+                result = postiz.publish_video(
+                    video_path,
+                    integration_id=selected_integration,
+                    title=title,
+                    description=description,
+                    visibility=visibility,
+                    tags=task.get("tags", []) if isinstance(task.get("tags", []), list) else [tag.strip() for tag in str(task.get("tags", "")).split(",") if tag.strip()],
+                    thumbnail_path=thumbnail_path,
+                )
+                record = {
+                    "task_id": task.get("id"),
+                    "destination": "Postiz",
+                    "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)
+                (st.success if result.ok else st.error)(result.message)
+
+
 def render_upload_conventional():
     st.title("Upload")
     settings = read_json("settings.json", {})
     youtube = YouTubeAdapter(settings=settings)
+    channels = read_json("channels.json", [])
+    channel_map = {str(channel.get("id")): channel for channel in channels if channel.get("id")}
+    direct_accounts = {str(account.get("id")): account for account in settings.get("youtube_batch_accounts", []) if isinstance(account, dict) and account.get("id")}
+    postiz = PostizAdapter(settings)
     tasks = [t for t in read_json("tasks.json", []) if t.get("state") == "done" or t.get("artifacts", {}).get("video")]
     destination = st.multiselect("Destinos", ["YouTube", "TikTok", "Instagram", "Facebook Pages"], default=["YouTube"], key="upload_destinations", placeholder="Seleccione os destinos")
 
@@ -2156,9 +2240,14 @@ def render_upload_conventional():
         st.info("Facebook Pages está disponível no front end. A publicação real será ligada numa etapa de credenciais/API própria.")
 
     if "YouTube" in destination:
-        st.markdown("**YouTube — youtube-automation-agent (principal)**")
-        st.caption("O Thunderbolt executa internamente a lógica do PublishingSchedulingAgent: OAuth, upload resumível, metadados, thumbnail e legendas. O OAuth directo é usado apenas como redundância se o caminho principal falhar.")
+        st.markdown("**YouTube — fluxo recomendado de envio**")
+        st.caption("Ordem automática: 1. API Oficial — até 5 envios bem-sucedidos por dia e por conta Gmail; 2. Upload directo — sessão interna YouTube; 3. Postiz — fallback final configurável.")
         status = youtube.upload_status()
+        if settings.get("postiz_enabled"):
+            postiz_status = postiz.status()
+            (st.success if postiz_status.ok else st.warning)(postiz_status.message)
+        else:
+            st.caption("Postiz está desactivado; active-o em Configurações Técnicas para o usar como fallback final.")
         status_cols = st.columns(2)
         with status_cols[0]:
             (st.success if status["agent"].ok else st.warning)(f"Agente: {status['agent'].message}")
@@ -2188,6 +2277,8 @@ def render_upload_conventional():
             thumbnail_path = artifacts.get("thumbnail") or artifacts.get("cover", "")
             captions_path = artifacts.get("captions") or artifacts.get("subtitle", "")
             st.caption(video_path or "Sem caminho de vídeo registado")
+            channel = channel_map.get(str(task.get("channel_id")), {})
+            account = direct_accounts.get(str(channel.get("google_account_id", "")))
             if "YouTube" in destination:
                 title = st.text_input("Título", value=task.get("title") or task.get("topic", "Vídeo Thunderbolt"), key=f"yt_title_{task['id']}")
                 description = st.text_area("Descrição", value=task.get("description", ""), key=f"yt_description_{task['id']}", height=100)
@@ -2199,10 +2290,16 @@ def render_upload_conventional():
                     category_id = st.text_input("Category ID", value="22", key=f"yt_category_{task['id']}")
                 with yt_cols[2]:
                     language = st.text_input("Idioma", value="pt-BR", key=f"yt_language_{task['id']}")
-                if st.button("Publicar no YouTube", type="primary", key=f"upload_youtube_{task['id']}"):
+                quota_count = official_upload_count(channel, account)
+                st.caption(f"API Oficial hoje: {quota_count}/{OFFICIAL_DAILY_LIMIT} envios nesta conta Gmail.")
+                if st.button("Enviar pelo fluxo recomendado", type="primary", key=f"upload_youtube_{task['id']}"):
                     tags = [tag.strip() for tag in tags_raw.split(",") if tag.strip()]
-                    result = youtube.upload_video(
-                        video_path,
+                    result = upload_with_default_route(
+                        settings,
+                        storage_root=STORAGE,
+                        channel=channel,
+                        account=account,
+                        video_path=video_path,
                         title=title,
                         description=description,
                         tags=tags,
@@ -2579,6 +2676,20 @@ def render_settings():
                 upload_post_platforms = text_setting("Plataformas Upload-Post", "upload_post_platforms")
                 upload_post_auto_upload = st.checkbox("Publicar automaticamente após gerar", bool(settings.get("upload_post_auto_upload", False)))
 
+            with st.expander("Postiz — API key, integração e MCP", expanded=True):
+                st.caption("O Thunderbolt é o cliente. A API key é enviada exclusivamente ao servidor Postiz configurado; não é colocada em URLs, logs ou repositório.")
+                postiz_enabled = st.checkbox("Activar Postiz como fallback final", bool(settings.get("postiz_enabled", False)))
+                postiz_mode = st.selectbox("Modo de ligação", ["api", "mcp"], index=0 if settings.get("postiz_mode", "api") != "mcp" else 1, help="API é o modo determinístico de upload. MCP fica disponível para uma ligação compatível com Streamable HTTP.")
+                postiz_cols = st.columns(2)
+                with postiz_cols[0]:
+                    postiz_api_key = text_setting("Postiz API key", "postiz_api_key", secret=True, help_text="API key criada nas definições do Postiz. A API HTTP usa o valor bruto no cabeçalho Authorization.")
+                    postiz_base_url = text_setting("Postiz Public API Base URL", "postiz_base_url", help_text="Cloud: https://api.postiz.com/public/v1 · Self-hosted: https://seu-servidor/api/public/v1")
+                    postiz_integration_id = text_setting("Postiz integração padrão", "postiz_integration_id", help_text="ID do canal/integração devolvido por GET /integrations.")
+                with postiz_cols[1]:
+                    postiz_mcp_url = text_setting("Postiz MCP URL", "postiz_mcp_url", help_text="Cloud: https://api.postiz.com/mcp · o cliente acrescenta a API key conforme o modo escolhido.")
+                    postiz_auto_publish = st.checkbox("Permitir publicação imediata no Postiz", bool(settings.get("postiz_auto_publish", False)))
+                st.caption("No Upload, a aba Postiz permite carregar as integrações e enviar vídeos manualmente. No fluxo recomendado, Postiz só é tentado depois da API Oficial e do Upload directo.")
+
             if refresh_openai_models:
                 try:
                     discovered_models = fetch_openai_compatible_models(openai_api_key, openai_base_url)
@@ -2613,6 +2724,9 @@ def render_settings():
                     "upload_post_enabled": upload_post_enabled, "upload_post_api_key": upload_post_api_key,
                     "upload_post_username": upload_post_username, "upload_post_platforms": upload_post_platforms,
                     "upload_post_auto_upload": upload_post_auto_upload,
+                    "postiz_enabled": postiz_enabled, "postiz_api_key": postiz_api_key, "postiz_base_url": postiz_base_url.strip() or "https://api.postiz.com/public/v1",
+                    "postiz_mcp_url": postiz_mcp_url.strip() or "https://api.postiz.com/mcp", "postiz_mode": postiz_mode,
+                    "postiz_integration_id": postiz_integration_id.strip(), "postiz_auto_publish": bool(postiz_auto_publish),
                 })
                 write_json("settings.json", settings)
                 try:

package/hermes_ui/storage.py

@@ -192,6 +192,13 @@ DEFAULTS: dict[str, Any] = {
         "upload_post_username": "",
         "upload_post_platforms": "tiktok,instagram",
         "upload_post_auto_upload": False,
+        "postiz_enabled": False,
+        "postiz_api_key": "",
+        "postiz_base_url": "https://api.postiz.com/public/v1",
+        "postiz_mcp_url": "https://api.postiz.com/mcp",
+        "postiz_mode": "api",
+        "postiz_integration_id": "",
+        "postiz_auto_publish": False,
         "tiktok_client_key": "",
         "tiktok_client_secret": "",
         "tiktok_redirect_uri": "http://localhost:3030/oauth/tiktok/callback",

package/integrations/postiz.py

@@ -0,0 +1,173 @@
+"""Postiz Public API adapter used as the final upload fallback."""
+
+from __future__ import annotations
+
+import mimetypes
+from pathlib import Path
+from typing import Any
+
+import requests
+
+from .platforms import IntegrationResult
+
+
+DEFAULT_POSTIZ_BASE_URL = "https://api.postiz.com/public/v1"
+DEFAULT_POSTIZ_MCP_URL = "https://api.postiz.com/mcp"
+
+
+class PostizAdapter:
+    def __init__(self, settings: dict[str, Any] | None = None):
+        self.settings = settings or {}
+        self.api_key = str(self.settings.get("postiz_api_key") or "").strip()
+        self.base_url = str(self.settings.get("postiz_base_url") or DEFAULT_POSTIZ_BASE_URL).strip().rstrip("/")
+        self.mcp_url = str(self.settings.get("postiz_mcp_url") or DEFAULT_POSTIZ_MCP_URL).strip().rstrip("/")
+
+    def _headers(self, *, json_body: bool = False) -> dict[str, str]:
+        headers = {"Authorization": self.api_key}
+        if json_body:
+            headers["Content-Type"] = "application/json"
+        return headers
+
+    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.api_key:
+            return self._error("Postiz não configurado: adicione a API key em Configurações Técnicas.")
+        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:
+        status = self.status()
+        if not status.ok:
+            return status
+        try:
+            response = requests.get(f"{self.base_url}/integrations", headers=self._headers(), timeout=30)
+        except requests.RequestException as exc:
+            return self._error(f"Não foi possível contactar o Postiz: {exc}")
+        if response.status_code >= 400:
+            return self._error(f"Postiz devolveu HTTP {response.status_code}: {response.text[:500]}")
+        try:
+            payload = response.json()
+        except ValueError:
+            return self._error("Postiz devolveu uma resposta que não é JSON.")
+        if isinstance(payload, dict):
+            integrations = payload.get("integrations") or payload.get("data") or payload.get("items") or []
+        else:
+            integrations = payload
+        if not isinstance(integrations, list):
+            return self._error("A resposta de integrações do Postiz não tem uma lista válida.", {"payload": payload})
+        normalized = [item for item in integrations if isinstance(item, dict) and item.get("id")]
+        return IntegrationResult(True, f"{len(normalized)} integração(ões) Postiz carregada(s).", {"integrations": normalized, "payload": payload})
+
+    def upload_file(self, video_path: str | Path, *, mime_type: str | None = None) -> IntegrationResult:
+        status = self.status()
+        if not status.ok:
+            return status
+        path = Path(video_path)
+        if not path.is_file():
+            return self._error(f"Vídeo não encontrado para o Postiz: {path}")
+        content_type = mime_type or 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(),
+                    files={"file": (path.name, handle, content_type)},
+                    timeout=180,
+                )
+        except requests.RequestException as exc:
+            return self._error(f"Não foi possível enviar o vídeo para o Postiz: {exc}")
+        if response.status_code >= 400:
+            return self._error(f"Postiz rejeitou o upload (HTTP {response.status_code}): {response.text[:500]}")
+        try:
+            payload = response.json()
+        except ValueError:
+            return self._error("Postiz devolveu uma resposta de upload que não é JSON.")
+        asset_id = str(payload.get("id") or "").strip() if isinstance(payload, dict) else ""
+        asset_path = str(payload.get("path") or "").strip() if isinstance(payload, dict) else ""
+        if not asset_id or not asset_path:
+            return self._error("O upload Postiz não devolveu id e path do asset.", {"payload": payload})
+        return IntegrationResult(True, "Vídeo carregado no Postiz.", {"asset": {"id": asset_id, "path": asset_path}, "payload": payload})
+
+    def create_youtube_post(
+        self,
+        integration_id: str,
+        *,
+        asset: dict[str, str],
+        title: str,
+        description: str = "",
+        visibility: str = "private",
+        tags: list[str] | None = None,
+        thumbnail: dict[str, str] | None = None,
+        post_type: str = "now",
+        date: str | None = None,
+    ) -> IntegrationResult:
+        status = self.status()
+        if not status.ok:
+            return status
+        integration_id = str(integration_id or "").strip()
+        if not integration_id:
+            return self._error("Seleccione uma integração YouTube do Postiz antes de publicar.")
+        normalized_visibility = visibility if visibility in {"public", "unlisted", "private"} else "private"
+        tag_values = [str(tag).strip() for tag in (tags or []) if str(tag).strip()]
+        body: dict[str, Any] = {
+            "type": post_type if post_type in {"now", "schedule", "draft"} else "now",
+            "shortLink": False,
+            "tags": [],
+            "posts": [
+                {
+                    "integration": {"id": integration_id},
+                    "value": [{"content": description, "image": [asset]}],
+                    "settings": {
+                        "__type": "youtube",
+                        "title": title.strip()[:100] or "Vídeo Thunderbolt",
+                        "type": normalized_visibility,
+                        "selfDeclaredMadeForKids": "no",
+                        "thumbnail": thumbnail,
+                        "tags": [{"value": value, "label": value} for value in tag_values],
+                    },
+                }
+            ],
+        }
+        if post_type == "schedule" and date:
+            body["date"] = date
+        try:
+            response = requests.post(f"{self.base_url}/posts", headers=self._headers(json_body=True), json=body, timeout=60)
+        except requests.RequestException as exc:
+            return self._error(f"Não foi possível criar o post no Postiz: {exc}")
+        if response.status_code >= 400:
+            return self._error(f"Postiz rejeitou a publicação (HTTP {response.status_code}): {response.text[:500]}", {"request": body})
+        try:
+            payload = response.json()
+        except ValueError:
+            return self._error("Postiz devolveu uma resposta de publicação que não é JSON.", {"request": body})
+        return IntegrationResult(True, "Post criado no Postiz.", {"payload": payload, "request": body, "asset": asset, "integration_id": integration_id})
+
+    def publish_video(
+        self,
+        video_path: str | Path,
+        *,
+        integration_id: str,
+        title: str,
+        description: str = "",
+        visibility: str = "private",
+        tags: list[str] | None = None,
+        thumbnail_path: str | Path | None = None,
+    ) -> IntegrationResult:
+        upload = self.upload_file(video_path)
+        if not upload.ok:
+            return upload
+        thumbnail_asset = None
+        if thumbnail_path and Path(thumbnail_path).is_file():
+            thumb_upload = self.upload_file(thumbnail_path, mime_type=mimetypes.guess_type(str(thumbnail_path))[0] or "image/jpeg")
+            if thumb_upload.ok:
+                thumbnail_asset = thumb_upload.data.get("asset")
+        return self.create_youtube_post(
+            integration_id,
+            asset=upload.data["asset"],
+            title=title,
+            description=description,
+            visibility=visibility,
+            tags=tags,
+            thumbnail=thumbnail_asset,
+        )

package/integrations/upload_routing.py

@@ -0,0 +1,177 @@
+"""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.
+"""
+
+from __future__ import annotations
+
+from datetime import date
+from pathlib import Path
+from typing import Any, Callable
+
+from integrations.platforms import IntegrationResult, YouTubeAdapter
+from integrations.postiz import PostizAdapter
+from integrations.youtube_direct_credentials import document_status
+from integrations.youtube_direct_upload import YouTubeDirectUploader
+from hermes_ui.storage import read_json, write_json
+
+OFFICIAL_DAILY_LIMIT = 5
+QUOTA_FILENAME = "official_upload_quota.json"
+
+
+def _attempt_record(name: str, result: IntegrationResult, *, skipped: bool = False) -> dict[str, Any]:
+    return {
+        "route": name,
+        "status": "skipped" if skipped else ("success" if result.ok else "failed"),
+        "message": result.message,
+        "data": result.data,
+    }
+
+
+def _quota_key(channel: dict[str, Any], account: dict[str, Any] | None) -> str:
+    if account and account.get("id"):
+        return f"account:{account['id']}"
+    if channel.get("google_account_id"):
+        return f"account:{channel['google_account_id']}"
+    return f"channel:{channel.get('id', 'unknown')}"
+
+
+def official_upload_count(channel: dict[str, Any], account: dict[str, Any] | None, *, today: str | None = None) -> int:
+    today = today or date.today().isoformat()
+    state = read_json(QUOTA_FILENAME, {})
+    if not isinstance(state, dict):
+        return 0
+    entry = state.get(_quota_key(channel, account), {})
+    if not isinstance(entry, dict) or entry.get("date") != today:
+        return 0
+    try:
+        return max(0, int(entry.get("count", 0)))
+    except (TypeError, ValueError):
+        return 0
+
+
+def record_official_upload(channel: dict[str, Any], account: dict[str, Any] | None, *, today: str | None = None) -> int:
+    today = today or date.today().isoformat()
+    state = read_json(QUOTA_FILENAME, {})
+    if not isinstance(state, dict):
+        state = {}
+    key = _quota_key(channel, account)
+    current = official_upload_count(channel, account, today=today)
+    state[key] = {"date": today, "count": current + 1}
+    write_json(QUOTA_FILENAME, state)
+    return current + 1
+
+
+def _result_with_attempts(result: IntegrationResult, attempts: list[dict[str, Any]], route: str) -> IntegrationResult:
+    data = dict(result.data or {})
+    data["route"] = route
+    data["attempts"] = attempts
+    return IntegrationResult(result.ok, result.message, data)
+
+
+def upload_with_default_route(
+    settings: dict[str, Any],
+    *,
+    storage_root: Path,
+    channel: dict[str, Any],
+    account: dict[str, Any] | None,
+    video_path: str,
+    title: str,
+    description: str = "",
+    tags: list[str] | None = None,
+    category_id: str = "22",
+    language: str = "pt-BR",
+    privacy_status: str = "private",
+    thumbnail_path: str = "",
+    captions_path: str = "",
+    official_uploader: Callable[..., IntegrationResult] | None = None,
+    direct_uploader: Callable[..., IntegrationResult] | None = None,
+    postiz_publisher: Callable[..., IntegrationResult] | None = None,
+) -> IntegrationResult:
+    attempts: list[dict[str, Any]] = []
+    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})
+        attempts.append(_attempt_record("API Oficial", quota_result, skipped=True))
+    else:
+        official_uploader = official_uploader or YouTubeAdapter(settings).upload_video
+        try:
+            official_result = official_uploader(
+                video_path,
+                title=title,
+                description=description,
+                tags=tags or [],
+                category_id=category_id,
+                language=language,
+                privacy_status=privacy_status,
+                thumbnail_path=thumbnail_path,
+                captions_path=captions_path,
+            )
+        except Exception as exc:  # Keep fallback actionable and deterministic.
+            official_result = IntegrationResult(False, f"API Oficial falhou: {exc}", {})
+        attempts.append(_attempt_record("API Oficial", official_result))
+        if official_result.ok:
+            used = record_official_upload(channel, account)
+            data = dict(official_result.data or {})
+            data["official_daily_count"] = used
+            data["official_daily_limit"] = OFFICIAL_DAILY_LIMIT
+            data["route"] = "API Oficial"
+            data["attempts"] = attempts
+            return IntegrationResult(True, official_result.message, data)
+
+    direct_ready = False
+    if account:
+        try:
+            status = document_status(storage_root, account, channel, settings, [channel])
+            direct_ready = bool(status.get("ready"))
+            if not direct_ready:
+                missing = list(status.get("missing_cookies", []))
+                if not status.get("has_session_info"):
+                    missing.append("sessionInfo")
+                if not status.get("has_innertube_api_key"):
+                    missing.append("INNERTUBE_API_KEY")
+                if not status.get("has_delegated_session_id"):
+                    missing.append("DELEGATED_SESSION_ID")
+                direct_result = IntegrationResult(False, f"Upload directo indisponível: {', '.join(missing)}.", {"missing": missing})
+            else:
+                direct_result = None
+        except Exception as exc:
+            direct_result = IntegrationResult(False, f"Não foi possível validar o documento do Upload directo: {exc}", {})
+    else:
+        direct_result = IntegrationResult(False, "Upload directo indisponível: o canal não tem uma conta Google associada.", {})
+    if direct_ready:
+        direct_uploader = direct_uploader or YouTubeDirectUploader(settings, channel, account=account, storage_root=storage_root).upload
+        try:
+            direct_result = direct_uploader(video_path, title=title, description=description, visibility=privacy_status)
+        except Exception as exc:
+            direct_result = IntegrationResult(False, f"Upload directo falhou: {exc}", {})
+    attempts.append(_attempt_record("Upload directo", direct_result))
+    if direct_result.ok:
+        return _result_with_attempts(direct_result, attempts, "Upload directo")
+
+    postiz = PostizAdapter(settings)
+    if not bool(settings.get("postiz_enabled", False)):
+        postiz_result = IntegrationResult(False, "Postiz está desactivado em Configurações Técnicas.", {})
+        attempts.append(_attempt_record("Postiz", postiz_result, skipped=True))
+    else:
+        postiz_publisher = postiz_publisher or postiz.publish_video
+        try:
+            postiz_result = postiz_publisher(
+                video_path,
+                integration_id=str(settings.get("postiz_integration_id", "") or ""),
+                title=title,
+                description=description,
+                visibility=privacy_status,
+                tags=tags or [],
+                thumbnail_path=thumbnail_path,
+            )
+        except Exception as exc:
+            postiz_result = IntegrationResult(False, f"Postiz falhou: {exc}", {})
+        attempts.append(_attempt_record("Postiz", postiz_result))
+        if postiz_result.ok:
+            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"})

package/package.json

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