@danhachuel/thunderbolt 0.2.26 → 0.2.28

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.26
+> **Versão deste manual:** 0.2.28
 > **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.26 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.28 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes @danhachuel/thunderbolt@0.2.26 install
+npx --yes @danhachuel/thunderbolt@0.2.28 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.
@@ -339,7 +339,7 @@ Set-ExecutionPolicy -Scope CurrentUser RemoteSigned
 
 ## 8. Configuração inicial da UI
 
-Na primeira execução, abra **Configurações** e reveja. Para YouTube, preencha primeiro o par **OAuth Client ID + OAuth Client Secret** se pretende autorizar uploads. A **YouTube Data API Key** é uma credencial Google Cloud diferente e fica numa área opcional, apenas para o método oficial de métricas; Client ID + Client Secret não formam uma API Key.
+Na primeira execução, a barra lateral apresenta **Início**, **Pipeline**, **Automação**, **Niche Finder** e **Configurações**. Abra **Configurações > Configurações Técnicas** e reveja. O menu **Pipeline** contém **Criação de Vídeos**, **Criação de Músicas**, **Upload** e **Limpador de Metadados**. O menu **Configurações** contém **Canais**, **Blueprints**, **MCP** e **Configurações Técnicas**. Para YouTube, preencha primeiro o par **OAuth Client ID + OAuth Client Secret** se pretende autorizar uploads. A **YouTube Data API Key** é uma credencial Google Cloud diferente e fica numa área opcional, apenas para o método oficial de métricas; Client ID + Client Secret não formam uma API Key.
 
 | Configuração | Finalidade |
 |---|---|
@@ -358,29 +358,30 @@ As credenciais devem ser inseridas apenas na configuração local. A Data API Ke
 
 Após iniciar a aplicação, valide o seguinte percurso:
 
-1. **Dashboard:** confirme que a UI abre e mostra o estado local.
+1. **Início:** confirme que a UI abre, mostra o estado local, as métricas e os cards das filas do Pipeline, sem botões de acções rápidas.
 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:** em **Importar do YouTube**, use o método **Página pública — sem API Key** com um URL `/channel/UC...`, um handle ou uma subpágina `/videos`; o parser resolve o ID, consulta a página pública e tenta o RSS quando necessário. Confirme que o resultado abre o formulário de revisão sem Data API Key. Se o canal não existir ou não fornecer metadados, confirme a mensagem clara e que o formulário de uma pesquisa anterior desaparece. A Data API é opcional e fica separada; 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. **Novo vídeo > Vídeos:** verifique o estado `to_do` e os botões **Iniciar** e **Parar** dentro da subaba.
+5. **Pipeline > Criação de Vídeos:** teste primeiro o modo **Canal específico** e depois os modos de lote.
+6. **Criação de Vídeos > Vídeos:** verifique o estado `to_do` e os botões **Iniciar** e **Parar** dentro da subaba. Confirme também que **Criação de Músicas** mostra o mesmo fluxo com título próprio.
 7. **Upload:** configure o OAuth Client ID e Secret, 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, se configurada, é exclusivamente para consultas oficiais públicas e nunca substitui OAuth.
-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. **Novo vídeo:** confirme que `Pexels/Pixabay` substitui o label antigo, que `Estilo IA` aparece apenas em `full_ia` e que `Apenas Música` exige áudio e guarda `background_mode=none`.
+8. **Pipeline > Limpador de Metadados:** 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 das páginas de criação não são aceites nesta área.
+9. **Configurações > Configurações Técnicas:** confirme que os caminhos e credenciais estão locais e não aparecem no Git.
+10. **Criação de Vídeos:** confirme que `Pexels/Pixabay` substitui o label antigo, que `Estilo IA` aparece apenas em `full_ia` e que `Apenas Música` exige áudio e guarda `background_mode=none`.
 11. **Automação:** no cartão de cada canal, escolha o **Blueprint padrão** e a **Voz padrão**, clique em `Guardar` e confirme que o resumo do cartão se actualiza. Configure também **Automação ON** e um horário `HH:MM`; confirme a lista de vídeos cadastrados. Os mesmos defaults aparecem em **Canais** e são usados em novas tarefas. A UI não inicia jobs em segundo plano nesta entrega.
-12. **Teste de vozes:** em Configurações, teste Edge/Azure ou provider configurado e confirme reprodução/download sem criação de tarefa.
+12. **Configurações > Configurações Técnicas > Teste de vozes:** teste Edge/Azure ou provider configurado e confirme reprodução/download sem criação de tarefa.
 13. **Upload directo:** configure manualmente cookies, sessionInfo e INNERTUBE_API_KEY, atribua o `DELEGATED_SESSION_ID` no canal e teste apenas com um vídeo de validação. O método envia chunks de 256 KiB e não extrai cookies do navegador.
-14. **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.
-15. **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.
+14. **Configurações > MCP > Client MCP:** confirme que Short Video Maker, AutoVio, OpenMontage e OpenCut aparecem com as portas padrão editáveis. O estado **Activo** é uma preferência local; a detecção deve indicar **Não detectado** quando os serviços externos não estiverem instalados ou iniciados.
+15. **Configurações > MCP > Servidor MCP:** abra a subaba, mantenha o host `127.0.0.1`, active **Servidor MCP ON** e clique em **Guardar e iniciar Servidor MCP**. Confirme o endpoint `/mcp` e o health endpoint `/health`. Mantenha **Permitir ferramentas de escrita** desactivado até precisar que um agente crie lotes.
+16. **Configurações > MCP > Skill:** 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.
 
-## Novo vídeo, Automação e música
+## Pipeline: Criação de Vídeos, Criação de Músicas e Automação
 
 O modo `Pexels/Pixabay` representa materiais de stock. Ao seleccionar `full_ia`, o selector `Estilo IA` apresenta os 12 estilos disponíveis. Ao seleccionar `Apenas Música`, a UI obriga a escolher uma música existente, carregar um ficheiro ou solicitar uma música a um endpoint Suno configurado. O vídeo recebe `background_mode=none`, sem fundo Pexels/Pixabay ou IA.
 
 A aba **Automação** lista os canais e vídeos, permite escolher e guardar **Blueprint padrão** e **Voz padrão** por canal, guarda **Automação ON** e valida horários diários no formato `HH:MM`. Os valores ficam sincronizados com o editor existente no cartão da aba **Canais** e são copiados para novas tarefas. É apenas uma camada de UI nesta versão, sem execução de worker.
 
-A área **Teste de vozes**, dentro de Configurações, é 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.
+A área **Teste de vozes**, dentro de **Configurações > Configurações Técnicas**, é isolada da pipeline. O preview pode ser reproduzido e descarregado de `storage/voice_previews/`. Caminhos vazios, directórios, ficheiros vazios e previews sem permissões de leitura são ignorados com uma mensagem clara, sem traceback. Se uma instalação antiga mostrar que `edge-tts` está em falta, execute `npx.cmd --yes @danhachuel/thunderbolt install`; o detector reinstala apenas a dependência ausente.
 
 ## Upload directo
 
@@ -388,17 +389,19 @@ A subaba **Upload directo** adapta o [YouTube-Video-Upload-Frontend-Api](https:/
 
 ## 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.
+A subaba **Client MCP**, em **Configurações > 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.
+A subaba **Servidor MCP**, em **Configurações > MCP**, disponibiliza, após activação explícita, `http://127.0.0.1:3031/mcp` por JSON-RPC sobre HTTP POST. Para configurar um agente compatível, use esse URL como endpoint MCP. Se o host for alterado para uma interface externa, preencha primeiro um token e trate-o como segredo. O servidor disponibiliza ferramentas de leitura por padrão; a criação de lotes só é exposta quando **Permitir ferramentas de escrita** está activado.
 
-## 12. Limpador de metadado
+A subaba **Skill**, em **Configurações > MCP**, contém as acções para guardar a skill anexada em `storage/skills/` ou descarregá-la como Markdown. Esta pasta fica fora dos estados JSON e é criada pelo instalador e pelo launcher. Os quatro repositórios continuam fora do pacote npm.
 
-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.
+## 12. Limpador de Metadados
+
+A aba **Limpador de Metadados** 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.
 
 A descrição combina **Preview**, **Links** e **Timestamps**, seguindo a estrutura do workflow `YTBMetadataGenerator.json`. O preview recomendado tem entre 100 e 200 caracteres; os capítulos devem começar por `00:00`. O manifesto JSON descarregado contém os campos para um fluxo posterior de upload. Esta adaptação local não faz scraping automático via RSS/Apify nem publica directamente no YouTube.
 
-Se a limpeza falhar, confirme a disponibilidade do FFmpeg em **Configurações > Caminho FFmpeg** ou execute `doctor`. O processo usa `-map_metadata -1` para remover os metadados existentes e `-c copy` para evitar uma re-encodificação desnecessária sempre que o contentor permitir.
+Se a limpeza falhar, confirme a disponibilidade do FFmpeg em **Configurações > Configurações Técnicas > Caminho FFmpeg** ou execute `doctor`. O processo usa `-map_metadata -1` para remover os metadados existentes e `-c copy` para evitar uma re-encodificação desnecessária sempre que o contentor permitir.
 
 ## 11. Problemas frequentes
 

package/README.md

@@ -10,21 +10,25 @@ A primeira versão implementa a camada UI independente com:
 
 | Área | Incluído |
 |---|---|
-| Dashboard | Resumo de canais, tarefas, backlog, execução e falhas |
-| Pipeline | Filas por etapa |
+| Início | Resumo de canais, tarefas, backlog, execução e falhas, com as filas do Pipeline inline |
+| Pipeline | Menu expansível com Criação de Vídeos, Criação de Músicas, Upload e Limpador de Metadados |
 | 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 | 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; lotes; 51 rótulos de idioma; Pexels/Pixabay, full IA com Estilo IA e Apenas Música com agente musical |
+| 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 |
 | Automação | Lista de vídeos e canais, selectores editáveis de Blueprint/voz padrão, Automação ON e horário diário HH:MM; UI configurável sem worker em segundo plano |
 | Upload | YouTube via `youtube-automation-agent` adaptado internamente, OAuth directo de redundância, Upload directo experimental, TikTok, Instagram e Facebook Pages no front end |
 | MCP | Catálogo local opcional de Short Video Maker, AutoVio, OpenMontage e OpenCut, com portas editáveis e activação |
-| 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, preview de vozes, Suno, materiais, Whisper, FFmpeg, OAuth YouTube, Data API Key opcional, Upload directo, TikTok Client ID/Secret e Upload-Post |
+| Limpador de Metadados | Upload isolado de vídeos terceiros, limpeza FFmpeg, edição de título/descrição/tags e manifesto JSON |
+| Configurações Técnicas | Provedores LLM, TTS/voz, preview de vozes, Suno, materiais, Whisper, FFmpeg, OAuth YouTube, Data API Key opcional, Upload directo, TikTok Client ID/Secret e Upload-Post |
 | Launcher | Execução via `npx`, instalação assistida, diagnóstico e preparação para distribuição |
 
 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.28
+
+A barra lateral mantém apenas os cinco níveis principais, nesta ordem: **Início**, **Pipeline**, **Automação**, **Niche Finder** e **Configurações**. **Pipeline** é expansível e contém **Criação de Vídeos**, **Criação de Músicas**, **Upload** e **Limpador de Metadados**. **Configurações** é expansível e contém **Canais**, **Blueprints**, **MCP** e **Configurações Técnicas**. O Início reúne o dashboard e as filas do Pipeline, sem botões de acções rápidas. Niche Finder permanece como placeholder vazio nesta versão.
+
 ## Instalação
 
 Recomenda-se Python 3.11 ou superior e Node.js 18 ou superior.
@@ -104,9 +108,9 @@ thunderbolt
 No Windows PowerShell, se `npx` for bloqueado por `npx.ps1`, use directamente `npx.cmd`:
 
 ```powershell
-npx.cmd --yes @danhachuel/thunderbolt@0.2.26 install
-npx.cmd --yes @danhachuel/thunderbolt@0.2.26 doctor
-npx.cmd --yes @danhachuel/thunderbolt@0.2.26
+npx.cmd --yes @danhachuel/thunderbolt@0.2.28 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.28 doctor
+npx.cmd --yes @danhachuel/thunderbolt@0.2.28
 ```
 
 Como alternativa, pode permitir scripts para o seu utilizador:
@@ -159,9 +163,9 @@ A mesma aba possui a subaba **Brandings**. No formulário **Criar blueprint a pa
 
 O fluxo foi modelado a partir do blueprint de clonagem com Branding anexado, incluindo a distinção entre entrada de canal/vídeo, normalização do link, metadados de nicho/idioma, perfil do canal, estratégia de conteúdo, pesquisa, identidade visual e brand pack. Placeholders de serviços externos são tratados como configuração local; chaves presentes em workflows importados não devem ser commitadas.
 
-## Limpador de metadado
+## Limpador de Metadados
 
-A aba **Limpador de metadado** foi adaptada do workflow `YTBMetadataGenerator.json`. Ela recebe apenas um vídeo externo já pronto, guarda uma cópia original separada, remove os metadados do contentor com FFmpeg e grava uma nova cópia com título, descrição, links, timestamps, tags e outros campos opcionais. O original nunca é alterado e os vídeos produzidos pela aba **Novo vídeo** não aparecem nesta área.
+A aba **Limpador de Metadados** foi adaptada do workflow `YTBMetadataGenerator.json`. Ela recebe apenas um vídeo externo já pronto, guarda uma cópia original separada, remove os metadados do contentor com FFmpeg e grava uma nova cópia com título, descrição, links, timestamps, tags e outros campos opcionais. O original nunca é alterado e os vídeos produzidos pelas páginas **Criação de Vídeos** e **Criação de Músicas** não aparecem nesta área.
 
 A descrição segue a composição do workflow de referência: preview, secção de links e capítulos/timestamps. O resultado inclui um manifesto JSON para utilizar os metadados num fluxo posterior de upload. A versão local não usa o trigger RSS, o Apify ou a actualização automática de um vídeo YouTube; em vez disso, o utilizador fornece directamente o vídeo terceiro e controla a edição antes de publicar.
 
@@ -181,29 +185,34 @@ Use **Autorizar fallback OAuth** apenas se precisar de uma autorização separad
 
 A subaba **Upload directo** adapta o [YouTube-Video-Upload-Frontend-Api](https://github.com/Nojus10/YouTube-Video-Upload-Frontend-Api). Ela usa cookies, `sessionInfo`, `INNERTUBE_API_KEY` e `DELEGATED_SESSION_ID` fornecidos manualmente pelo utilizador, cria o vídeo através do endpoint interno e envia o ficheiro em chunks de 256 KiB. Este caminho é experimental, não extrai cookies automaticamente e fica separado do agente YouTube principal.
 
-## Novo vídeo, Automação e música
+## Pipeline: Criação de Vídeos, Criação de Músicas e Automação
 
-Em **Novo vídeo**, o estilo visual `Pexels/Pixabay` é o modo de materiais, `full_ia` abre o selector **Estilo IA** com os 12 estilos solicitados e **Apenas Música** exige um áudio local, um upload musical ou um pedido ao endpoint Suno configurado. Neste último modo, a task fica com `background_mode=none`: não são gerados fundos Pexels/Pixabay nem fundos IA.
+Em **Criação de Vídeos**, o estilo visual `Pexels/Pixabay` é o modo de materiais, `full_ia` abre o selector **Estilo IA** com os 12 estilos solicitados e **Apenas Música** exige um áudio local, um upload musical ou um pedido ao endpoint Suno configurado. **Criação de Músicas** reutiliza o mesmo conteúdo e formulário com título próprio. Neste último modo, a task fica com `background_mode=none`: não são gerados fundos Pexels/Pixabay nem fundos IA.
 
 O agente musical guarda os ficheiros em `storage/music/`, aceita formatos de áudio comuns e pode descarregar uma URL de áudio devolvida por um endpoint Suno compatível. Em **Canais**, abra **Definir Blueprint e voz padrão** no cartão do canal para guardar os defaults; em **Automação**, os mesmos dois selectores aparecem no cartão e são sincronizados. Esses valores são usados automaticamente em novas tarefas criadas para o canal. A aba **Automação** também guarda `Automação ON` e um horário diário `HH:MM` por canal e lista os vídeos cadastrados; por definição, esta entrega não executa workers de fundo.
 
 ## Teste de vozes
 
-A área **Configurações > Teste de vozes** é isolada da pipeline. Permite escolher Edge/Azure Speech ou um provider HTTP configurado, seleccionar voz/ID, alterar a velocidade, sintetizar uma amostra, reproduzi-la e descarregá-la. O áudio é guardado em `storage/voice_previews/` e nunca altera vídeos ou tarefas. Se uma instalação antiga não tiver `edge-tts`, execute `npx.cmd --yes @danhachuel/thunderbolt install`; o instalador detecta a dependência em falta sem reinstalar componentes válidos.
+A área **Configurações > Configurações Técnicas > Teste de vozes** é isolada da pipeline.
+ Permite escolher Edge/Azure Speech ou um provider HTTP configurado, seleccionar voz/ID, alterar a velocidade, sintetizar uma amostra, reproduzi-la e descarregá-la. O áudio é guardado em `storage/voice_previews/` e nunca altera vídeos ou tarefas. Se uma instalação antiga não tiver `edge-tts`, execute `npx.cmd --yes @danhachuel/thunderbolt install`; o instalador detecta a dependência em falta sem reinstalar componentes válidos.
 
 ## 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.
+A aba **MCP** está organizada em três subabas independentes. **Client MCP** lista **Short Video Maker**, **AutoVio**, **OpenMontage** e **OpenCut** com links oficiais, protocolo/capacidade conhecida, porta local editável, detecção passiva e toggle **Activo**. Os repositórios externos 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 do Client MCP apenas consulta `localhost` e nunca inicia processos externos.
+
+**Servidor MCP** activa, mediante confirmação explícita na UI, um endpoint local em `http://127.0.0.1:3031/mcp`. O endpoint usa JSON-RPC sobre HTTP POST, disponibiliza ferramentas de leitura para estado da pipeline, canais, vídeos e Blueprints e exige um token quando o host é exposto fora do computador local. As ferramentas de escrita ficam desactivadas por padrão; quando o utilizador as activa, o agente pode criar lotes de vídeos através de uma ferramenta controlada. O endpoint `/health` serve apenas para verificação de disponibilidade.
 
-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.
+**Skill** contém exclusivamente os botões para guardar localmente ou descarregar `moneyprinterturbo-video.md`. A skill é guardada em `storage/skills/` e não é misturada com o catálogo de clientes MCP.
 
-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 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 subaba **Vídeos**, dentro de **Criação de Vídeos** ou **Criação de Músicas**, 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 para TikTok. Para YouTube, o bloco principal pede o OAuth Client ID e Client Secret; a Data API Key, se usada, fica numa área opcional separada. Client ID + Client Secret não formam uma Data API Key nem um token OAuth.
+A página **Configurações Técnicas** contém apenas o TikTok Client ID e o TikTok Client Secret para TikTok.
+ Para YouTube, o bloco principal pede o OAuth Client ID e Client Secret; a Data API Key, se usada, fica numa área opcional separada. Client ID + Client Secret não formam uma Data API Key nem um token OAuth.
  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

package/app/main.py

@@ -20,7 +20,8 @@ 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 hermes_ui.mcp import detect_local_service, install_skill_locally, load_integrations, read_packaged_skill, update_integration
+from hermes_ui.mcp import detect_local_service, install_skill_locally, load_integrations, load_server_config, read_packaged_skill, save_server_config, update_integration
+from hermes_ui.mcp_server import server_status, start_server, stop_server
 from hermes_ui.music import list_music_files, materialize_suno_audio, request_suno_generation, store_music_file
 from hermes_ui.voice_preview import DEFAULT_SAMPLE, load_preview_file, synthesize_preview
 from integrations.platforms import IntegrationResult, TikTokAdapter, YouTubeAdapter
@@ -124,6 +125,13 @@ st.markdown("""
 [data-testid="stSidebar"] [data-testid="stBaseButton-primary"]:hover { background:#343434; color:#ffffff; }
 [data-testid="stSidebar"] [data-testid="stBaseButton-primary"] span { color:#ffffff; }
 [data-testid="stSidebar"] [data-testid="stBaseButton-secondary"] span { color:#e7edf2; }
+[data-testid="stSidebar"] [data-testid="stExpander"] { border:0 !important; background:transparent !important; margin:0.02rem 0 !important; }
+[data-testid="stSidebar"] [data-testid="stExpander"] details { border:0 !important; background:transparent !important; }
+[data-testid="stSidebar"] [data-testid="stExpander"] summary { min-height:1.72rem; padding:0.10rem 0.52rem !important; border-radius:7px; color:#e7edf2; font-size:0.86rem; font-weight:650; }
+[data-testid="stSidebar"] [data-testid="stExpander"] summary:hover { background:#1c252e; }
+[data-testid="stSidebar"] [data-testid="stExpander"] summary p { margin:0; line-height:1; }
+[data-testid="stSidebar"] [data-testid="stExpander"] > div { padding:0 0 0 0.42rem !important; }
+[data-testid="stSidebar"] [data-testid="stExpander"] > div [data-testid="stButton"] button { padding-left:0.92rem; font-size:0.83rem; min-height:1.62rem; height:1.62rem; }
 .content-card { padding: 1rem 1.1rem; border:1px solid #20384d; border-radius:14px; background:rgba(18,27,38,.92); min-height:110px; }
 .content-label { color:#8ba6bb; font-size:.8rem; text-transform:uppercase; letter-spacing:.07em; }
 .content-value { color:#f4f8fb; font-size:1.8rem; font-weight:700; margin-top:.3rem; }
@@ -211,27 +219,18 @@ def render_dashboard():
         with col:
             card(label, value, note)
     st.divider()
-    left, right = st.columns([1.5, 1])
-    with left:
-        st.subheader("Pipeline")
-        tasks = read_json("tasks.json", [])
-        counts = {stage: sum(1 for t in tasks if t.get("stage") == stage and t.get("state") not in {"done", "cancelled"}) for stage in STAGES}
-        for stage in STAGES:
-            st.markdown(f'<div class="stage"><strong>{stage.title()}</strong> <span class="small-muted">{counts[stage]} tarefa(s)</span></div>', unsafe_allow_html=True)
-    with right:
-        st.subheader("Acções rápidas")
-        if st.button("Criar novo vídeo", use_container_width=True):
-            st.session_state["page"] = "Novo vídeo"
-            st.rerun()
-        if st.button("Importar canal", use_container_width=True):
-            st.session_state["page"] = "Canais"
-            st.rerun()
-        if st.button("Abrir Blueprints", use_container_width=True):
-            st.session_state["page"] = "Blueprints"
-            st.rerun()
-        if st.button("Abrir Upload", use_container_width=True):
-            st.session_state["page"] = "Upload"
-            st.rerun()
+    st.subheader("Pipeline")
+    st.caption("Filas locais e dependências da cascata")
+    queues = read_json("queues.json", {})
+    blueprint_count = len(list_blueprint_files())
+    for row_start in range(0, len(STAGES), 3):
+        queue_cols = st.columns(3)
+        for col, stage in zip(queue_cols, STAGES[row_start:row_start + 3]):
+            with col:
+                if stage == "blueprint":
+                    card("Blueprints", blueprint_count, f"na biblioteca · {len(queues.get(stage, []))} tarefa(s) na fila")
+                else:
+                    card(stage.title(), len(queues.get(stage, [])), "fila")
 
 
 def render_blueprints():
@@ -536,8 +535,8 @@ def render_channels():
                     st.rerun()
 
 
-def render_new_video():
-    st.title("Novo vídeo")
+def render_new_video(page_title: str = "Criação de Vídeos"):
+    st.title(page_title)
     create_tab, videos_tab = st.tabs(["Criar vídeo", "Vídeos"])
     with create_tab:
         channels = channel_options()
@@ -622,6 +621,16 @@ def render_new_video():
         render_videos()
 
 
+def render_music_creation():
+    """Expose the complete video-creation UI under the music-oriented navigation entry without changing the original page."""
+    render_new_video(page_title="Criação de Músicas")
+
+
+def render_niche_finder():
+    st.title("Niche Finder")
+    st.info("Esta área está reservada para o Niche Finder e será implementada numa próxima etapa.")
+
+
 def render_videos():
     st.subheader("Vídeos e backlog")
     st.caption("Acompanhamento dos vídeos criados, estados da pipeline e controlos de execução.")
@@ -869,7 +878,7 @@ def render_upload_conventional():
 
 
 def render_settings():
-    st.title("Configurações do Thunderbolt")
+    st.title("Configurações Técnicas")
     st.caption("Configuração do motor de vídeo e dos serviços usados pelo Thunderbolt. As credenciais ficam no storage local e não são enviadas para o GitHub.")
     settings = read_json("settings.json", {})
 
@@ -1077,77 +1086,145 @@ def render_settings():
 
 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.")
+    st.caption("Clientes externos, servidor MCP do Thunderbolt e a skill local ficam separados para evitar confundir funções diferentes.")
+
+    client_tab, server_tab, skill_tab = st.tabs(["Client MCP", "Servidor MCP", "Skill"])
+
+    with client_tab:
+        st.subheader("Client MCP")
+        st.info("Configure aqui os serviços MCP externos que o Thunderbolt pode detectar passivamente. Activar uma integração guarda apenas a preferência; não instala nem inicia processos externos.")
+        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()
 
-    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.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.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"):
+    with server_tab:
+        st.subheader("Servidor MCP")
+        st.caption("Servidor local do Thunderbolt para ser descoberto por um agente compatível com MCP. O endpoint usa JSON-RPC sobre HTTP POST em `/mcp`.")
+        st.warning("Por segurança, o servidor inicia apenas quando o activar explicitamente. Por padrão fica acessível somente neste computador em 127.0.0.1:3031.")
+        server_config = load_server_config()
+        if server_config.get("enabled") and not server_status().get("running"):
             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",
+                start_server(
+                    str(server_config.get("host", "127.0.0.1")),
+                    int(server_config.get("port", 3031)),
+                    str(server_config.get("auth_token", "")),
+                    bool(server_config.get("write_enabled", False)),
+                )
+            except Exception as exc:
+                st.error(f"Não foi possível iniciar o Servidor MCP guardado: {exc}")
+
+        server_cols = st.columns([1.3, 1.4, 1.4])
+        with server_cols[0]:
+            server_enabled = st.checkbox("Servidor MCP ON", value=bool(server_config.get("enabled", False)), key="mcp_server_enabled")
+        with server_cols[1]:
+            server_host = st.text_input("Host", value=str(server_config.get("host", "127.0.0.1")), key="mcp_server_host", help="Use 127.0.0.1 para acesso local. Um host externo exige token.")
+        with server_cols[2]:
+            server_port = st.number_input("Porta do servidor", min_value=1, max_value=65535, value=int(server_config.get("port", 3031)), step=1, key="mcp_server_port")
+        server_token = st.text_input("Token de acesso MCP (opcional no localhost)", value=str(server_config.get("auth_token", "")), type="password", key="mcp_server_token")
+        write_enabled = st.checkbox("Permitir ferramentas de escrita", value=bool(server_config.get("write_enabled", False)), key="mcp_server_write", help="Desactivado por padrão. Quando activo, o agente pode criar lotes de vídeos através de uma ferramenta MCP; leituras continuam disponíveis sem esta opção.")
+        if str(server_host).strip() not in {"127.0.0.1", "localhost", "::1"} and not str(server_token).strip():
+            st.error("Para expor o servidor fora do computador local, defina um token de acesso MCP.")
+
+        action_label = "Guardar e iniciar Servidor MCP" if server_enabled else "Guardar e parar Servidor MCP"
+        if st.button(action_label, type="primary", key="mcp_server_save", use_container_width=True):
+            try:
+                saved = save_server_config(enabled=server_enabled, host=server_host, port=int(server_port), auth_token=server_token, write_enabled=write_enabled)
+                if saved["enabled"]:
+                    status = start_server(saved["host"], saved["port"], saved["auth_token"], saved["write_enabled"])
+                    st.success(f"Servidor MCP activo em `{status['endpoint']}`")
+                else:
+                    stop_server()
+                    st.success("Servidor MCP parado.")
+                st.rerun()
+            except Exception as exc:
+                st.error(f"Não foi possível guardar/iniciar o Servidor MCP: {exc}")
+
+        runtime = server_status()
+        if runtime.get("running"):
+            st.success(f"Servidor MCP activo: `{runtime['endpoint']}`")
+            st.code(
+                json.dumps(
+                    {
+                        "endpoint": runtime["endpoint"],
+                        "health": runtime["health_endpoint"],
+                        "transport": "Streamable HTTP / JSON-RPC POST",
+                        "write_tools": runtime["write_enabled"],
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                ),
+                language="json",
             )
+            st.caption("Use o endpoint `/mcp` na configuração do agente. O endpoint `/health` serve apenas para verificar se o servidor está activo. Não partilhe o token.")
         else:
-            st.warning("A skill ainda não está disponível nesta instalação.")
+            st.info("Servidor MCP parado. As configurações ficam guardadas localmente e só são usadas depois de clicar em Guardar e iniciar.")
+        st.markdown("**Ferramentas disponibilizadas**")
+        st.write("Leitura: estado da pipeline, canais, vídeos e Blueprints. Ferramentas de escrita: criação de lotes de vídeos, apenas quando a opção de escrita estiver activada pelo utilizador.")
+
+    with skill_tab:
+        st.subheader("Skill")
+        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.title("Limpador de Metadados")
     st.caption("Limpeza e edição de metadados para vídeos de terceiros que já estão prontos.")
     st.warning("Esta área aceita exclusivamente vídeos externos. Vídeos criados na aba Novo vídeo não são listados nem processados aqui.")
 
@@ -1275,43 +1352,74 @@ def render_pipeline():
 
 
 def main():
-    pages = [
-        ("Dashboard", ":material/home:", "Início"),
-        ("Pipeline", ":material/account_tree:", "Pipeline"),
-        ("Blueprints", ":material/library_books:", "Blueprints"),
-        ("Canais", ":material/ondemand_video:", "Canais"),
-        ("Novo vídeo", ":material/add_circle:", "Novo vídeo"),
-        ("Automação", ":material/schedule:", "Automação"),
+    pipeline_items = [
+        ("Criação de Vídeos", ":material/add_circle:", "Criação de Vídeos"),
+        ("Criação de Músicas", ":material/music_note:", "Criação de Músicas"),
         ("Upload", ":material/cloud_upload:", "Upload"),
+        ("Limpador de Metadados", ":material/edit_note:", "Limpador de Metadados"),
+    ]
+    settings_items = [
+        ("Canais", ":material/ondemand_video:", "Canais"),
+        ("Blueprints", ":material/library_books:", "Blueprints"),
         ("MCP", ":material/hub:", "MCP"),
-        ("Limpador de metadado", ":material/edit_note:", "Limpador de metadado"),
+        ("Configurações Técnicas", ":material/settings:", "Configurações Técnicas"),
+    ]
+    top_pages = [
+        ("Início", ":material/home:", "Início"),
+        ("Pipeline", ":material/account_tree:", "Pipeline"),
+        ("Automação", ":material/schedule:", "Automação"),
+        ("Niche Finder", ":material/search:", "Niche Finder"),
         ("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
+    aliases = {
+        "Dashboard": "Início",
+        "Novo vídeo": "Criação de Vídeos",
+        "Vídeos": "Criação de Vídeos",
+        "Limpador de metadado": "Limpador de Metadados",
+        "Configurações Técnicas": "Configurações Técnicas",
+    }
+    current_page = aliases.get(st.session_state.get("page", "Início"), st.session_state.get("page", "Início"))
+    if current_page not in {item[0] for item in top_pages + pipeline_items + settings_items}:
+        current_page = "Início"
+    st.session_state["page"] = current_page
+
+    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"):
+            navigate(target)
+
     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)
-        for target, icon, label in pages:
-            if st.button(label, key=f"nav_{target}", icon=icon, use_container_width=True, type="primary" if current_page == target else "secondary"):
-                st.session_state["page"] = target
-                st.rerun()
+        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:"):
+                    for child_target, child_icon, child_label in pipeline_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:"):
+                    for child_target, child_icon, child_label in settings_items:
+                        render_nav_button(child_target, child_icon, child_label, child=True)
+            else:
+                render_nav_button(target, icon, label)
+
     renderers = {
-        "Dashboard": render_dashboard,
-        "Pipeline": render_pipeline,
-        "Blueprints": render_blueprints,
-        "Canais": render_channels,
-        "Novo vídeo": render_new_video,
+        "Início": render_dashboard,
+        "Criação de Vídeos": render_new_video,
+        "Criação de Músicas": render_music_creation,
         "Automação": render_automation,
+        "Niche Finder": render_niche_finder,
         "Upload": render_upload,
+        "Limpador de Metadados": render_metadata_cleaner,
+        "Canais": render_channels,
+        "Blueprints": render_blueprints,
         "MCP": render_mcp,
-        "Limpador de metadado": render_metadata_cleaner,
-        "Configurações": render_settings,
+        "Configurações Técnicas": render_settings,
     }
     renderers.get(current_page, render_dashboard)()
 
-
 if __name__ == "__main__":
     main()

package/hermes_ui/mcp.py

@@ -9,6 +9,13 @@ from . import storage
 
 
 SKILL_FILENAME = "moneyprinterturbo-video.md"
+MCP_SERVER_DEFAULTS: dict[str, Any] = {
+    "enabled": False,
+    "host": "127.0.0.1",
+    "port": 3031,
+    "auth_token": "",
+    "write_enabled": False,
+}
 
 MCP_DEFAULTS: list[dict[str, Any]] = [
     {
@@ -72,6 +79,36 @@ def _merge_defaults(saved: Any) -> list[dict[str, Any]]:
     return merged
 
 
+def load_server_config() -> dict[str, Any]:
+    saved = storage.read_json("mcp_server.json", MCP_SERVER_DEFAULTS)
+    config = {**MCP_SERVER_DEFAULTS, **(saved if isinstance(saved, dict) else {})}
+    config["enabled"] = bool(config.get("enabled", False))
+    config["write_enabled"] = bool(config.get("write_enabled", False))
+    config["host"] = str(config.get("host", "127.0.0.1") or "127.0.0.1").strip()
+    config["auth_token"] = str(config.get("auth_token", "") or "").strip()
+    try:
+        config["port"] = max(1, min(65535, int(config.get("port", 3031))))
+    except (TypeError, ValueError):
+        config["port"] = 3031
+    return config
+
+
+def save_server_config(**updates: Any) -> dict[str, Any]:
+    config = load_server_config()
+    config.update(updates)
+    config = {**MCP_SERVER_DEFAULTS, **config}
+    config["enabled"] = bool(config.get("enabled", False))
+    config["write_enabled"] = bool(config.get("write_enabled", False))
+    config["host"] = str(config.get("host", "127.0.0.1") or "127.0.0.1").strip()
+    config["auth_token"] = str(config.get("auth_token", "") or "").strip()
+    try:
+        config["port"] = max(1, min(65535, int(config.get("port", 3031))))
+    except (TypeError, ValueError):
+        config["port"] = 3031
+    storage.write_json("mcp_server.json", config)
+    return config
+
+
 def load_integrations() -> list[dict[str, Any]]:
     return _merge_defaults(storage.read_json("mcp_integrations.json", MCP_DEFAULTS))
 

package/hermes_ui/mcp_server.py

@@ -0,0 +1,400 @@
+from __future__ import annotations
+
+import atexit
+import json
+import logging
+import threading
+from http import HTTPStatus
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlparse
+
+from . import storage
+from .domain import create_batch, create_tasks_for_batch, pipeline_summary
+
+LOGGER = logging.getLogger(__name__)
+MCP_ENDPOINT_PATH = "/mcp"
+MCP_HEALTH_PATH = "/health"
+DEFAULT_HOST = "127.0.0.1"
+DEFAULT_PORT = 3031
+DEFAULT_PROTOCOL_VERSION = "2025-06-18"
+
+
+def _version() -> str:
+    try:
+        package = json.loads((Path(__file__).resolve().parents[1] / "package.json").read_text(encoding="utf-8"))
+        return str(package.get("version") or "")
+    except (OSError, json.JSONDecodeError):
+        return ""
+
+
+def _json_text(value: Any) -> str:
+    return json.dumps(value, ensure_ascii=False, indent=2, default=str)
+
+
+def _channel_public(channel: dict[str, Any]) -> dict[str, Any]:
+    allowed = (
+        "id", "name", "url", "handle", "description", "thumbnail_url", "subscriber_count",
+        "video_count", "view_count", "metrics_source", "last_youtube_sync", "language",
+        "blueprint_id", "default_blueprint_id", "style_wide", "voice", "default_voice",
+        "automation_on", "automation_time", "active", "daily_limit", "backlog_total",
+        "created_at", "updated_at",
+    )
+    return {key: channel.get(key) for key in allowed if key in channel}
+
+
+def _task_public(task: dict[str, Any]) -> dict[str, Any]:
+    allowed = (
+        "id", "batch_id", "creation_mode", "channel_id", "channel_name", "topic", "language",
+        "format", "style_wide", "style_ia", "music_mode", "music_source", "background_mode",
+        "blueprint_id", "voice", "automation_on", "automation_time", "stage", "state",
+        "progress", "error", "created_at", "updated_at",
+    )
+    return {key: task.get(key) for key in allowed if key in task}
+
+
+def _list_blueprints() -> list[dict[str, Any]]:
+    storage.ensure_storage()
+    files = sorted(storage.BLUEPRINTS.rglob("*.json"))
+    return [
+        {
+            "id": path.stem,
+            "name": path.stem,
+            "filename": path.name,
+            "category": path.parent.name,
+        }
+        for path in files
+    ]
+
+
+def _tool_definitions(write_enabled: bool) -> list[dict[str, Any]]:
+    tools = [
+        {
+            "name": "thunderbolt_get_status",
+            "title": "Thunderbolt — estado da pipeline",
+            "description": "Obtém o resumo actual de canais e tarefas do Thunderbolt.",
+            "inputSchema": {"type": "object", "additionalProperties": False},
+        },
+        {
+            "name": "thunderbolt_list_channels",
+            "title": "Thunderbolt — listar canais",
+            "description": "Lista os canais registados sem devolver cookies, tokens ou outros segredos.",
+            "inputSchema": {"type": "object", "additionalProperties": False},
+        },
+        {
+            "name": "thunderbolt_list_videos",
+            "title": "Thunderbolt — listar vídeos",
+            "description": "Lista tarefas de vídeo com filtros opcionais por canal e estado.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "channel_id": {"type": "string", "description": "ID do canal opcional."},
+                    "state": {"type": "string", "description": "Estado opcional: to_do, doing, blocked, done, failed ou cancelled."},
+                    "limit": {"type": "integer", "minimum": 1, "maximum": 100, "default": 50},
+                },
+                "additionalProperties": False,
+            },
+        },
+        {
+            "name": "thunderbolt_list_blueprints",
+            "title": "Thunderbolt — listar Blueprints",
+            "description": "Lista os Blueprints JSON disponíveis na biblioteca local, sem expor caminhos absolutos.",
+            "inputSchema": {"type": "object", "additionalProperties": False},
+        },
+    ]
+    if write_enabled:
+        tools.append(
+            {
+                "name": "thunderbolt_create_video_batch",
+                "title": "Thunderbolt — criar lote de vídeos",
+                "description": "Cria um lote e as respectivas tarefas. Só aparece quando o utilizador activa ferramentas de escrita na UI.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "mode": {"type": "string", "enum": ["single", "batch", "general"]},
+                        "channel_ids": {"type": "array", "items": {"type": "string"}, "minItems": 1},
+                        "topic": {"type": "string", "minLength": 1},
+                        "quantity": {"type": "integer", "minimum": 1, "maximum": 50},
+                        "language": {"type": "string"},
+                        "format": {"type": "string"},
+                        "style_wide": {"type": "string"},
+                        "style_ia": {"type": "string"},
+                        "music_mode": {"type": "boolean"},
+                        "background_mode": {"type": "string"},
+                    },
+                    "required": ["mode", "channel_ids", "topic", "quantity"],
+                    "additionalProperties": False,
+                },
+            }
+        )
+    return tools
+
+
+def _tool_call(name: str, arguments: dict[str, Any], write_enabled: bool) -> Any:
+    if name == "thunderbolt_get_status":
+        return pipeline_summary()
+    if name == "thunderbolt_list_channels":
+        channels = storage.read_json("channels.json", [])
+        return [_channel_public(channel) for channel in channels if isinstance(channel, dict)]
+    if name == "thunderbolt_list_videos":
+        channel_id = str(arguments.get("channel_id", "") or "").strip()
+        state = str(arguments.get("state", "") or "").strip()
+        limit = int(arguments.get("limit", 50) or 50)
+        if limit < 1 or limit > 100:
+            raise ValueError("limit deve estar entre 1 e 100.")
+        valid_states = {"to_do", "doing", "blocked", "done", "failed", "cancelled"}
+        if state and state not in valid_states:
+            raise ValueError(f"state inválido: {state}.")
+        tasks = storage.read_json("tasks.json", [])
+        filtered = [
+            task for task in tasks
+            if isinstance(task, dict)
+            and (not channel_id or task.get("channel_id") == channel_id)
+            and (not state or task.get("state") == state)
+        ]
+        return [_task_public(task) for task in filtered[:limit]]
+    if name == "thunderbolt_list_blueprints":
+        return _list_blueprints()
+    if name == "thunderbolt_create_video_batch":
+        if not write_enabled:
+            raise PermissionError("Ferramentas de escrita estão desactivadas no Servidor MCP.")
+        mode = str(arguments.get("mode", "")).strip()
+        if mode not in {"single", "batch", "general"}:
+            raise ValueError("mode deve ser single, batch ou general.")
+        channel_ids = arguments.get("channel_ids")
+        if not isinstance(channel_ids, list) or not channel_ids or not all(isinstance(item, str) and item.strip() for item in channel_ids):
+            raise ValueError("channel_ids deve conter pelo menos um ID de canal válido.")
+        topic = str(arguments.get("topic", "") or "").strip()
+        if not topic:
+            raise ValueError("topic é obrigatório.")
+        quantity = int(arguments.get("quantity", 1) or 1)
+        if quantity < 1 or quantity > 50:
+            raise ValueError("quantity deve estar entre 1 e 50.")
+        options = {
+            "language": str(arguments.get("language", "") or ""),
+            "format": str(arguments.get("format", "wide") or "wide"),
+            "style_wide": str(arguments.get("style_wide", "pexels") or "pexels"),
+            "style_ia": str(arguments.get("style_ia", "") or ""),
+            "music_mode": bool(arguments.get("music_mode", False)),
+            "background_mode": str(arguments.get("background_mode", "stock") or "stock"),
+        }
+        batch = create_batch(mode, [item.strip() for item in channel_ids], topic, quantity, options)
+        tasks = create_tasks_for_batch(batch)
+        return {"batch_id": batch["id"], "task_ids": [task["id"] for task in tasks], "created": len(tasks)}
+    raise KeyError(f"Ferramenta desconhecida: {name}")
+
+
+def _rpc_error(request_id: Any, code: int, message: str) -> dict[str, Any]:
+    return {"jsonrpc": "2.0", "id": request_id, "error": {"code": code, "message": message}}
+
+
+def _tool_result(value: Any, *, is_error: bool = False) -> dict[str, Any]:
+    result: dict[str, Any] = {
+        "content": [{"type": "text", "text": _json_text(value)}],
+        "isError": is_error,
+    }
+    if not is_error:
+        result["structuredContent"] = value
+    return result
+
+
+class _MCPDispatcher:
+    def __init__(self, auth_token: str = "", write_enabled: bool = False):
+        self.auth_token = auth_token.strip()
+        self.write_enabled = bool(write_enabled)
+
+    def handle(self, request: dict[str, Any]) -> dict[str, Any] | None:
+        request_id = request.get("id")
+        if request.get("jsonrpc") != "2.0":
+            return _rpc_error(request_id, -32600, "Pedido JSON-RPC inválido.")
+        method = request.get("method")
+        params = request.get("params") or {}
+        if not isinstance(method, str) or not isinstance(params, dict):
+            return _rpc_error(request_id, -32600, "method e params inválidos.")
+        if method in {"notifications/initialized", "notifications/cancelled", "notifications/progress"} or "id" not in request:
+            return None
+        if method == "initialize":
+            requested = params.get("protocolVersion")
+            protocol_version = requested if isinstance(requested, str) and requested else DEFAULT_PROTOCOL_VERSION
+            return {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "result": {
+                    "protocolVersion": protocol_version,
+                    "capabilities": {"tools": {"listChanged": False}},
+                    "serverInfo": {"name": "Thunderbolt MCP Server", "version": _version()},
+                    "instructions": "Use tools/list para descobrir as ferramentas disponíveis. Ferramentas de escrita só aparecem quando autorizadas pelo utilizador na UI.",
+                },
+            }
+        if method == "ping":
+            return {"jsonrpc": "2.0", "id": request_id, "result": {}}
+        if method == "tools/list":
+            return {"jsonrpc": "2.0", "id": request_id, "result": {"tools": _tool_definitions(self.write_enabled)}}
+        if method == "tools/call":
+            name = params.get("name")
+            arguments = params.get("arguments") or {}
+            if not isinstance(name, str) or not isinstance(arguments, dict):
+                return _rpc_error(request_id, -32602, "name e arguments são obrigatórios em tools/call.")
+            try:
+                value = _tool_call(name, arguments, self.write_enabled)
+                return {"jsonrpc": "2.0", "id": request_id, "result": _tool_result(value)}
+            except KeyError as exc:
+                return _rpc_error(request_id, -32602, str(exc))
+            except (ValueError, PermissionError) as exc:
+                return {"jsonrpc": "2.0", "id": request_id, "result": _tool_result(str(exc), is_error=True)}
+            except Exception:
+                LOGGER.exception("Falha ao executar ferramenta MCP %s", name)
+                return {"jsonrpc": "2.0", "id": request_id, "result": _tool_result("Erro interno ao executar a ferramenta.", is_error=True)}
+        return _rpc_error(request_id, -32601, f"Método não suportado: {method}")
+
+
+class _HTTPServer(ThreadingHTTPServer):
+    daemon_threads = True
+    allow_reuse_address = True
+
+
+class _RequestHandler(BaseHTTPRequestHandler):
+    server: _HTTPServer
+
+    def log_message(self, format: str, *args: Any) -> None:
+        LOGGER.info("MCP HTTP %s", format % args)
+
+    def _send_json(self, payload: Any, status: int = HTTPStatus.OK) -> None:
+        body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json; charset=utf-8")
+        self.send_header("Content-Length", str(len(body)))
+        self.send_header("Cache-Control", "no-store")
+        self.end_headers()
+        self.wfile.write(body)
+
+    def _authorized(self) -> bool:
+        token = self.server.dispatcher.auth_token
+        if not token:
+            return True
+        return self.headers.get("Authorization", "") == f"Bearer {token}" or self.headers.get("X-Thunderbolt-MCP-Token", "") == token
+
+    def do_GET(self) -> None:
+        path = urlparse(self.path).path
+        if path == MCP_HEALTH_PATH:
+            self._send_json({"ok": True, "server": "Thunderbolt MCP Server", "endpoint": MCP_ENDPOINT_PATH, "version": _version()})
+            return
+        if path == MCP_ENDPOINT_PATH:
+            self.send_response(HTTPStatus.METHOD_NOT_ALLOWED)
+            self.send_header("Allow", "POST")
+            self.end_headers()
+            return
+        self._send_json({"error": "Not found"}, HTTPStatus.NOT_FOUND)
+
+    def do_POST(self) -> None:
+        path = urlparse(self.path).path
+        if path != MCP_ENDPOINT_PATH:
+            self._send_json({"error": "Not found"}, HTTPStatus.NOT_FOUND)
+            return
+        if not self._authorized():
+            self._send_json({"error": "Unauthorized"}, HTTPStatus.UNAUTHORIZED)
+            return
+        try:
+            length = int(self.headers.get("Content-Length", "0"))
+            if length < 1 or length > 1_000_000:
+                raise ValueError("Corpo JSON inválido ou demasiado grande.")
+            payload = json.loads(self.rfile.read(length).decode("utf-8"))
+        except (ValueError, json.JSONDecodeError, UnicodeDecodeError) as exc:
+            self._send_json(_rpc_error(None, -32700, f"JSON inválido: {exc}"), HTTPStatus.BAD_REQUEST)
+            return
+        if isinstance(payload, list):
+            responses = [self.server.dispatcher.handle(item) for item in payload if isinstance(item, dict)]
+            responses = [item for item in responses if item is not None]
+            if responses:
+                self._send_json(responses)
+            else:
+                self.send_response(HTTPStatus.ACCEPTED)
+                self.end_headers()
+            return
+        if not isinstance(payload, dict):
+            self._send_json(_rpc_error(None, -32600, "O pedido MCP deve ser um objecto JSON-RPC."), HTTPStatus.BAD_REQUEST)
+            return
+        response = self.server.dispatcher.handle(payload)
+        if response is None:
+            self.send_response(HTTPStatus.ACCEPTED)
+            self.end_headers()
+            return
+        self._send_json(response)
+
+
+class _Runtime:
+    def __init__(self) -> None:
+        self.lock = threading.RLock()
+        self.http_server: _HTTPServer | None = None
+        self.thread: threading.Thread | None = None
+        self.host = ""
+        self.port = 0
+        self.write_enabled = False
+
+    def start(self, host: str, port: int, auth_token: str = "", write_enabled: bool = False) -> dict[str, Any]:
+        host = (host or DEFAULT_HOST).strip()
+        port = int(port)
+        if not 1 <= port <= 65535:
+            raise ValueError("A porta MCP deve estar entre 1 e 65535.")
+        if host not in {"127.0.0.1", "localhost", "::1"} and not auth_token.strip():
+            raise ValueError("Defina um token MCP antes de expor o servidor fora do computador local.")
+        with self.lock:
+            if self.http_server and self.thread and self.thread.is_alive() and (self.host, self.port) == (host, port):
+                self.write_enabled = bool(write_enabled)
+                self.http_server.dispatcher.write_enabled = bool(write_enabled)
+                self.http_server.dispatcher.auth_token = auth_token.strip()
+                return self.status()
+            self.stop()
+            server = _HTTPServer((host, port), _RequestHandler)
+            server.dispatcher = _MCPDispatcher(auth_token, write_enabled)
+            thread = threading.Thread(target=server.serve_forever, name="thunderbolt-mcp", daemon=True)
+            thread.start()
+            self.http_server = server
+            self.thread = thread
+            self.host = host
+            self.port = port
+            self.write_enabled = bool(write_enabled)
+            return self.status()
+
+    def stop(self) -> None:
+        with self.lock:
+            if self.http_server:
+                self.http_server.shutdown()
+                self.http_server.server_close()
+            self.http_server = None
+            self.thread = None
+            self.host = ""
+            self.port = 0
+            self.write_enabled = False
+
+    def status(self) -> dict[str, Any]:
+        running = bool(self.http_server and self.thread and self.thread.is_alive())
+        return {
+            "running": running,
+            "host": self.host if running else "",
+            "port": self.port if running else 0,
+            "endpoint": f"http://{self.host}:{self.port}{MCP_ENDPOINT_PATH}" if running else "",
+            "health_endpoint": f"http://{self.host}:{self.port}{MCP_HEALTH_PATH}" if running else "",
+            "write_enabled": self.write_enabled if running else False,
+        }
+
+
+_RUNTIME = _Runtime()
+atexit.register(_RUNTIME.stop)
+
+
+def start_server(host: str = DEFAULT_HOST, port: int = DEFAULT_PORT, auth_token: str = "", write_enabled: bool = False) -> dict[str, Any]:
+    return _RUNTIME.start(host, port, auth_token, write_enabled)
+
+
+def stop_server() -> None:
+    _RUNTIME.stop()
+
+
+def server_status() -> dict[str, Any]:
+    return _RUNTIME.status()
+
+
+def tool_definitions(write_enabled: bool = False) -> list[dict[str, Any]]:
+    return _tool_definitions(write_enabled)

package/hermes_ui/storage.py

@@ -21,6 +21,13 @@ DEFAULTS: dict[str, Any] = {
     "batches.json": [],
     "uploads.json": [],
     "metadata_edits.json": [],
+    "mcp_server.json": {
+        "enabled": False,
+        "host": "127.0.0.1",
+        "port": 3031,
+        "auth_token": "",
+        "write_enabled": False,
+    },
     "mcp_integrations.json": [
         {
             "id": "short-video-maker",

package/package.json

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