@danhachuel/thunderbolt 0.2.17 → 0.2.19

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.17
+> **Versão deste manual:** 0.2.19
 > **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.17 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.19 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes @danhachuel/thunderbolt@0.2.17 install
+npx --yes @danhachuel/thunderbolt@0.2.19 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.
@@ -348,6 +348,8 @@ Na primeira execução, abra **Configurações** e reveja:
 | YouTube Data API Key | Permitir importar nome, handle e métricas públicas de canais |
 | YouTube OAuth Client ID | Identificar a aplicação OAuth 2.0 do Google para operações autenticadas |
 | YouTube OAuth Client Secret | Secret do mesmo cliente OAuth 2.0; não é a Data API Key |
+| YouTube upload principal | Lógica do `youtube-automation-agent` adaptada e executada dentro do Thunderbolt |
+| OAuth directo de redundância | Caminho alternativo accionado automaticamente se o agente falhar |
 | TikTok Client ID/Secret | Credenciais da aplicação; Redirect URI, scopes e autorização ficam no TikTok for Developers Playground |
 
 As chaves devem ser inseridas apenas na configuração local. Não as coloque no GitHub, no `package.json`, em blueprints ou em ficheiros de estado versionados.
@@ -359,14 +361,22 @@ Após iniciar a aplicação, valide o seguinte percurso:
 1. **Dashboard:** confirme que a UI abre e mostra o estado local.
 2. **Blueprints:** coloque um JSON em `~/.thunderbolt/storage/blueprints/importados/` (Windows: `%LOCALAPPDATA%\\THUNDERBOLT\storage\blueprints\importados\`) ou use o carregador da interface.
 3. **Brandings:** abra a subaba **Brandings** e confirme a listagem dos ficheiros JSON.
-4. **Canais:** cadastre um canal manualmente ou importe-o depois de configurar a YouTube Data API.
+4. **Canais:** em **Importar do YouTube**, use o método **Página pública — sem API Key** ou a Data API opcional; em **Cadastro manual**, preencha os dados sem qualquer consulta externa.
 5. **Novo vídeo:** teste primeiro o modo **Canal específico** e depois os modos de lote.
-6. **Vídeos:** verifique o estado `to_do` e os botões **Iniciar** e **Parar**.
-7. **Upload:** confirme os destinos configurados e os estados de pré-requisito.
+6. **Novo vídeo > Vídeos:** verifique o estado `to_do` e os botões **Iniciar** e **Parar** dentro da subaba.
+7. **Upload:** autorize primeiro o **youtube-automation-agent** na própria aba, confirme o estado **pronto para publicar**, preencha título/descrição/tags e publique um MP4 real. O botão **Autorizar fallback OAuth** existe apenas para redundância; a Data API Key é exclusivamente para consultas públicas.
 8. **Limpador de metadado:** suba um vídeo de terceiro, preencha título, preview, links, timestamps e tags, aplique a limpeza e descarregue a cópia limpa e o manifesto JSON. O original fica preservado e vídeos da aba Novo vídeo não são aceites nesta área.
 9. **Configurações:** confirme que os caminhos e credenciais estão locais e não aparecem no Git.
+10. **MCP:** confirme que Short Video Maker, AutoVio, OpenMontage e OpenCut aparecem com as portas padrão editáveis. O estado **Activo** é apenas uma preferência local; a detecção deve indicar **Não detectado** quando os serviços externos não estiverem instalados ou iniciados.
+11. **Skill MCP:** clique em **Guardar skill localmente** e confirme o ficheiro em `storage/skills/moneyprinterturbo-video.md`; opcionalmente use **Descarregar skill .md** para obter a cópia através do navegador.
 
-## 10. Limpador de metadado
+## MCP e integrações externas
+
+A aba **MCP** é um configurador local de quatro serviços opcionais. As portas iniciais são `3123` para Short Video Maker, `3001` para AutoVio, `8000` como referência editável para OpenMontage e `8787` para a API do OpenCut. A página consulta apenas `http://127.0.0.1:<porta>/` com timeout curto; não clona, instala ou inicia processos externos.
+
+O botão **Guardar skill localmente** copia a skill anexada para `storage/skills/`. Esta pasta fica fora dos estados JSON e é criada pelo instalador e pelo launcher. Os quatro repositórios continuam fora do pacote npm.
+
+## 11. Limpador de metadado
 
 A aba **Limpador de metadado** recebe somente vídeos externos já prontos. O ficheiro enviado é copiado para `storage/metadata_cleaner/originals/`; a aplicação não altera o original. Ao aplicar a operação, o FFmpeg remove os metadados existentes do contentor e cria uma nova versão em `storage/metadata_cleaner/outputs/` com o título, descrição, tags, idioma e outros campos preenchidos.
 
@@ -506,6 +516,8 @@ Nunca publique ou envie por chat:
 
 Use secrets do GitHub Actions apenas para publicação do pacote. Para execução local, mantenha credenciais fora do repositório e use a área de configurações local ou variáveis de ambiente.
 
+A publicação YouTube segue primeiro a lógica adaptada do `PublishingSchedulingAgent` do [youtube-automation-agent](https://github.com/darkzOGx/youtube-automation-agent), sob licença MIT. O código corre dentro do processo Streamlit; não é necessário iniciar o agente Node separadamente. O fallback OAuth directo só é chamado quando a tentativa primária falha.
+
 ## 14. Referências
 
 [1]: https://github.com/harry0703/MoneyPrinterTurbo/blob/main/README-en.md — MoneyPrinterTurbo: requisitos, instalação, dependências, Streamlit e FFmpeg.

package/README.md

@@ -14,10 +14,10 @@ A primeira versão implementa a camada UI independente com:
 | Pipeline | Filas por etapa |
 | Blueprints | 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 | Cadastro manual, importação via YouTube Data API quando configurada e edição de dados importados |
-| Novo vídeo | Canal específico, lote no mesmo canal e lote geral |
-| Vídeos | Filtro por estado e controlos iniciar/parar |
-| Upload | Destinos YouTube/TikTok e diagnóstico do TikTok |
+| Canais | Subabas de importação pública sem API Key, Data API opcional e cadastro manual independente |
+| Novo vídeo | Subabas Criar vídeo e Vídeos; canal específico, lote no mesmo canal, lote geral, filtro de estados e controlos iniciar/parar |
+| Upload | YouTube via `youtube-automation-agent` adaptado internamente, OAuth directo de redundância, TikTok e diagnóstico |
+| MCP | Catálogo local opcional de Short Video Maker, AutoVio, OpenMontage e OpenCut, com portas editáveis e activação |
 | Limpador de metadado | Upload isolado de vídeos terceiros, limpeza FFmpeg, edição de título/descrição/tags e manifesto JSON |
 | Configurações | Provedores LLM, TTS/voz, materiais, Whisper, FFmpeg, YouTube, TikTok Client ID/Secret e Upload-Post |
 | Launcher | Execução via `npx`, instalação assistida, diagnóstico e preparação para distribuição |
@@ -103,9 +103,9 @@ thunderbolt
 No Windows PowerShell, se `npx` for bloqueado por `npx.ps1`, use directamente `npx.cmd`:
 
 ```powershell
-npx.cmd --yes @danhachuel/thunderbolt@0.2.17 install
-npx.cmd --yes @danhachuel/thunderbolt@0.2.17 doctor
-npx.cmd --yes @danhachuel/thunderbolt@0.2.17
+npx.cmd --yes @danhachuel/thunderbolt@0.2.19 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.19 doctor
+npx.cmd --yes @danhachuel/thunderbolt@0.2.19
 ```
 
 Como alternativa, pode permitir scripts para o seu utilizador:
@@ -162,12 +162,33 @@ A descrição segue a composição do workflow de referência: preview, secção
 
 ## Canais YouTube
 
-Sem chave, o cadastro manual continua disponível. Para importar nome, handle e estatísticas através da API oficial do YouTube Data API, configure `youtube_api_key` na aba **Configurações** ou em `YOUTUBE_API_KEY`.
+A aba **Canais** está dividida em dois fluxos independentes. Em **Importar do YouTube**, o método padrão **Página pública — sem API Key** consulta a página pública do canal e preenche nome, ID, handle, URL, descrição e thumbnail quando esses dados estão disponíveis. A opção **YouTube Data API — API Key opcional** pode ser escolhida para métricas oficiais quando `youtube_api_key` estiver configurada em **Configurações** ou em `YOUTUBE_API_KEY`.
+
+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 e Blueprint associado. A importação pública nunca grava automaticamente: os dados aparecem num formulário de revisão antes de guardar.
+
+## Upload YouTube
+
+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.
+
+Na aba **Upload**, configure primeiro o **YouTube OAuth Client ID** e o **YouTube OAuth Client Secret** em **Configurações**. Em seguida, use **Autorizar agente YouTube**. O navegador local abrirá a autorização Google e o token será guardado apenas em `storage/state/youtube_agent_tokens.json`. Se a publicação principal falhar, o Thunderbolt tenta automaticamente o **OAuth directo de redundância**, usando o token local compatível; a Data API Key nunca é usada para publicar.
+
+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.
+
+## MCP e integrações externas opcionais
+
+A aba **MCP** funciona como um catálogo local de clientes externos. Ela lista **Short Video Maker**, **AutoVio**, **OpenMontage** e **OpenCut** com os respectivos links oficiais, protocolo/capacidade conhecida, porta local editável e toggle **Activo**. Os repositórios não são clonados, instalados ou incluídos no pacote npm do Thunderbolt.
+
+As portas iniciais são `3123` para Short Video Maker, `3001` para a API backend do AutoVio, `8000` como referência editável para OpenMontage — que não documenta uma porta HTTP padrão — e `8787` para a API do OpenCut, cujo frontend de desenvolvimento usa `5173`. A detecção é passiva: apenas consulta `localhost` e nunca inicia processos externos. Activar uma integração guarda a preferência local; não substitui a instalação/configuração do serviço externo.
+
+A mesma aba permite **Guardar skill localmente**, copiando `moneyprinterturbo-video.md` para `storage/skills/`, e **Descarregar skill .md** através do navegador. A skill é um recurso separado dos quatro repositórios externos.
 
 ## TikTok
 
-A aba **Configurações** contém apenas o TikTok Client ID e o TikTok Client Secret. Redirect URI, scopes, autorização OAuth e tokens são geridos no TikTok for Developers Playground. O adaptador rejeita o upload quando faltam credenciais ou OAuth, em vez de indicar sucesso falso.
+A subaba **Vídeos**, dentro de **Novo vídeo**, mostra o backlog e permite iniciar/parar tarefas; deixou de existir como botão principal na barra lateral.
+
+A aba **Configurações** contém apenas o TikTok Client ID e o TikTok Client Secret.
+ Redirect URI, scopes, autorização OAuth e tokens são geridos no TikTok for Developers Playground. O adaptador rejeita o upload quando faltam credenciais ou OAuth, em vez de indicar sucesso falso.
 
 ## Segurança
 
-Não coloque chaves, cookies, tokens YouTube ou segredos TikTok no Git. Use a configuração local, variáveis de ambiente ou um ficheiro fora do repositório. O `.gitignore` exclui o storage de estado real, ambientes virtuais e ficheiros de segredo.
+Não coloque chaves, cookies, tokens YouTube ou segredos TikTok no Git. Use a configuração local, variáveis de ambiente ou um ficheiro fora do repositório. O `.gitignore` exclui o storage de estado real, ambientes virtuais e ficheiros de segredo. O adaptador interno foi baseado na lógica publicada sob licença MIT do [youtube-automation-agent](https://github.com/darkzOGx/youtube-automation-agent).

package/app/main.py

@@ -18,10 +18,66 @@ from hermes_ui.domain import STAGES, create_batch, create_channel, create_tasks_
 from hermes_ui.storage import BLUEPRINTS, ensure_storage, list_blueprint_files, load_blueprint_file, now, read_json, write_json
 from hermes_ui.blueprints import create_blueprint_from_link, list_branding_files, save_generated_blueprint
 from hermes_ui.metadata_cleaner import build_description, clean_video_metadata, list_edit_records, metadata_manifest, normalize_tags, save_edit_record, store_external_video
-from integrations.platforms import TikTokAdapter, YouTubeAdapter
+from hermes_ui.mcp import detect_local_service, install_skill_locally, load_integrations, read_packaged_skill, update_integration
+from integrations.platforms import IntegrationResult, TikTokAdapter, YouTubeAdapter
 from integrations.local_runtime import MoneyPrinterRuntime
 from integrations.moneyprinter_config import sync_moneyprinter_config
 
+VIDEO_LANGUAGE_OPTIONS = [
+    "00 – Apenas Música de Fundo (Sem Falas)",
+    "01 – Inglês",
+    "02 – Norueguês",
+    "03 – Dinamarquês",
+    "04 – Sueco",
+    "05 – Holandês",
+    "06 – Alemão",
+    "07 – Luxemburguês",
+    "08 – Finlandês",
+    "09 – Hebraico",
+    "10 – Japonês",
+    "11 – Árabe (Golfo)",
+    "12 – Islandês",
+    "13 – Espanhol (Espanha)",
+    "14 – Francês",
+    "15 – Italiano",
+    "16 – Coreano",
+    "16 – Irlandês",
+    "17 – Estoniano",
+    "18 – Grego",
+    "19 – Esloveno",
+    "20 – Polonês",
+    "21 – Tcheco",
+    "22 – Lituano",
+    "23 – Português (Portugal)",
+    "24 – Eslovaco",
+    "25 – Letão",
+    "26 – Ucraniano",
+    "27 – Húngaro",
+    "28 – Afrikaans",
+    "29 – Turco",
+    "30 – Romeno",
+    "31 – Russo",
+    "32 – Croata",
+    "33 – Árabe (Magreb)",
+    "34 – Sérvio",
+    "35 – Búlgaro",
+    "36 – Português (Brasil)",
+    "37 – Cantonês",
+    "38 – Persa (Farsi)",
+    "39 – Mandarim",
+    "40 – Malaio",
+    "41 – Espanhol (LatAm)",
+    "42 – Vietnamita",
+    "43 – Filipino (Tagalog)",
+    "44 – Indonésio",
+    "45 – Malayalam",
+    "46 – Tailandês",
+    "47 – Télugo",
+    "48 – Tamil",
+    "49 – Bengali",
+    "50 – Hausa",
+]
+
 ensure_storage()
 st.set_page_config(page_title="Thunderbolt", page_icon="T", layout="wide", initial_sidebar_state="expanded")
 
@@ -194,38 +250,107 @@ def render_blueprints():
 
 def render_channels():
     st.title("Canais")
-    st.caption("Importação do YouTube com edição manual e armazenamento local")
-    with st.expander("Criar ou importar novo canal", expanded=True):
-        source = st.text_input("Nome, URL, handle ou ID do canal", placeholder="https://youtube.com/@seucanal")
+    st.caption("Escolha entre importar dados públicos do YouTube ou preencher o canal manualmente.")
+    settings = read_json("settings.json", {})
+    youtube = YouTubeAdapter(settings=settings)
+    import_tab, manual_tab = st.tabs(["Importar do YouTube", "Cadastro manual"])
+
+    with import_tab:
+        st.caption("A pesquisa pública funciona sem API Key. A Data API é opcional e fica disponível numa opção separada para métricas oficiais.")
+        source = st.text_input("URL, handle ou ID do canal", placeholder="https://youtube.com/@seucanal", key="youtube_channel_source")
+        lookup_mode = st.radio("Método de consulta", ["Página pública — sem API Key", "YouTube Data API — API Key opcional"], horizontal=True, key="youtube_channel_lookup_mode")
         col1, col2 = st.columns([1, 1])
         with col1:
-            if st.button("Buscar no YouTube", type="primary", use_container_width=True):
-                result = YouTubeAdapter(read_json("settings.json", {}).get("youtube_api_key", "")).fetch_channel(source)
+            if st.button("Buscar no YouTube", type="primary", use_container_width=True, key="youtube_channel_lookup"):
+                if lookup_mode.startswith("Página pública"):
+                    result = youtube.fetch_channel_public(source)
+                elif not youtube.api_key:
+                    result = IntegrationResult(False, "A YouTube Data API Key não está configurada. Escolha a opção Página pública — sem API Key ou configure a chave em Configurações.", {"status": "api_key_not_configured"})
+                else:
+                    result = youtube.fetch_channel(source)
                 st.session_state["yt_import"] = result.data
                 st.session_state["yt_message"] = result.message
                 st.session_state["yt_ok"] = result.ok
         with col2:
-            if st.button("Limpar importação", use_container_width=True):
-                st.session_state.pop("yt_import", None)
+            if st.button("Limpar importação", use_container_width=True, key="youtube_channel_clear"):
+                for key in ("yt_import", "yt_message", "yt_ok"):
+                    st.session_state.pop(key, None)
+                st.rerun()
         if st.session_state.get("yt_message"):
             (st.success if st.session_state.get("yt_ok") else st.warning)(st.session_state["yt_message"])
         imported = st.session_state.get("yt_import", {})
-        with st.form("channel_form"):
-            name = st.text_input("Nome do canal", value=imported.get("name", ""))
-            url = st.text_input("URL", value=source if source.startswith("http") else imported.get("url", ""))
-            handle = st.text_input("Handle", value=imported.get("handle", ""))
-            language = st.selectbox("Idioma", ["Português", "English", "Español", "Français", "Deutsch"], index=0)
-            style = st.selectbox("Estilo wide", ["pexels", "full_ia"], index=0)
-            blueprint = st.text_input("Blueprint associado", value="")
-            submitted = st.form_submit_button("Guardar canal", type="primary")
+        if imported:
+            st.caption("Dados encontrados. Reveja ou edite os campos antes de guardar.")
+            with st.form("channel_import_form"):
+                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")
+                style = st.selectbox("Estilo wide", ["pexels", "full_ia"], index=0, key="yt_import_style")
+                blueprint = st.text_input("Blueprint associado", value="", key="yt_import_blueprint")
+                description = st.text_area("Descrição", value=imported.get("description", ""), key="yt_import_description")
+                metrics = st.columns(3)
+                with metrics[0]: subscriber_count = st.number_input("Inscritos", min_value=0, value=int(imported.get("subscriber_count") or 0), key="yt_import_subscribers")
+                with metrics[1]: video_count = st.number_input("Vídeos", min_value=0, value=int(imported.get("video_count") or 0), key="yt_import_videos")
+                with metrics[2]: view_count = st.number_input("Visualizações", min_value=0, value=int(imported.get("view_count") or 0), key="yt_import_views")
+                submitted = st.form_submit_button("Guardar canal importado", type="primary")
+                if submitted:
+                    if not name.strip():
+                        st.error("Informe o nome do canal antes de guardar.")
+                    else:
+                        metadata = {
+                            **imported,
+                            "handle": handle.strip(),
+                            "description": description.strip(),
+                            "language": language,
+                            "style_wide": style,
+                            "blueprint_id": blueprint.strip(),
+                            "subscriber_count": int(subscriber_count) or None,
+                            "video_count": int(video_count) or None,
+                            "view_count": int(view_count) or None,
+                            "metrics_source": imported.get("metrics_source", "youtube_public_page"),
+                        }
+                        channel = create_channel(name, url, metadata)
+                        st.success(f"Canal {channel['name']} guardado.")
+                        st.rerun()
+        else:
+            st.info("Introduza um URL, handle ou ID e clique em Buscar no YouTube. Não é necessária API Key na opção pública.")
+
+    with manual_tab:
+        st.caption("Este fluxo não consulta o YouTube e não exige API Key. Preencha os dados que quiser e guarde o canal localmente.")
+        with st.form("channel_manual_form"):
+            name = st.text_input("Nome do canal", key="manual_channel_name")
+            url = st.text_input("URL do canal", placeholder="https://youtube.com/@seucanal", key="manual_channel_url")
+            handle = st.text_input("Handle", placeholder="@seucanal", key="manual_channel_handle")
+            description = st.text_area("Descrição", key="manual_channel_description")
+            language = st.selectbox("Idioma", ["Português", "English", "Español", "Français", "Deutsch"], index=0, key="manual_channel_language")
+            style = st.selectbox("Estilo wide", ["pexels", "full_ia"], index=0, key="manual_channel_style")
+            blueprint = st.text_input("Blueprint associado", key="manual_channel_blueprint")
+            thumbnail_url = st.text_input("URL da imagem do canal", key="manual_channel_thumbnail")
+            metrics = st.columns(3)
+            with metrics[0]: subscriber_count = st.number_input("Inscritos", min_value=0, value=0, key="manual_channel_subscribers")
+            with metrics[1]: video_count = st.number_input("Vídeos", min_value=0, value=0, key="manual_channel_videos")
+            with metrics[2]: view_count = st.number_input("Visualizações", min_value=0, value=0, key="manual_channel_views")
+            submitted = st.form_submit_button("Guardar canal manual", type="primary")
             if submitted:
                 if not name.strip():
                     st.error("Informe o nome do canal.")
                 else:
-                    metadata = {"handle": handle, "language": language, "style_wide": style, "blueprint_id": blueprint, **imported}
-                    channel = create_channel(name, url, metadata)
-                    st.success(f"Canal {channel['name']} guardado.")
+                    channel = create_channel(name, url, {
+                        "handle": handle.strip(),
+                        "description": description.strip(),
+                        "language": language,
+                        "style_wide": style,
+                        "blueprint_id": blueprint.strip(),
+                        "thumbnail_url": thumbnail_url.strip(),
+                        "subscriber_count": int(subscriber_count) or None,
+                        "video_count": int(video_count) or None,
+                        "view_count": int(view_count) or None,
+                        "metrics_source": "manual",
+                    })
+                    st.success(f"Canal {channel['name']} guardado manualmente.")
                     st.rerun()
+
     st.subheader("Canais cadastrados")
     channels = read_json("channels.json", [])
     if not channels:
@@ -241,7 +366,7 @@ def render_channels():
                     st.markdown("### YT")
             with cols[1]:
                 st.write(f"**{channel.get('name', 'Sem nome')}**")
-                st.caption(f"{channel.get('handle') or channel.get('url') or 'sem URL'}")
+                st.caption(f"{channel.get('handle') or channel.get('url') or 'sem URL'} · {channel.get('metrics_source', 'manual')}")
             with cols[2]: st.metric("Inscritos", channel.get("subscriber_count") if channel.get("subscriber_count") is not None else "—")
             with cols[3]: st.metric("Vídeos", channel.get("video_count") if channel.get("video_count") is not None else "—")
             with cols[4]: st.metric("Backlog", channel.get("backlog_total", 0))
@@ -253,41 +378,54 @@ def render_channels():
 
 def render_new_video():
     st.title("Novo vídeo")
-    channels = channel_options()
-    if not channels:
-        st.warning("Cadastre pelo menos um canal antes de criar vídeos.")
-        return
-    mode_label = st.radio("Modo de criação", ["Canal específico", "Lote no mesmo canal", "Lote geral"], horizontal=True)
-    mode = {"Canal específico": "single", "Lote no mesmo canal": "same_channel", "Lote geral": "general"}[mode_label]
-    if mode == "general":
-        selected = st.multiselect("Canais incluídos", [c["id"] for c in channels], default=[c["id"] for c in channels], format_func=lambda cid: next(c["name"] for c in channels if c["id"] == cid))
-    else:
-        selected_one = st.selectbox("Canal", channels, format_func=lambda c: c["name"])
-        selected = [selected_one["id"]]
-    with st.form("new_video_form"):
-        topic = st.text_area("Tópico ou briefing", placeholder="Ex.: A história pouco conhecida por trás de...")
-        quantity = st.number_input("Quantidade", min_value=1, max_value=100, value=1, disabled=mode != "same_channel")
-        language = st.selectbox("Idioma", ["Português", "English", "Español"], key="video_language")
-        fmt = st.selectbox("Formato", ["wide", "shorts", "music"])
-        style = st.selectbox("Estilo wide", ["pexels", "full_ia"])
-        submitted = st.form_submit_button("Criar tarefas", type="primary")
-    if submitted:
-        if not topic.strip() or not selected:
-            st.error("Informe um tópico e seleccione pelo menos um canal.")
+    create_tab, videos_tab = st.tabs(["Criar vídeo", "Vídeos"])
+    with create_tab:
+        channels = channel_options()
+        if not channels:
+            st.warning("Cadastre pelo menos um canal antes de criar vídeos.")
         else:
-            quantity = int(quantity if mode == "same_channel" else 1)
-            batch = create_batch(mode, selected, topic, quantity, {"language": language, "format": fmt, "style_wide": style})
-            tasks = create_tasks_for_batch(batch)
-            st.success(f"Lote {batch['id']} criado com {len(tasks)} tarefa(s).")
+            mode_label = st.radio("Modo de criação", ["Canal específico", "Lote no mesmo canal", "Lote geral"], horizontal=True, key="new_video_mode")
+            mode = {"Canal específico": "single", "Lote no mesmo canal": "same_channel", "Lote geral": "general"}[mode_label]
+            if mode == "general":
+                selected = st.multiselect("Canais incluídos", [c["id"] for c in channels], default=[c["id"] for c in channels], format_func=lambda cid: next(c["name"] for c in channels if c["id"] == cid), key="new_video_channels_general")
+            else:
+                selected_one = st.selectbox("Canal", channels, format_func=lambda c: c["name"], key="new_video_channel")
+                selected = [selected_one["id"]]
+            with st.form("new_video_form"):
+                topic = st.text_area("Tópico ou briefing", placeholder="Ex.: A história pouco conhecida por trás de...")
+                quantity = st.number_input("Quantidade", min_value=1, max_value=100, value=1, disabled=mode != "same_channel")
+                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])
+                language = st.selectbox("Idioma", VIDEO_LANGUAGE_OPTIONS, key="video_language")
+                fmt = st.selectbox("Formato", ["wide", "shorts", "music"])
+                style = st.selectbox("Estilo wide", ["pexels", "full_ia"])
+                submitted = st.form_submit_button("Criar tarefas", type="primary")
+            if submitted:
+                if not topic.strip() or not selected:
+                    st.error("Informe um tópico e seleccione pelo menos um canal.")
+                else:
+                    quantity = int(quantity if mode == "same_channel" else 1)
+                    batch = create_batch(mode, selected, topic, quantity, {"language": language, "format": fmt, "style_wide": style})
+                    tasks = create_tasks_for_batch(batch)
+                    st.success(f"Lote {batch['id']} criado com {len(tasks)} tarefa(s). Abra a subaba Vídeos para acompanhar.")
+    with videos_tab:
+        render_videos()
 
 
 def render_videos():
-    st.title("Vídeos e backlog")
+    st.subheader("Vídeos e backlog")
+    st.caption("Acompanhamento dos vídeos criados, estados da pipeline e controlos de execução.")
     tasks = read_json("tasks.json", [])
     if not tasks:
         st.info("Nenhum vídeo criado.")
         return
-    state_filter = st.selectbox("Filtrar por estado", ["Todos", "to_do", "doing", "blocked", "done", "failed", "cancelled"])
+    state_filter = st.selectbox("Filtrar por estado", ["Todos", "to_do", "doing", "blocked", "done", "failed", "cancelled"], key="videos_state_filter")
     for task in tasks:
         if state_filter != "Todos" and task.get("state") != state_filter:
             continue
@@ -311,10 +449,32 @@ def render_videos():
 
 def render_upload():
     st.title("Upload")
+    settings = read_json("settings.json", {})
+    youtube = YouTubeAdapter(settings=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"], default=["YouTube"])
+
+    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.")
+        status = youtube.upload_status()
+        status_cols = st.columns(2)
+        with status_cols[0]:
+            (st.success if status["agent"].ok else st.warning)(f"Agente: {status['agent'].message}")
+            if st.button("Autorizar agente YouTube", key="youtube_authorize_agent", use_container_width=True):
+                result = youtube.authorize_agent()
+                (st.success if result.ok else st.error)(result.message)
+                if result.ok:
+                    st.rerun()
+        with status_cols[1]:
+            (st.info if status["fallback"].ok else st.caption)(f"Fallback OAuth: {status['fallback'].message}")
+            if st.button("Autorizar fallback OAuth", key="youtube_authorize_fallback", use_container_width=True):
+                result = youtube.authorize_fallback()
+                (st.success if result.ok else st.error)(result.message)
+                if result.ok:
+                    st.rerun()
     if "TikTok" in destination:
-        status = TikTokAdapter(read_json("settings.json", {})).status()
+        status = TikTokAdapter(settings).status()
         (st.success if status.ok else st.warning)(status.message)
     if not tasks:
         st.info("Não há vídeos prontos para upload.")
@@ -322,14 +482,53 @@ def render_upload():
     for task in tasks:
         with st.container(border=True):
             st.write(f"**{task.get('topic')}** — {task.get('channel_name')}")
-            video_path = task.get("artifacts", {}).get("video", "")
+            artifacts = task.get("artifacts", {}) or {}
+            video_path = artifacts.get("video", "")
+            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")
-            if st.button("Preparar upload", key=f"upload_{task['id']}"):
-                if "TikTok" in destination:
-                    result = TikTokAdapter(read_json("settings.json", {})).upload_video(video_path, task.get("topic", ""))
-                    (st.success if result.ok else st.warning)(result.message)
-                else:
-                    st.info("Upload YouTube preparado; configure o uploader local para executar a publicação.")
+            if "YouTube" in destination:
+                title = st.text_input("Título", value=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)
+                tags_raw = st.text_input("Tags separadas por vírgula", value=task.get("tags", "") if isinstance(task.get("tags", ""), str) else ", ".join(task.get("tags", [])), key=f"yt_tags_{task['id']}")
+                yt_cols = st.columns(3)
+                with yt_cols[0]:
+                    privacy_status = st.selectbox("Privacidade", ["private", "unlisted", "public"], key=f"yt_privacy_{task['id']}")
+                with yt_cols[1]:
+                    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']}"):
+                    tags = [tag.strip() for tag in tags_raw.split(",") if tag.strip()]
+                    result = youtube.upload_video(
+                        video_path,
+                        title=title,
+                        description=description,
+                        tags=tags,
+                        category_id=category_id,
+                        language=language,
+                        privacy_status=privacy_status,
+                        thumbnail_path=thumbnail_path,
+                        captions_path=captions_path,
+                    )
+                    record = {
+                        "task_id": task.get("id"),
+                        "destination": "YouTube",
+                        "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)
+                    if result.data.get("attempts"):
+                        with st.expander("Detalhes dos mecanismos de upload"):
+                            st.json(result.data["attempts"])
+            if "TikTok" in destination and st.button("Enviar para TikTok", key=f"upload_tiktok_{task['id']}"):
+                result = TikTokAdapter(settings).upload_video(video_path, task.get("topic", ""))
+                (st.success if result.ok else st.warning)(result.message)
 
 
 def render_settings():
@@ -485,6 +684,77 @@ def render_settings():
                 st.warning(f"Configurações locais guardadas, mas não foi possível sincronizar config.toml: {exc}")
 
 
+def render_mcp():
+    st.title("MCP")
+    st.caption("Clientes opcionais para serviços externos. Os repositórios não são instalados nem incluídos no pacote Thunderbolt.")
+    st.info("Activar uma integração guarda apenas a preferência local. O Thunderbolt não inicia processos externos automaticamente; a detecção verifica passivamente se existe um serviço já disponível na porta configurada.")
+
+    integrations = load_integrations()
+    for integration in integrations:
+        integration_id = integration["id"]
+        with st.container(border=True):
+            header_cols = st.columns([2.6, 1.15, 1.65, 1.2])
+            with header_cols[0]:
+                st.write(f"**{integration['name']}**")
+                st.caption(f"{integration['protocol']} · {integration['description']}")
+                st.markdown(f"[Abrir repositório oficial]({integration['repository']})")
+            with header_cols[1]:
+                port = st.number_input(
+                    "Porta",
+                    min_value=1,
+                    max_value=65535,
+                    value=int(integration.get("port", 8000)),
+                    step=1,
+                    key=f"mcp_port_{integration_id}",
+                )
+            with header_cols[2]:
+                status = detect_local_service({**integration, "port": port})
+                if status["available"]:
+                    st.success("Disponível")
+                else:
+                    st.caption("Não detectado")
+                st.caption(status["message"])
+            with header_cols[3]:
+                active = st.toggle("Activo", value=bool(integration.get("active", False)), key=f"mcp_active_{integration_id}")
+                if active != bool(integration.get("active", False)):
+                    update_integration(integration_id, active=active)
+                    st.rerun()
+
+            st.caption(integration.get("endpoint_note", "Porta editável para o serviço local."))
+            if st.button("Guardar porta", key=f"mcp_save_port_{integration_id}", use_container_width=True):
+                update_integration(integration_id, port=int(port))
+                st.success(f"Porta de {integration['name']} guardada: {int(port)}")
+                st.rerun()
+
+    st.divider()
+    st.subheader("Skill MoneyPrinterTurbo")
+    st.caption("A skill anexada pode ser guardada na pasta local do Thunderbolt ou descarregada como ficheiro Markdown. Nenhum dos quatro repositórios externos é copiado para o pacote.")
+    skill_cols = st.columns(2)
+    with skill_cols[0]:
+        if st.button("Guardar skill localmente", type="primary", use_container_width=True, key="mcp_install_mpt_skill"):
+            try:
+                destination = install_skill_locally()
+                st.success(f"Skill guardada em `{destination}`")
+            except (FileNotFoundError, OSError) as exc:
+                st.error(f"Não foi possível guardar a skill: {exc}")
+    with skill_cols[1]:
+        try:
+            skill_data = read_packaged_skill()
+        except FileNotFoundError:
+            skill_data = None
+        if skill_data is not None:
+            st.download_button(
+                "Descarregar skill .md",
+                data=skill_data,
+                file_name="moneyprinterturbo-video.md",
+                mime="text/markdown",
+                use_container_width=True,
+                key="mcp_download_mpt_skill",
+            )
+        else:
+            st.warning("A skill ainda não está disponível nesta instalação.")
+
+
 def render_metadata_cleaner():
     st.title("Limpador de metadado")
     st.caption("Limpeza e edição de metadados para vídeos de terceiros que já estão prontos.")
@@ -620,12 +890,15 @@ def main():
         ("Blueprints", ":material/library_books:", "Blueprints"),
         ("Canais", ":material/ondemand_video:", "Canais"),
         ("Novo vídeo", ":material/add_circle:", "Novo vídeo"),
-        ("Vídeos", ":material/video_library:", "Vídeos"),
         ("Upload", ":material/cloud_upload:", "Upload"),
+        ("MCP", ":material/hub:", "MCP"),
         ("Limpador de metadado", ":material/edit_note:", "Limpador de metadado"),
         ("Configurações", ":material/settings:", "Configurações"),
     ]
     current_page = st.session_state.get("page", "Dashboard")
+    if current_page == "Vídeos":
+        current_page = "Novo vídeo"
+        st.session_state["page"] = current_page
     with st.sidebar:
         version_markup = f'<span class="tb-brand-version">{APP_VERSION}</span>' if APP_VERSION else ""
         st.markdown(f'<div class="tb-brand"><span class="tb-brand-name">Thunderbolt</span>{version_markup}</div>', unsafe_allow_html=True)
@@ -639,8 +912,8 @@ def main():
         "Blueprints": render_blueprints,
         "Canais": render_channels,
         "Novo vídeo": render_new_video,
-        "Vídeos": render_videos,
         "Upload": render_upload,
+        "MCP": render_mcp,
         "Limpador de metadado": render_metadata_cleaner,
         "Configurações": render_settings,
     }