@danhachuel/thunderbolt 0.2.76 → 0.2.78

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.75
+> **Versão deste manual:** 0.2.78
 > **Pacote npm:** `@danhachuel/thunderbolt`
 > **Porta padrão da UI:** `localhost:3030`  
 > **Repositório:** [github.com/DanHachuel/thunderbolt](https://github.com/DanHachuel/thunderbolt)
@@ -23,7 +23,7 @@ A instalação assistida cria um ambiente local separado para evitar misturar as
 | FFmpeg | Disponibilizado pelo pacote Python `imageio-ffmpeg` |
 | Porta da aplicação | `3030`, configurável com `THUNDERBOLT_PORT` |
 
-A aplicação não instala drivers de GPU, Docker, modelos Whisper ou credenciais externas. As chaves de API do MoneyPrinterTurbo são configuradas na aba **Configurações** e sincronizadas com o `config.toml` do clone local.
+A aplicação não instala drivers de GPU, Docker, modelos Whisper ou credenciais externas. As chaves de API do MoneyPrinterTurbo são configuradas na aba **Configurações** e sincronizadas com o `config.toml` do clone local. O idioma da interface e o idioma dos vídeos são preferências independentes.
 
 O MoneyPrinterTurbo declara Python 3.11 ou superior como requisito e documenta a instalação com `uv` ou com `venv + pip`. A aplicação segue o mesmo princípio e adiciona um instalador assistido próprio.[1]
 
@@ -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.
@@ -190,6 +190,12 @@ $env:THUNDERBOLT_VENV="C:\ContentHermes\.venv"
 npx --yes @danhachuel/thunderbolt install
 ```
 
+## Idiomas e selector de bandeira
+
+O Thunderbolt inclui as dez opções de idioma usadas pelo fluxo MoneyPrinterTurbo: **🇺🇸 Inglês (en)**, **🇨🇳 Chinês Simplificado (zh)**, **🇩🇪 Alemão (de)**, **🇻🇳 Vietnamita (vi)**, **🇹🇷 Turco (tr)**, **🇧🇷 Português (pt)**, **🇷🇺 Russo (ru)**, **🇪🇸 Espanhol (es)**, **🇮🇩 Indonésio (id)** e **🇮🇹 Italiano (it)**. A criação de vídeos mantém ainda os rótulos históricos para não invalidar Blueprints e tarefas antigas.
+
+No canto superior direito, imediatamente à esquerda de **Deploy**, o botão com a bandeira actual abre o selector do **Idioma da interface**. A escolha fica guardada como `ui_language` em `storage/state/settings.json` e, quando existe um caminho MoneyPrinterTurbo configurado, é sincronizada com `[ui].language` no `config.toml`. Na Criação de Vídeos e em Roteiros, o selector **Script Language** mostra bandeira, nome e código, mas guarda o código curto; essa escolha é sincronizada com `[ui].video_language`.
+
 ## 4. Diagnóstico antes de iniciar
 
 Depois da instalação, execute:
@@ -436,7 +442,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 +484,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

@@ -15,7 +15,7 @@ A primeira versão implementa a camada UI independente com:
 | Blueprints Youtube | Leitura da pasta `storage/blueprints/`, upload/validação de JSON e criação a partir de link YouTube |
 | Brandings | Subaba própria dentro de Blueprints, upload/listagem de Brandings e criação conjunta com Blueprint |
 | Canais Youtube | Subabas de importação pública sem API Key, Canais em lote gmail por conta Google/YouTube via OAuth e cadastro manual independente; cartões com botão Editar, nicho/referências visível, Prompts do Canal/Blueprint, Narrador/voz e gestão dos últimos 10 vídeos |
-| Criação de Vídeos / Criação de Músicas | Subabas Criar vídeo e Vídeos; lotes; 51 rótulos de idioma; Pexels/Pixabay, full IA com Estilo IA e Apenas Música com agente musical; a segunda página reutiliza o mesmo fluxo com título próprio |
+| Criação de Vídeos / Criação de Músicas | Subabas Criar vídeo e Vídeos; idiomas históricos preservados e dez códigos MoneyPrinterTurbo com bandeiras; Pexels/Pixabay, full IA com Estilo IA e Apenas Música com agente musical; a segunda página reutiliza o mesmo fluxo com título próprio |
 | Automação | Menu expansível com a subaba **Automação Youtube**, onde ficam os vídeos e canais, selectores editáveis de Blueprint/voz padrão, Automação ON, horário diário HH:MM e worker local baseado no relógio do computador |
 | AI Influencers | Menu expansível com Personagens, Redes Sociais e Tutorial Meta |
 | Niche Finder | Menu expansível com duas alternativas independentes: Niche Finder Kaggle e Niche Finder Apify, com parâmetros, execução e resultados separados |
@@ -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,13 @@ 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
+## Idiomas e selector rápido da UI
+
+O Thunderbolt mantém os idiomas históricos da criação de vídeos e acrescenta as dez opções canónicas do MoneyPrinterTurbo: **🇺🇸 Inglês (en)**, **🇨🇳 Chinês Simplificado (zh)**, **🇩🇪 Alemão (de)**, **🇻🇳 Vietnamita (vi)**, **🇹🇷 Turco (tr)**, **🇧🇷 Português (pt)**, **🇷🇺 Russo (ru)**, **🇪🇸 Espanhol (es)**, **🇮🇩 Indonésio (id)** e **🇮🇹 Italiano (it)**. Os códigos curtos são os valores persistidos e sincronizados com `ui.video_language` no `config.toml`; a bandeira e o nome são apenas a apresentação visual.
+
+No canto superior direito da aplicação existe um botão compacto com a bandeira do idioma actual, colocado imediatamente à esquerda do botão **Deploy** do Streamlit. Ao abrir o botão, seleccione outro idioma; a preferência é guardada em `storage/state/settings.json` como `ui_language`, e a navegação lateral actualiza-se sem alterar o idioma seleccionado para os vídeos. A primeira implementação traduz o chrome principal da navegação e mantém os rótulos específicos das páginas compatíveis com o fluxo existente.
+
+## Navegação da UI 0.2.78
 
 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 +183,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 +209,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

@@ -37,6 +37,7 @@ from hermes_ui.material_sources import material_api_keys, material_source_catalo
 from hermes_ui.music import list_music_files, materialize_suno_audio, request_suno_generation, store_music_file
 from hermes_ui.media_downloader import AUDIO_FORMATS, VIDEO_CONTAINERS, VIDEO_QUALITY_OPTIONS, MediaDownloadError, build_download_options, clear_media_download_history, dependency_status, download_media, list_media_downloads, media_download_file
 from hermes_ui.notifications import clear_notifications, list_notifications, mark_all_notifications_read, mark_notification_read, notification_event_catalog, notification_preferences, record_notification, reconcile_persisted_notifications, save_notification_preferences, unread_notification_count
+from hermes_ui.languages import LANGUAGE_CODES, language_code, language_flag, language_label, ui_text, video_language_label, video_language_options
 from hermes_ui.script_documents import list_script_documents, read_script_document, save_script_document, script_storage_path
 from hermes_ui.script_generation import generate_script_document
 from hermes_ui.voice_preview import DEFAULT_SAMPLE, load_preview_file, synthesize_preview
@@ -45,6 +46,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
@@ -125,8 +127,10 @@ VIDEO_LANGUAGE_OPTIONS = [
     "50 – Hausa",
 ]
 
-# Mantemos estes valores separados para que Criação de Vídeos e Roteiros partilhem
-# exactamente os mesmos selectores sem alterar a lista histórica de idiomas.
+# Mantemos esta lista histórica para preservar Blueprints, testes e tarefas antigas.
+# A UI acrescenta os dez códigos canónicos do MoneyPrinterTurbo com bandeiras.
+VIDEO_LANGUAGE_SELECTION_OPTIONS = ["music", *LANGUAGE_CODES, *[item for item in VIDEO_LANGUAGE_OPTIONS if item not in {"01 – Inglês", "06 – Alemão", "15 – Italiano", "29 – Turco", "31 – Russo", "36 – Português (Brasil)", "39 – Mandarim", "41 – Espanhol (LatAm)", "42 – Vietnamita", "44 – Indonésio"}]]
+
 VIDEO_FORMAT_OPTIONS = ["wide", "shorts", "music"]
 VIDEO_CONCATENATION_OPTIONS = ["Random Concatenation (Recommended)", "Sequential Concatenation"]
 VIDEO_TRANSITION_OPTIONS = ["None", "Fade", "Dissolve"]
@@ -184,6 +188,12 @@ st.markdown("""
 [data-testid="stRadio"] label { border:1px solid #2a4052; border-radius:12px; padding:.65rem .8rem; background:#101b25; min-height:4.3rem; }
 [data-testid="stRadio"] label:has(input:checked) { border-color:#c59b55; background:linear-gradient(145deg, rgba(96,71,33,.42), rgba(17,27,37,.95)); }
 [data-testid="stStatusWidget"] { border-color:#2a4052 !important; background:#101b25 !important; }
+/* Selector compacto de idioma, visualmente colocado à esquerda do Deploy do Streamlit. */
+[data-testid="stPopover"] { position:fixed !important; top:0.34rem !important; right:4.75rem !important; z-index:100000 !important; }
+[data-testid="stPopover"] > button { min-width:2.25rem !important; width:2.25rem !important; height:2.25rem !important; padding:0 !important; border:1px solid #2a4052 !important; border-radius:8px !important; background:#101b25 !important; }
+[data-testid="stPopover"] > button p { font-size:1.12rem !important; line-height:1 !important; margin:0 !important; }
+[data-testid="stPopover"] [data-testid="stPopoverBody"] { min-width:18rem; }
+@media (max-width: 700px) { [data-testid="stPopover"] { right:3.2rem !important; } }
 
 /* Cores dos chips por identidade da plataforma, sem depender da ordem de selecção. */
 [data-testid="stMultiSelectTagsContainer"] span[data-tag] { color:#ffffff !important; border:0 !important; font-weight:700 !important; }
@@ -205,6 +215,58 @@ st.markdown("""
 """, unsafe_allow_html=True)
 
 
+def current_ui_language() -> str:
+    settings = read_json("settings.json", {})
+    stored = st.session_state.get("ui_language") or settings.get("ui_language") or "pt"
+    normalized = language_code(stored)
+    st.session_state["ui_language"] = normalized
+    return normalized
+
+
+def save_ui_language(value: str) -> str:
+    normalized = language_code(value)
+    settings = read_json("settings.json", {})
+    settings["ui_language"] = normalized
+    write_json("settings.json", settings)
+    try:
+        sync_moneyprinter_config(settings, str(settings.get("moneyprinter_path") or ""))
+    except Exception:
+        # The selector remains usable even when no MoneyPrinterTurbo path exists.
+        pass
+    st.session_state["ui_language"] = normalized
+    return normalized
+
+
+def save_video_language(value: str) -> str:
+    normalized = "music" if str(value or "").strip().casefold() == "music" else language_code(value)
+    settings = read_json("settings.json", {})
+    settings["video_language"] = normalized
+    write_json("settings.json", settings)
+    try:
+        sync_moneyprinter_config(settings, str(settings.get("moneyprinter_path") or ""))
+    except Exception:
+        pass
+    st.session_state["video_language"] = normalized
+    return normalized
+
+
+def render_ui_language_picker(language: str) -> None:
+    """Render the flag-only popover over the Streamlit toolbar area."""
+    current = language_code(language)
+    with st.popover(language_flag(current), help="Trocar idioma da interface"):
+        st.markdown(f"**{ui_text('Idioma da interface', current)}**")
+        selected = st.selectbox(
+            ui_text("Idioma da interface", current),
+            list(LANGUAGE_CODES),
+            index=list(LANGUAGE_CODES).index(current),
+            format_func=language_label,
+            key="ui_language_picker",
+        )
+        if selected != current:
+            save_ui_language(selected)
+            st.rerun()
+
+
 def card(label: str, value: str | int, note: str = ""):
     st.markdown(f'<div class="content-card"><div class="content-label">{label}</div><div class="content-value">{value}</div><div class="small-muted">{note}</div></div>', unsafe_allow_html=True)
 
@@ -376,10 +438,12 @@ def render_video_generation_settings(prefix: str, *, current_language: str = "")
             key=f"{prefix}_video_subject",
             placeholder="Ex.: How AI is changing everyday life",
         )
+        normalized_current_language = "music" if str(current_language or "").strip().casefold() in {"music", "00 – apenas música de fundo (sem falas)", "00 - apenas música de fundo (sem falas)"} else language_code(current_language)
         settings["script_language"] = st.selectbox(
             "Script Language",
-            VIDEO_LANGUAGE_OPTIONS,
-            index=VIDEO_LANGUAGE_OPTIONS.index(current_language) if current_language in VIDEO_LANGUAGE_OPTIONS else 0,
+            VIDEO_LANGUAGE_SELECTION_OPTIONS,
+            index=VIDEO_LANGUAGE_SELECTION_OPTIONS.index(normalized_current_language) if normalized_current_language in VIDEO_LANGUAGE_SELECTION_OPTIONS else 0,
+            format_func=video_language_label,
             key=f"{prefix}_script_language",
         )
     with subject_cols[1]:
@@ -602,7 +666,7 @@ def render_channel_edit_form(channel: dict, youtube_account_ids: list[str], yout
             edited_name = st.text_input("Nome do canal", value=str(channel.get("name") or ""))
             edited_url = st.text_input("URL", value=str(channel.get("url") or ""))
             edited_handle = st.text_input("Handle", value=str(channel.get("handle") or ""))
-            edited_language = st.selectbox("Idioma", ["Português", "English", "Español", "Français", "Deutsch"], index=["Português", "English", "Español", "Français", "Deutsch"].index(channel.get("language")) if channel.get("language") in {"Português", "English", "Español", "Français", "Deutsch"} else 0)
+            edited_language = st.selectbox("Idioma", list(LANGUAGE_CODES), index=list(LANGUAGE_CODES).index(language_code(channel.get("language") or "pt")), format_func=language_label)
             style_options = ["Pexels/Pixabay", "full_ia", "Apenas Música"]
             style_value = {"pexels": "Pexels/Pixabay", "music": "Apenas Música"}.get(str(channel.get("style_wide") or "pexels"), str(channel.get("style_wide") or "Pexels/Pixabay"))
             edited_style = st.selectbox("Estilo wide", style_options, index=style_options.index(style_value) if style_value in style_options else 0)
@@ -1051,7 +1115,7 @@ def render_channels():
                 name = st.text_input("Nome do canal", value=imported.get("name", ""), key="yt_import_name")
                 url = st.text_input("URL", value=imported.get("url", source if source.startswith("http") else ""), key="yt_import_url")
                 handle = st.text_input("Handle", value=imported.get("handle", ""), key="yt_import_handle")
-                language = st.selectbox("Idioma", ["Português", "English", "Español", "Français", "Deutsch"], index=0, key="yt_import_language")
+                language = st.selectbox("Idioma", list(LANGUAGE_CODES), index=list(LANGUAGE_CODES).index(language_code(imported.get("language") or "pt")), format_func=language_label, key="yt_import_language")
                 style = st.selectbox("Estilo wide", ["Pexels/Pixabay", "full_ia", "Apenas Música"], index=0, key="yt_import_style")
                 blueprint = st.selectbox("Blueprint padrão do canal", blueprint_ids, index=blueprint_ids.index(imported_blueprint) if imported_blueprint in blueprint_ids else 0, format_func=lambda item: blueprint_labels.get(item, item or "Sem Blueprint padrão"), key="yt_import_blueprint")
                 voice_options = voice_catalog(imported.get("default_voice") or imported.get("voice", ""))
@@ -1154,7 +1218,7 @@ def render_channels():
                     with defaults_cols[1]:
                         batch_voice = st.selectbox("Voz padrão", voice_options, format_func=lambda item: item or "Sem voz padrão", key="batch_channel_voice")
                     with defaults_cols[2]:
-                        batch_language = st.selectbox("Idioma", ["Português", "English", "Español", "Français", "Deutsch"], key="batch_channel_language")
+                        batch_language = st.selectbox("Idioma", list(LANGUAGE_CODES), index=list(LANGUAGE_CODES).index("pt"), format_func=language_label, key="batch_channel_language")
                     with defaults_cols[3]:
                         batch_style = st.selectbox("Estilo wide", ["Pexels/Pixabay", "full_ia", "Apenas Música"], key="batch_channel_style")
                     import_selected = st.form_submit_button("Cadastrar canais seleccionados", type="primary", use_container_width=True)
@@ -1200,7 +1264,7 @@ def render_channels():
             handle = st.text_input("Handle", placeholder="@seucanal", key="manual_channel_handle")
             description = st.text_area("Descrição", key="manual_channel_description")
             niche = st.text_input("Canais de Referência / Nicho", placeholder="Ex.: História militar, mistérios, ciência", key="manual_channel_niche")
-            language = st.selectbox("Idioma", ["Português", "English", "Español", "Français", "Deutsch"], index=0, key="manual_channel_language")
+            language = st.selectbox("Idioma", list(LANGUAGE_CODES), index=list(LANGUAGE_CODES).index("pt"), format_func=language_label, key="manual_channel_language")
             style = st.selectbox("Estilo wide", ["Pexels/Pixabay", "full_ia", "Apenas Música"], index=0, key="manual_channel_style")
             manual_blueprint_items = blueprint_catalog()
             manual_blueprint_ids = [item[0] for item in manual_blueprint_items]
@@ -1360,10 +1424,11 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
             )
             mode = {"Canal específico": "single", "Lote no mesmo canal": "same_channel", "Lote geral": "general"}[mode_label]
             selected_one: dict[str, Any] | None = None
-            legacy_language = st.session_state.get("video_language")
-            legacy_language_map = {"Português": "36 – Português (Brasil)", "English": "01 – Inglês", "Español": "41 – Espanhol (LatAm)"}
-            if legacy_language not in VIDEO_LANGUAGE_OPTIONS:
-                st.session_state["video_language"] = legacy_language_map.get(legacy_language, VIDEO_LANGUAGE_OPTIONS[0])
+            legacy_language = st.session_state.get("video_language") or read_json("settings.json", {}).get("video_language")
+            if str(legacy_language or "").strip().casefold() in {"music", "00 – apenas música de fundo (sem falas)", "00 - apenas música de fundo (sem falas)"}:
+                st.session_state["video_language"] = "music"
+            else:
+                st.session_state["video_language"] = language_code(legacy_language or "pt")
             generation_settings: dict[str, Any] = {}
             if mode == "general":
                 selected = [str(channel["id"]) for channel in all_channels if channel.get("id")]
@@ -1624,6 +1689,7 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                 fmt = generation_settings["video_format"]
                 submitted = st.form_submit_button("Criar tarefas", type="primary")
             if submitted:
+                save_video_language(language)
                 style = {"Pexels/Pixabay": "pexels", "full_ia": "full_ia", "Apenas Música": "music"}[wide_style_label]
                 if style == "music" and not music_path:
                     st.error("Escolha, carregue ou gere uma música antes de criar o vídeo Apenas Música.")
@@ -1752,7 +1818,7 @@ def render_scripts():
         legacy_script_language = str(st.session_state.get("script_language") or "")
         script_settings = render_video_generation_settings(
             "pipeline_scripts",
-            current_language=legacy_script_language if legacy_script_language in VIDEO_LANGUAGE_OPTIONS else "",
+            current_language=legacy_script_language or str(read_json("settings.json", {}).get("video_language") or "pt"),
         )
         language = script_settings["script_language"]
         structure_notes = script_settings["script_structure_notes"]
@@ -2722,11 +2788,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 +2876,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",
@@ -3956,13 +4096,16 @@ def main():
     if current_page not in {item[0] for item in top_pages + pipeline_items + pipeline_tiktok_items + automation_items + edition_items + models_ai_items + niche_finder_items + settings_items}:
         current_page = "Início"
     st.session_state["page"] = current_page
+    ui_language = current_ui_language()
+    render_ui_language_picker(ui_language)
 
     def navigate(target: str):
         st.session_state["page"] = target
         st.rerun()
 
     def render_nav_button(target: str, icon: str, label: str, *, child: bool = False):
-        if st.button(label, key=f"nav_{target}", icon=icon, use_container_width=True, type="primary" if current_page == target else "secondary"):
+        display_label = ui_text(label, ui_language)
+        if st.button(display_label, key=f"nav_{target}", icon=icon, use_container_width=True, type="primary" if current_page == target else "secondary"):
             navigate(target)
 
     with st.sidebar:
@@ -3970,31 +4113,31 @@ def main():
         st.markdown(f'<div class="tb-brand"><span class="tb-brand-name">Thunderbolt</span>{version_markup}</div>', unsafe_allow_html=True)
         for target, icon, label in top_pages:
             if target == "Pipeline":
-                with st.expander("Pipeline", expanded=current_page in {item[0] for item in pipeline_items}, icon=":material/account_tree:"):
+                with st.expander(ui_text("Pipeline", ui_language), expanded=current_page in {item[0] for item in pipeline_items}, icon=":material/account_tree:"):
                     for child_target, child_icon, child_label in pipeline_items:
                         render_nav_button(child_target, child_icon, child_label, child=True)
             elif target == "Pipeline TikTok":
-                with st.expander("Pipeline TikTok", expanded=current_page in {item[0] for item in pipeline_tiktok_items}, icon=":material/video_library:"):
+                with st.expander(ui_text("Pipeline TikTok", ui_language), expanded=current_page in {item[0] for item in pipeline_tiktok_items}, icon=":material/video_library:"):
                     for child_target, child_icon, child_label in pipeline_tiktok_items:
                         render_nav_button(child_target, child_icon, child_label, child=True)
             elif target == "Automação":
-                with st.expander("Automação", expanded=current_page in {item[0] for item in automation_items}, icon=":material/schedule:"):
+                with st.expander(ui_text("Automação", ui_language), expanded=current_page in {item[0] for item in automation_items}, icon=":material/schedule:"):
                     for child_target, child_icon, child_label in automation_items:
                         render_nav_button(child_target, child_icon, child_label, child=True)
             elif target == "Edição":
-                with st.expander("Edição", expanded=current_page in {item[0] for item in edition_items}, icon=":material/edit:"):
+                with st.expander(ui_text("Edição", ui_language), expanded=current_page in {item[0] for item in edition_items}, icon=":material/edit:"):
                     for child_target, child_icon, child_label in edition_items:
                         render_nav_button(child_target, child_icon, child_label, child=True)
             elif target == "AI Influencers":
-                with st.expander("AI Influencers", expanded=current_page in {item[0] for item in models_ai_items}, icon=":material/smart_toy:"):
+                with st.expander(ui_text("AI Influencers", ui_language), expanded=current_page in {item[0] for item in models_ai_items}, icon=":material/smart_toy:"):
                     for child_target, child_icon, child_label in models_ai_items:
                         render_nav_button(child_target, child_icon, child_label, child=True)
             elif target == "Niche Finder":
-                with st.expander("Niche Finder", expanded=current_page in {item[0] for item in niche_finder_items}, icon=":material/search:"):
+                with st.expander(ui_text("Niche Finder", ui_language), expanded=current_page in {item[0] for item in niche_finder_items}, icon=":material/search:"):
                     for child_target, child_icon, child_label in niche_finder_items:
                         render_nav_button(child_target, child_icon, child_label, child=True)
             elif target == "Configurações":
-                with st.expander("Configurações", expanded=current_page in {item[0] for item in settings_items}, icon=":material/settings:"):
+                with st.expander(ui_text("Configurações", ui_language), expanded=current_page in {item[0] for item in settings_items}, icon=":material/settings:"):
                     for child_target, child_icon, child_label in settings_items:
                         render_nav_button(child_target, child_icon, child_label, child=True)
             else:

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/languages.py

@@ -0,0 +1,197 @@
+"""Canonical UI and video language catalog shared by Thunderbolt screens."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+# The persisted value is always the short MoneyPrinterTurbo-compatible code.
+LANGUAGE_CATALOG: tuple[dict[str, str], ...] = (
+    {"code": "en", "name": "Inglês", "flag": "🇺🇸", "locale": "en-US"},
+    {"code": "zh", "name": "Chinês Simplificado", "flag": "🇨🇳", "locale": "zh-CN"},
+    {"code": "de", "name": "Alemão", "flag": "🇩🇪", "locale": "de-DE"},
+    {"code": "vi", "name": "Vietnamita", "flag": "🇻🇳", "locale": "vi-VN"},
+    {"code": "tr", "name": "Turco", "flag": "🇹🇷", "locale": "tr-TR"},
+    {"code": "pt", "name": "Português", "flag": "🇧🇷", "locale": "pt-BR"},
+    {"code": "ru", "name": "Russo", "flag": "🇷🇺", "locale": "ru-RU"},
+    {"code": "es", "name": "Espanhol", "flag": "🇪🇸", "locale": "es-ES"},
+    {"code": "id", "name": "Indonésio", "flag": "🇮🇩", "locale": "id-ID"},
+    {"code": "it", "name": "Italiano", "flag": "🇮🇹", "locale": "it-IT"},
+)
+
+LANGUAGE_BY_CODE = {item["code"]: item for item in LANGUAGE_CATALOG}
+LANGUAGE_CODES = tuple(item["code"] for item in LANGUAGE_CATALOG)
+
+# Legacy labels used by existing channels, scripts and tests.  They remain
+# readable while new UI selections persist only the canonical short code.
+LEGACY_LANGUAGE_CODES = {
+    "01 – inglês": "en",
+    "01 - inglês": "en",
+    "06 – alemão": "de",
+    "06 - alemão": "de",
+    "15 – italiano": "it",
+    "15 - italiano": "it",
+    "29 – turco": "tr",
+    "29 - turco": "tr",
+    "31 – russo": "ru",
+    "31 - russo": "ru",
+    "36 – português (brasil)": "pt",
+    "36 - português (brasil)": "pt",
+    "39 – mandarim": "zh",
+    "39 - mandarim": "zh",
+    "13 – espanhol (espanha)": "es",
+    "41 - espanhol (latam)": "es",
+    "42 – vietnamita": "vi",
+    "42 - vietnamita": "vi",
+    "44 – indonésio": "id",
+    "44 - indonésio": "id",
+    "13 – espanhol (espanha)": "es",
+    "13 - espanhol (espanha)": "es",
+    "37 – cantonês": "zh",
+    "37 - cantonês": "zh",
+    "english": "en",
+    "inglês": "en",
+    "inglés": "en",
+    "zh": "zh",
+    "chinês": "zh",
+    "chinês simplificado": "zh",
+    "deutsch": "de",
+    "alemão": "de",
+    "vietnamita": "vi",
+    "turco": "tr",
+    "português": "pt",
+    "português (brasil)": "pt",
+    "portuguese": "pt",
+    "ru": "ru",
+    "russo": "ru",
+    "español": "es",
+    "espanhol": "es",
+    "indonésio": "id",
+    "bahasa indonesia": "id",
+    "italiano": "it",
+}
+
+
+def language_code(value: Any, default: str = "pt") -> str:
+    """Normalize a canonical code or a legacy display label to a code."""
+    raw = str(value or "").strip()
+    if raw in LANGUAGE_BY_CODE:
+        return raw
+    lowered = raw.casefold()
+    if lowered in LEGACY_LANGUAGE_CODES:
+        return LEGACY_LANGUAGE_CODES[lowered]
+    for item in LANGUAGE_CATALOG:
+        if lowered in {item["name"].casefold(), item["locale"].casefold()}:
+            return item["code"]
+    return default if default in LANGUAGE_BY_CODE else "pt"
+
+
+def language_label(value: Any, *, include_code: bool = True) -> str:
+    """Return the visual label with the requested flag and optional code."""
+    code = language_code(value)
+    item = LANGUAGE_BY_CODE[code]
+    suffix = f" ({item['code']})" if include_code else ""
+    return f"{item['flag']} {item['name']}{suffix}"
+
+
+def language_option_labels(*, include_code: bool = True) -> list[str]:
+    return [language_label(item["code"], include_code=include_code) for item in LANGUAGE_CATALOG]
+
+
+def language_option_codes() -> list[str]:
+    return list(LANGUAGE_CODES)
+
+
+UI_TRANSLATIONS: dict[str, dict[str, str]] = {
+    "en": {
+        "Início": "Home", "Niche Finder": "Niche Finder", "Pipeline": "Pipeline", "Pipeline TikTok": "TikTok Pipeline",
+        "Automação": "Automation", "Edição": "Editing", "AI Influencers": "AI Influencers", "Configurações": "Settings",
+        "Criação de Vídeos": "Video Creation", "Criação de Músicas": "Music Creation", "Roteiros": "Scripts", "Upload": "Upload",
+        "Prompts Master": "Prompt Masters", "Contas TikTok": "TikTok Accounts", "Automação Youtube": "YouTube Automation",
+        "Canais Youtube": "YouTube Channels", "Blueprints Youtube": "YouTube Blueprints", "Contas Google": "Google Accounts",
+        "Configuração API": "API Configuration", "Notificações": "Notifications", "Niche Finder Kaggle": "Niche Finder Kaggle",
+        "Niche Finder Apify": "Niche Finder Apify", "Limpador de Metadados": "Metadata Cleaner", "Cortes": "Cuts",
+        "Editor Python": "Python Editor", "Download Mídia": "Media Download", "Personagens": "Characters", "Redes Sociais": "Social Networks",
+        "Tutorial Meta": "Meta Tutorial", "Idioma da interface": "Interface language",
+    },
+    "zh": {
+        "Início": "首页", "Pipeline": "视频流程", "Pipeline TikTok": "TikTok 流程", "Automação": "自动化", "Edição": "编辑", "Configurações": "设置",
+        "Criação de Vídeos": "视频创作", "Criação de Músicas": "音乐创作", "Roteiros": "脚本", "Upload": "上传", "Contas Google": "Google 账户", "Notificações": "通知", "Idioma da interface": "界面语言",
+    },
+    "de": {
+        "Início": "Startseite", "Pipeline": "Pipeline", "Pipeline TikTok": "TikTok-Pipeline", "Automação": "Automatisierung", "Edição": "Bearbeitung", "Configurações": "Einstellungen",
+        "Criação de Vídeos": "Videoerstellung", "Criação de Músicas": "Musikerstellung", "Roteiros": "Skripte", "Upload": "Upload", "Contas Google": "Google-Konten", "Notificações": "Benachrichtigungen", "Idioma da interface": "Oberflächensprache",
+    },
+    "vi": {
+        "Início": "Trang chủ", "Pipeline": "Quy trình", "Pipeline TikTok": "Quy trình TikTok", "Automação": "Tự động hóa", "Edição": "Chỉnh sửa", "Configurações": "Cài đặt",
+        "Criação de Vídeos": "Tạo video", "Criação de Músicas": "Tạo nhạc", "Roteiros": "Kịch bản", "Upload": "Tải lên", "Contas Google": "Tài khoản Google", "Notificações": "Thông báo", "Idioma da interface": "Ngôn ngữ giao diện",
+    },
+    "tr": {
+        "Início": "Ana sayfa", "Pipeline": "Akış", "Pipeline TikTok": "TikTok akışı", "Automação": "Otomasyon", "Edição": "Düzenleme", "Configurações": "Ayarlar",
+        "Criação de Vídeos": "Video oluşturma", "Criação de Músicas": "Müzik oluşturma", "Roteiros": "Senaryolar", "Upload": "Yükleme", "Contas Google": "Google hesapları", "Notificações": "Bildirimler", "Idioma da interface": "Arayüz dili",
+    },
+    "ru": {
+        "Início": "Главная", "Pipeline": "Конвейер", "Pipeline TikTok": "Конвейер TikTok", "Automação": "Автоматизация", "Edição": "Редактирование", "Configurações": "Настройки",
+        "Criação de Vídeos": "Создание видео", "Criação de Músicas": "Создание музыки", "Roteiros": "Сценарии", "Upload": "Загрузка", "Contas Google": "Аккаунты Google", "Notificações": "Уведомления", "Idioma da interface": "Язык интерфейса",
+    },
+    "es": {
+        "Início": "Inicio", "Pipeline": "Flujo", "Pipeline TikTok": "Flujo de TikTok", "Automação": "Automatización", "Edição": "Edición", "Configurações": "Configuración",
+        "Criação de Vídeos": "Creación de vídeos", "Criação de Músicas": "Creación de música", "Roteiros": "Guiones", "Upload": "Carga", "Contas Google": "Cuentas de Google", "Notificações": "Notificaciones", "Idioma da interface": "Idioma de la interfaz",
+    },
+    "id": {
+        "Início": "Beranda", "Pipeline": "Alur", "Pipeline TikTok": "Alur TikTok", "Automação": "Otomatisasi", "Edição": "Penyuntingan", "Configurações": "Pengaturan",
+        "Criação de Vídeos": "Pembuatan video", "Criação de Músicas": "Pembuatan musik", "Roteiros": "Skrip", "Upload": "Unggah", "Contas Google": "Akun Google", "Notificações": "Notifikasi", "Idioma da interface": "Bahasa antarmuka",
+    },
+    "it": {
+        "Início": "Home", "Pipeline": "Pipeline", "Pipeline TikTok": "Pipeline TikTok", "Automação": "Automazione", "Edição": "Modifica", "Configurações": "Impostazioni",
+        "Criação de Vídeos": "Creazione video", "Criação de Músicas": "Creazione musicale", "Roteiros": "Script", "Upload": "Caricamento", "Contas Google": "Account Google", "Notificações": "Notifiche", "Idioma da interface": "Lingua dell'interfaccia",
+    },
+    "pt": {},
+}
+
+
+def ui_text(value: str, language: Any = "pt") -> str:
+    code = language_code(language)
+    return UI_TRANSLATIONS.get(code, {}).get(value, value)
+
+
+def language_flag(value: Any) -> str:
+    return LANGUAGE_BY_CODE[language_code(value)]["flag"]
+
+
+def language_locale(value: Any) -> str:
+    return LANGUAGE_BY_CODE[language_code(value)]["locale"]
+
+
+def video_language_label(value: Any) -> str:
+    """Format a video-language value while preserving all historical options."""
+    raw = str(value or "").strip()
+    if raw.casefold() in {
+        "music",
+        "00 – apenas música de fundo (sem falas)",
+        "00 - apenas música de fundo (sem falas)",
+    }:
+        return "🎵 Apenas Música de Fundo (Sem Falas)"
+    normalized = language_code(raw, default="")
+    if normalized in LANGUAGE_BY_CODE and (raw.casefold() in LEGACY_LANGUAGE_CODES or raw in LANGUAGE_BY_CODE):
+        return language_label(normalized)
+    return raw
+
+
+def video_language_options() -> list[str]:
+    return ["music", *LANGUAGE_CODES]
+
+
+__all__ = [
+    "LANGUAGE_CATALOG",
+    "LANGUAGE_BY_CODE",
+    "LANGUAGE_CODES",
+    "language_code",
+    "language_flag",
+    "language_label",
+    "language_locale",
+    "language_option_codes",
+    "language_option_labels",
+    "video_language_label",
+    "video_language_options",
+]

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": "",
@@ -192,6 +193,8 @@ DEFAULTS: dict[str, Any] = {
         "log_level": "DEBUG",
         "listen_host": "127.0.0.1",
         "listen_port": 8080,
+        "ui_language": "pt",
+        "video_language": "pt",
         "video_source": "pexels",
         "match_materials_to_script": False,
         "endpoint": "",

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/moneyprinter_config.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Any
 
+from hermes_ui.languages import language_code
 from hermes_ui.material_sources import all_material_api_keys, selected_material_source
 
 try:
@@ -32,6 +33,7 @@ def build_moneyprinter_config(settings: dict[str, Any], existing: dict[str, Any]
     elevenlabs = dict(config.get("elevenlabs") or {})
     chatterbox = dict(config.get("chatterbox") or {})
     proxy = dict(config.get("proxy") or {})
+    ui = dict(config.get("ui") or {})
 
     app_map = {
         "llm_provider": "llm_provider",
@@ -123,6 +125,11 @@ def build_moneyprinter_config(settings: dict[str, Any], existing: dict[str, Any]
     app["video_source"] = selected_material_source(settings)
     config["app"] = app
 
+    ui["language"] = language_code(settings.get("ui_language", ui.get("language", "pt")))
+    requested_video_language = str(settings.get("video_language") or ui.get("video_language") or "").strip()
+    ui["video_language"] = "" if requested_video_language.casefold() == "music" else language_code(requested_video_language)
+    config["ui"] = ui
+
     whisper["model_size"] = settings.get("whisper_model_size", whisper.get("model_size", "large-v3"))
     whisper["device"] = settings.get("whisper_device", whisper.get("device", "cpu"))
     whisper["compute_type"] = settings.get("whisper_compute_type", whisper.get("compute_type", "int8"))

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.78",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "license": "MIT",
   "main": "scripts/cli.mjs",