@danhachuel/thunderbolt 0.2.40 → 0.2.41

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.40
+> **Versão deste manual:** 0.2.41
 > **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.40 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.41 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes @danhachuel/thunderbolt@0.2.40 install
+npx --yes @danhachuel/thunderbolt@0.2.41 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.
@@ -379,7 +379,7 @@ Após iniciar a aplicação, valide o seguinte percurso:
 7. **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.
 8. **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.
 9. **Edição > 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.
-10. **Configurações > Configurações Técnicas:** confirme que os caminhos e credenciais estão locais e não aparecem no Git.
+10. **Configurações > Configurações Técnicas:** confirme que os caminhos e credenciais estão locais e não aparecem no Git. Na secção **Contas Google/YouTube — canais em lote**, adicione cada conta com o seu e-mail/Gmail, OAuth Client ID e OAuth Client Secret próprios; o e-mail identifica a conta e não é usado para ler a caixa Gmail.
 11. **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`.
 12. **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. Inicie o Thunderbolt pelo launcher, confirme o aviso verde **Worker activo** e verifique que o relógio apresentado corresponde ao computador. O worker cria no máximo um lote por canal por dia quando o horário local coincide.
 13. **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.
@@ -388,6 +388,14 @@ Após iniciar a aplicação, valide o seguinte percurso:
 16. **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.
 17. **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.
 
+## Canais em lote por conta Google/YouTube
+
+A subaba **Canais em lote gmail**, dentro de **Canais**, não lê e-mails, mensagens, contactos ou a caixa Gmail. O nome identifica a conta Google/Gmail que gere os canais YouTube. Configure cada conta em **Configurações > Configurações Técnicas > Contas Google/YouTube — canais em lote**, preenchendo e-mail, OAuth Client ID e OAuth Client Secret.
+
+Na subaba, seleccione a conta e clique em **Autorizar conta Google**. A autorização abre o browser do sistema e guarda um refresh token separado para essa conta. Depois clique em **Listar canais desta conta**. O Thunderbolt chama a YouTube Data API com `channels.list`, `mine=true`, `part=snippet,contentDetails,statistics`, suporta páginas sucessivas e apresenta os canais encontrados para selecção.
+
+Escolha os canais e os defaults de Blueprint, voz, idioma e estilo wide, depois clique em **Cadastrar canais seleccionados**. A importação usa `youtube_channel_id` para não duplicar canais já cadastrados, preserva os registos existentes e identifica a origem como `youtube_data_api_oauth_mine`. A API Key global não substitui OAuth neste fluxo; permanece reservada para consultas públicas/métricas.
+
 ## Niche Finder Kaggle e Niche Finder Apify
 
 A página **Niche Finder Kaggle** integra a lógica adaptada do projecto open source [johanfortus/Niche-Finder](https://github.com/johanfortus/Niche-Finder), cujo projecto original usa K-Means e FP-Growth sobre o dataset público [Trending Youtube Video Statistics (113 Countries)](https://www.kaggle.com/datasets/asaniczka/trending-youtube-videos-113-countries). No Thunderbolt não existe Flask, rota HTTP adicional, template HTML, JavaScript D3 ou segundo processo; toda a análise é síncrona no Streamlit.
@@ -396,7 +404,7 @@ Ao abrir a página, o Thunderbolt não prepara dados públicos, não descarrega
 
 Os parâmetros da UI são número de clusters entre 2 e 10, suporte mínimo entre 0,01 e 0,50, país, engagement, intervalo de datas e tags, todos dentro da área principal da aba. O núcleo normaliza os dados, calcula engagement, aplica filtros, faz transformação logarítmica e standardização, executa K-Means e calcula itemsets/regras com FP-Growth. Não são apresentados resultados até ao primeiro clique em **Analisar Nichos**; o mesmo botão aplica alterações posteriores aos filtros. Os resultados são DataFrames de clusters, itemsets frequentes, regras de associação e dados analisados; o gráfico de dispersão é criado nativamente com Plotly.
 
-As dependências adicionais — `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub` — são instaladas pelo procedimento normal de `npx`. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.40 install`; o instalador detecta e reutiliza o que já estiver válido.
+As dependências adicionais — `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub` — são instaladas pelo procedimento normal de `npx`. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.41 install`; o instalador detecta e reutiliza o que já estiver válido.
 
 ### Niche Finder Apify
 

package/README.md

@@ -14,7 +14,7 @@ A primeira versão implementa a camada UI independente com:
 | Pipeline | Menu expansível com Criação de Vídeos, Criação de Músicas e Upload |
 | 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 |
+| Canais | Subabas de importação pública sem API Key, Canais em lote gmail por conta Google/YouTube via OAuth e cadastro manual independente |
 | 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, horário diário HH:MM e worker local baseado no relógio do computador |
 | Models AI | Menu expansível com Personagens e Redes Sociais reservados para desenvolvimento futuro |
@@ -22,12 +22,12 @@ A primeira versão implementa a camada UI independente com:
 | Edição | Menu expansível abaixo de Automação com Limpador de Metadados funcional, Cortes reservado e Editor Python inspirado no PYEdit para vídeos e scripts locais |
 | Upload | YouTube via `youtube-automation-agent` adaptado internamente, OAuth directo de redundância, Upload directo 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 |
-| Configurações Técnicas | Provedores LLM, TTS/voz, preview de vozes, Suno, materiais, Whisper, FFmpeg, OAuth YouTube, Data API Key opcional, Kaggle Username/API Key, Apify API Token/Actor ID/limites, Upload directo, TikTok Client ID/Secret e Upload-Post |
+| Configurações Técnicas | Provedores LLM, TTS/voz, preview de vozes, Suno, materiais, Whisper, FFmpeg, OAuth YouTube, contas Google/YouTube para canais em lote com e-mail, Client ID e Client Secret por conta, Data API Key opcional, Kaggle Username/API Key, Apify API Token/Actor ID/limites, 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.40
+## Navegação da UI 0.2.41
 
 A barra lateral mantém os níveis principais, nesta ordem: **Início**, **Niche Finder**, **Pipeline**, **Automação**, **Edição**, **Models AI** e **Configurações**. **Pipeline** é expansível e contém **Criação de Vídeos**, **Criação de Músicas** e **Upload**. **Edição** é expansível e contém **Limpador de Metadados**, **Cortes** e **Editor Python**, nessa ordem. **Models AI** é expansível e contém **Personagens** e **Redes Sociais**, nessa ordem. **Niche Finder** é expansível e contém **Niche Finder Kaggle** e **Niche Finder Apify**. **Configurações** é expansível e contém **Canais**, **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.
 
@@ -116,9 +116,9 @@ thunderbolt
 No Windows PowerShell, se `npx` for bloqueado por `npx.ps1`, use directamente `npx.cmd`:
 
 ```powershell
-npx.cmd --yes @danhachuel/thunderbolt@0.2.40 install
-npx.cmd --yes @danhachuel/thunderbolt@0.2.40 doctor
-npx.cmd --yes @danhachuel/thunderbolt@0.2.40
+npx.cmd --yes @danhachuel/thunderbolt@0.2.41 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.41 doctor
+npx.cmd --yes @danhachuel/thunderbolt@0.2.41
 ```
 
 Como alternativa, pode permitir scripts para o seu utilizador:
@@ -142,7 +142,7 @@ O menu expansível **Niche Finder** contém duas alternativas independentes. **N
 
 A interface apresenta dentro da aba os parâmetros da busca: número de clusters entre 2 e 10, suporte mínimo entre 0,01 e 0,50, país, categoria de engagement, intervalo de datas e tags. A página permanece sem resultados até o primeiro clique em **Analisar Nichos**; depois, se os parâmetros forem alterados, mostra os resultados anteriores e pede novo clique para aplicar os filtros actuais. O núcleo aplica normalização, filtros, `log1p`, `StandardScaler`, K-Means e FP-Growth. Os resultados aparecem em DataFrames para clusters, itemsets frequentes, regras de associação e dados analisados, acompanhados por uma visualização Plotly nativa e pesquisa de palavras nos clusters.
 
-**Niche Finder Apify** é a segunda alternativa e não usa o dataset, filtros, execução ou resultados Kaggle. Define três palavras-chave, período, limite de resultados, Shorts, duração, idioma de legendas e ordenação; depois de clicar em **Pesquisar no Apify**, inicia o actor `streamers~youtube-scraper`, acompanha o run, carrega o dataset, normaliza vídeos, limpa SRT, calcula VSC Ratio e tenta resumir as transcrições com o provider LLM configurado. Os resultados ficam na sessão própria `niche_apify_results`, o histórico pequeno fica em `storage/state/niche_apify_runs.json` e existem exportações JSON/CSV. Configure o **Apify API Token** em Configurações Técnicas. As dependências adicionais são instaladas pelo fluxo normal do pacote: `requests`, `pandas` e os componentes já existentes da análise. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.40 install`; o instalador detecta e reutiliza componentes já válidos.
+**Niche Finder Apify** é a segunda alternativa e não usa o dataset, filtros, execução ou resultados Kaggle. Define três palavras-chave, período, limite de resultados, Shorts, duração, idioma de legendas e ordenação; depois de clicar em **Pesquisar no Apify**, inicia o actor `streamers~youtube-scraper`, acompanha o run, carrega o dataset, normaliza vídeos, limpa SRT, calcula VSC Ratio e tenta resumir as transcrições com o provider LLM configurado. Os resultados ficam na sessão própria `niche_apify_results`, o histórico pequeno fica em `storage/state/niche_apify_runs.json` e existem exportações JSON/CSV. Configure o **Apify API Token** em Configurações Técnicas. As dependências adicionais são instaladas pelo fluxo normal do pacote: `requests`, `pandas` e os componentes já existentes da análise. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.41 install`; o instalador detecta e reutiliza componentes já válidos.
 
 ## Editor Python baseado no PYEdit
 

package/app/main.py

@@ -4,6 +4,7 @@ import json
 import re
 from datetime import date, datetime
 import sys
+import uuid
 from pathlib import Path
 
 import requests
@@ -33,6 +34,7 @@ from hermes_ui.music import list_music_files, materialize_suno_audio, request_su
 from hermes_ui.voice_preview import DEFAULT_SAMPLE, load_preview_file, synthesize_preview
 from integrations.platforms import IntegrationResult, TikTokAdapter, YouTubeAdapter
 from integrations.youtube_direct_upload import YouTubeDirectUploader
+from integrations.youtube_batch import account_key as youtube_batch_account_key, account_status as youtube_batch_account_status, authorize_account as authorize_youtube_batch_account, delete_account_token as delete_youtube_batch_token, list_my_channels as list_youtube_batch_channels
 from integrations.local_runtime import MoneyPrinterRuntime
 from integrations.moneyprinter_config import sync_moneyprinter_config
 
@@ -339,7 +341,7 @@ def render_channels():
     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"])
+    import_tab, batch_tab, manual_tab = st.tabs(["Importar do YouTube", "Canais em lote gmail", "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.")
@@ -423,6 +425,96 @@ def render_channels():
         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 batch_tab:
+        st.caption("Esta subaba usa a conta Google/YouTube seleccionada para listar os canais que ela gere. Não lê a caixa Gmail e não usa e-mails como pesquisa pública.")
+        accounts = [account for account in settings.get("youtube_batch_accounts", []) if isinstance(account, dict) and account.get("id")]
+        if not accounts:
+            st.info("Configure primeiro uma conta em Configurações > Configurações Técnicas > Contas Google/YouTube para canais em lote.")
+        else:
+            account_ids = [str(account["id"]) for account in accounts]
+            account_labels = {str(account["id"]): f"{account.get('email', 'Conta Google')} — {account.get('label', 'Canais YouTube')}" for account in accounts}
+            default_account_id = str(settings.get("youtube_batch_selected_account_id") or account_ids[0])
+            if default_account_id not in account_ids:
+                default_account_id = account_ids[0]
+            selected_account_id = st.selectbox("Conta Google/YouTube", account_ids, index=account_ids.index(default_account_id), format_func=lambda item: account_labels.get(item, item), key="batch_selected_account_id")
+            selected_account = next(account for account in accounts if str(account["id"]) == selected_account_id)
+            account_status = youtube_batch_account_status(selected_account, STORAGE)
+            (st.success if account_status.ok else st.warning)(account_status.message)
+            auth_cols = st.columns([1, 2])
+            with auth_cols[0]:
+                if st.button("Autorizar conta Google", type="secondary", use_container_width=True, key="batch_authorize_account"):
+                    result = authorize_youtube_batch_account(selected_account, STORAGE)
+                    (st.success if result.ok else st.error)(result.message)
+                    if result.ok:
+                        st.rerun()
+            with auth_cols[1]:
+                st.caption("A autorização é feita no browser do sistema e fica guardada separadamente para esta conta.")
+            batch_key = f"youtube_batch_channels_{selected_account_id}"
+            if st.button("Listar canais desta conta", type="primary", use_container_width=True, key="batch_list_channels"):
+                result = list_youtube_batch_channels(selected_account, STORAGE)
+                st.session_state[batch_key] = result.data.get("channels", []) if result.ok else []
+                st.session_state[f"{batch_key}_message"] = result.message
+                st.session_state[f"{batch_key}_ok"] = result.ok
+            if st.session_state.get(f"{batch_key}_message"):
+                (st.success if st.session_state.get(f"{batch_key}_ok") else st.error)(st.session_state[f"{batch_key}_message"])
+            listed_channels = st.session_state.get(batch_key, [])
+            if listed_channels:
+                channel_by_id = {str(channel.get("youtube_channel_id")): channel for channel in listed_channels if channel.get("youtube_channel_id")}
+                channel_labels = {channel_id: f"{channel.get('name', channel_id)} — {channel.get('handle') or channel_id}" for channel_id, channel in channel_by_id.items()}
+                existing_channels = read_json("channels.json", [])
+                existing_ids = {str(channel.get("youtube_channel_id")) for channel in existing_channels if channel.get("youtube_channel_id")}
+                existing_count = sum(1 for channel_id in channel_by_id if channel_id in existing_ids)
+                st.caption(f"{len(listed_channels)} canal(is) listado(s); {existing_count} já cadastrado(s). A API devolveu a lista da conta autenticada, não uma caixa Gmail.")
+                blueprint_items = blueprint_catalog()
+                blueprint_ids = [item[0] for item in blueprint_items]
+                blueprint_labels = {item[0]: item[1] for item in blueprint_items}
+                voice_options = voice_catalog()
+                with st.form("batch_channel_import_form"):
+                    selected_channel_ids = st.multiselect("Canais a cadastrar", list(channel_by_id), default=list(channel_by_id), format_func=lambda item: channel_labels.get(item, item), key="batch_channel_ids")
+                    defaults_cols = st.columns(4)
+                    with defaults_cols[0]:
+                        batch_blueprint = st.selectbox("Blueprint padrão", blueprint_ids, format_func=lambda item: blueprint_labels.get(item, item or "Sem Blueprint padrão"), key="batch_channel_blueprint")
+                    with defaults_cols[1]:
+                        batch_voice = st.selectbox("Voz padrão", voice_options, format_func=lambda item: item or "Sem voz padrão", key="batch_channel_voice")
+                    with defaults_cols[2]:
+                        batch_language = st.selectbox("Idioma", ["Português", "English", "Español", "Français", "Deutsch"], key="batch_channel_language")
+                    with defaults_cols[3]:
+                        batch_style = st.selectbox("Estilo wide", ["Pexels/Pixabay", "full_ia", "Apenas Música"], key="batch_channel_style")
+                    import_selected = st.form_submit_button("Cadastrar canais seleccionados", type="primary", use_container_width=True)
+                if import_selected:
+                    created_names = []
+                    skipped_names = []
+                    failed_names = []
+                    style_value = {"Pexels/Pixabay": "pexels", "full_ia": "full_ia", "Apenas Música": "music"}.get(batch_style, batch_style)
+                    for channel_id in selected_channel_ids:
+                        data = channel_by_id[channel_id]
+                        if channel_id in existing_ids:
+                            skipped_names.append(data.get("name", channel_id))
+                            continue
+                        try:
+                            create_channel(data.get("name", channel_id), data.get("url", ""), {
+                                **data,
+                                "youtube_channel_id": channel_id,
+                                "google_account_id": str(selected_account.get("id", "")),
+                                "google_account_email": str(selected_account.get("email", "")),
+                                "blueprint_id": batch_blueprint.strip(),
+                                "default_blueprint_id": batch_blueprint.strip(),
+                                "default_voice": batch_voice.strip(),
+                                "voice": batch_voice.strip(),
+                                "language": batch_language,
+                                "style_wide": style_value,
+                                "last_youtube_sync": now(),
+                            })
+                            created_names.append(data.get("name", channel_id))
+                        except Exception as exc:
+                            failed_names.append(f"{data.get('name', channel_id)}: {exc}")
+                    if created_names:
+                        st.success(f"Canais cadastrados: {', '.join(created_names)}")
+                    if skipped_names:
+                        st.info(f"Já existentes e não duplicados: {', '.join(skipped_names)}")
+                    if failed_names:
+                        st.error(f"Falhas: {'; '.join(failed_names)}")
+
     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"):
@@ -1287,6 +1379,83 @@ def render_settings():
             key=f"settings_{key}",
         )
 
+    st.subheader("Contas Google/YouTube — canais em lote")
+    st.caption("Cada registo representa uma conta Google que pode gerir vários canais do YouTube. O e-mail identifica a conta; esta área não lê a caixa Gmail. Cada conta tem Client ID, Client Secret e token OAuth próprios.")
+    batch_accounts = [account for account in settings.get("youtube_batch_accounts", []) if isinstance(account, dict) and account.get("id")]
+    for batch_account in batch_accounts:
+        account_id = str(batch_account["id"])
+        with st.container(border=True):
+            with st.form(f"batch_account_form_{account_id}"):
+                account_cols = st.columns(4)
+                with account_cols[0]:
+                    account_label = st.text_input("Nome da conta", value=str(batch_account.get("label", "Canais YouTube")), key=f"batch_label_{account_id}")
+                with account_cols[1]:
+                    account_email = st.text_input("E-mail/Gmail da conta", value=str(batch_account.get("email", "")), key=f"batch_email_{account_id}")
+                with account_cols[2]:
+                    account_client_id = st.text_input("OAuth Client ID", value=str(batch_account.get("client_id", "")), key=f"batch_client_id_{account_id}")
+                with account_cols[3]:
+                    account_client_secret = st.text_input("OAuth Client Secret", value=str(batch_account.get("client_secret", "")), type="password", key=f"batch_client_secret_{account_id}")
+                save_account = st.form_submit_button("Guardar conta", type="primary", use_container_width=True)
+            account_status = youtube_batch_account_status(batch_account, STORAGE)
+            status_cols = st.columns([2, 1, 1])
+            with status_cols[0]:
+                (st.success if account_status.ok else st.warning)(account_status.message)
+            with status_cols[1]:
+                if st.button("Autorizar/Reautorizar", key=f"batch_authorize_settings_{account_id}", use_container_width=True):
+                    result = authorize_youtube_batch_account(batch_account, STORAGE)
+                    (st.success if result.ok else st.error)(result.message)
+                    if result.ok:
+                        st.rerun()
+            with status_cols[2]:
+                if st.button("Remover conta", key=f"batch_remove_settings_{account_id}", use_container_width=True):
+                    delete_youtube_batch_token(batch_account, STORAGE)
+                    remaining_accounts = [account for account in batch_accounts if str(account.get("id")) != account_id]
+                    settings["youtube_batch_accounts"] = remaining_accounts
+                    if settings.get("youtube_batch_selected_account_id") == account_id:
+                        settings["youtube_batch_selected_account_id"] = str(remaining_accounts[0].get("id")) if remaining_accounts else ""
+                    write_json("settings.json", settings)
+                    st.rerun()
+            if save_account:
+                if "@" not in account_email.strip():
+                    st.error("Informe um e-mail Google válido.")
+                elif not account_client_id.strip() or not account_client_secret.strip():
+                    st.error("Informe o Client ID e o Client Secret desta conta.")
+                else:
+                    for existing in batch_accounts:
+                        if str(existing.get("id")) == account_id:
+                            credentials_changed = any(existing.get(field, "") != value for field, value in (("email", account_email.strip()), ("client_id", account_client_id.strip()), ("client_secret", account_client_secret.strip())))
+                            if credentials_changed:
+                                delete_youtube_batch_token(existing, STORAGE)
+                            existing.update({"label": account_label.strip() or "Canais YouTube", "email": account_email.strip(), "client_id": account_client_id.strip(), "client_secret": account_client_secret.strip()})
+                    settings["youtube_batch_accounts"] = batch_accounts
+                    write_json("settings.json", settings)
+                    st.success("Conta Google/YouTube guardada.")
+                    st.rerun()
+    with st.form("add_batch_account_form"):
+        add_cols = st.columns(4)
+        with add_cols[0]:
+            new_account_label = st.text_input("Nome da nova conta", value="Canais YouTube", key="new_batch_account_label")
+        with add_cols[1]:
+            new_account_email = st.text_input("E-mail/Gmail", key="new_batch_account_email")
+        with add_cols[2]:
+            new_account_client_id = st.text_input("OAuth Client ID", key="new_batch_account_client_id")
+        with add_cols[3]:
+            new_account_client_secret = st.text_input("OAuth Client Secret", type="password", key="new_batch_account_client_secret")
+        add_account = st.form_submit_button("Adicionar conta Google/YouTube", use_container_width=True)
+    if add_account:
+        if "@" not in new_account_email.strip():
+            st.error("Informe um e-mail Google válido.")
+        elif not new_account_client_id.strip() or not new_account_client_secret.strip():
+            st.error("Informe o Client ID e o Client Secret da nova conta.")
+        else:
+            new_account = {"id": f"google_batch_{uuid.uuid4().hex[:12]}", "label": new_account_label.strip() or "Canais YouTube", "email": new_account_email.strip(), "client_id": new_account_client_id.strip(), "client_secret": new_account_client_secret.strip()}
+            batch_accounts.append(new_account)
+            settings["youtube_batch_accounts"] = batch_accounts
+            settings["youtube_batch_selected_account_id"] = new_account["id"]
+            write_json("settings.json", settings)
+            st.success(f"Conta {new_account['email']} adicionada.")
+            st.rerun()
+
     with st.form("settings_form"):
         st.subheader("Execução local")
         port = st.number_input("Porta Streamlit", 1, 65535, int(settings.get("port", 3030)))

package/hermes_ui/domain.py

@@ -22,6 +22,9 @@ def make_id(prefix: str) -> str:
 def create_channel(name: str, url: str = "", metadata: dict[str, Any] | None = None) -> dict[str, Any]:
     channel = {
         "id": make_id("channel"),
+        "youtube_channel_id": "",
+        "google_account_id": "",
+        "google_account_email": "",
         "name": name.strip(),
         "url": url.strip(),
         "handle": "",

package/hermes_ui/storage.py

@@ -83,6 +83,8 @@ DEFAULTS: dict[str, Any] = {
         "youtube_api_key": "",
         "youtube_client_id": "",
         "youtube_client_secret": "",
+        "youtube_batch_accounts": [],
+        "youtube_batch_selected_account_id": "",
         "kaggle_username": "",
         "kaggle_api_key": "",
         "kaggle_kernel_slug": "thunderbolt-niche-finder",

package/integrations/youtube_batch.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import secrets
+from pathlib import Path
+from typing import Any
+
+from integrations.platforms import IntegrationResult
+
+BATCH_SCOPES = ["https://www.googleapis.com/auth/youtube.readonly"]
+
+
+def _text(value: Any) -> str:
+    return str(value or "").strip()
+
+
+def account_key(account: dict[str, Any]) -> str:
+    raw = _text(account.get("id") or account.get("email"))
+    digest = hashlib.sha256(raw.lower().encode("utf-8")).hexdigest()[:16]
+    slug = re.sub(r"[^a-z0-9]+", "-", raw.lower()).strip("-")[:36] or "google-account"
+    return f"{slug}-{digest}"
+
+
+def token_path(storage_root: Path, account: dict[str, Any]) -> Path:
+    return Path(storage_root) / "state" / "youtube_batch_tokens" / f"{account_key(account)}.json"
+
+
+def _client_config(account: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "installed": {
+            "client_id": _text(account.get("client_id")),
+            "client_secret": _text(account.get("client_secret")),
+            "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+            "token_uri": "https://oauth2.googleapis.com/token",
+            "redirect_uris": ["http://localhost"],
+        }
+    }
+
+
+def _save_credentials(path: Path, credentials: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.{secrets.token_hex(6)}.tmp")
+    temporary.write_text(credentials.to_json(), encoding="utf-8")
+    try:
+        os.chmod(temporary, 0o600)
+    except OSError:
+        pass
+    temporary.replace(path)
+    try:
+        os.chmod(path, 0o600)
+    except OSError:
+        pass
+
+
+def _load_credentials(path: Path) -> Any | None:
+    if not path.exists() or path.stat().st_size == 0:
+        return None
+    try:
+        from google.auth.transport.requests import Request
+        from google.oauth2.credentials import Credentials
+    except ImportError as exc:
+        raise RuntimeError("As dependências Google OAuth ainda não estão instaladas. Execute a instalação do Thunderbolt novamente.") from exc
+    raw = json.loads(path.read_text(encoding="utf-8"))
+    credentials = Credentials.from_authorized_user_info(raw, BATCH_SCOPES)
+    if credentials.expired and credentials.refresh_token:
+        credentials.refresh(Request())
+        _save_credentials(path, credentials)
+    return credentials
+
+
+def authorize_account(account: dict[str, Any], storage_root: Path, *, open_browser: bool = True) -> IntegrationResult:
+    email = _text(account.get("email"))
+    if not email or "@" not in email:
+        return IntegrationResult(False, "Informe um e-mail Google válido para esta conta.", {"status": "email_not_configured"})
+    if not _text(account.get("client_id")) or not _text(account.get("client_secret")):
+        return IntegrationResult(False, "Preencha o OAuth Client ID e o OAuth Client Secret desta conta.", {"status": "oauth_not_configured", "email": email})
+    try:
+        from google_auth_oauthlib.flow import InstalledAppFlow
+    except ImportError as exc:
+        return IntegrationResult(False, "As dependências Google OAuth ainda não estão instaladas. Execute a instalação do Thunderbolt novamente.", {"status": "missing_dependencies", "error": str(exc)})
+    try:
+        flow = InstalledAppFlow.from_client_config(_client_config(account), BATCH_SCOPES)
+        credentials = flow.run_local_server(
+            host="localhost",
+            port=0,
+            open_browser=open_browser,
+            access_type="offline",
+            prompt="consent",
+            include_granted_scopes="true",
+        )
+        path = token_path(storage_root, account)
+        _save_credentials(path, credentials)
+        return IntegrationResult(True, f"Conta Google autorizada para listagem de canais: {email}.", {"status": "authorized", "email": email, "token_path": str(path)})
+    except Exception as exc:
+        return IntegrationResult(False, f"A autorização da conta {email} falhou: {exc}", {"status": "authorization_failed", "email": email})
+
+
+def delete_account_token(account: dict[str, Any], storage_root: Path) -> None:
+    path = token_path(storage_root, account)
+    try:
+        path.unlink(missing_ok=True)
+    except OSError:
+        pass
+
+
+def account_status(account: dict[str, Any], storage_root: Path) -> IntegrationResult:
+    email = _text(account.get("email"))
+    if not email or not _text(account.get("client_id")) or not _text(account.get("client_secret")):
+        return IntegrationResult(False, "Conta incompleta: informe e-mail, Client ID e Client Secret.", {"status": "not_configured", "email": email})
+    path = token_path(storage_root, account)
+    if not path.exists():
+        return IntegrationResult(False, "Conta configurada, mas ainda não autorizada.", {"status": "requires_authorization", "email": email})
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+        if isinstance(raw, dict) and (raw.get("refresh_token") or raw.get("access_token")):
+            return IntegrationResult(True, f"Conta autorizada: {email}", {"status": "ready", "email": email, "token_path": str(path), "refresh_on_use": bool(raw.get("refresh_token"))})
+    except (OSError, ValueError) as exc:
+        return IntegrationResult(False, f"Token da conta {email} inválido: {exc}", {"status": "invalid_token", "email": email})
+    return IntegrationResult(False, f"Token da conta {email} não está pronto.", {"status": "requires_authorization", "email": email})
+
+
+def _channel_record(item: dict[str, Any]) -> dict[str, Any]:
+    channel_id = _text(item.get("id"))
+    snippet = item.get("snippet") or {}
+    statistics = item.get("statistics") or {}
+    custom_url = _text(snippet.get("customUrl"))
+    url = f"https://www.youtube.com/{custom_url.lstrip('/')}" if custom_url else f"https://www.youtube.com/channel/{channel_id}"
+    thumbnails = snippet.get("thumbnails") or {}
+    thumbnail = (thumbnails.get("high") or thumbnails.get("medium") or thumbnails.get("default") or {}).get("url", "")
+
+    def integer(value: Any) -> int | None:
+        try:
+            return int(value) if value is not None else None
+        except (TypeError, ValueError):
+            return None
+
+    return {
+        "youtube_channel_id": channel_id,
+        "name": _text(snippet.get("title")) or channel_id,
+        "url": url,
+        "handle": custom_url,
+        "description": _text(snippet.get("description")),
+        "thumbnail_url": _text(thumbnail),
+        "subscriber_count": integer(statistics.get("subscriberCount")),
+        "video_count": integer(statistics.get("videoCount")),
+        "view_count": integer(statistics.get("viewCount")),
+        "metrics_source": "youtube_data_api_oauth_mine",
+        "published_at": _text(snippet.get("publishedAt")),
+    }
+
+
+def list_my_channels(account: dict[str, Any], storage_root: Path) -> IntegrationResult:
+    status = account_status(account, storage_root)
+    if not status.ok:
+        return status
+    try:
+        credentials = _load_credentials(token_path(storage_root, account))
+        if credentials is None:
+            return IntegrationResult(False, "Autorize primeiro esta conta Google.", {"status": "requires_authorization"})
+        from googleapiclient.discovery import build
+
+        youtube = build("youtube", "v3", credentials=credentials, cache_discovery=False)
+        channels: list[dict[str, Any]] = []
+        page_token = None
+        while True:
+            kwargs: dict[str, Any] = {
+                "part": "snippet,contentDetails,statistics",
+                "mine": True,
+                "maxResults": 50,
+            }
+            if page_token:
+                kwargs["pageToken"] = page_token
+            response = youtube.channels().list(**kwargs).execute()
+            channels.extend(_channel_record(item) for item in response.get("items", []))
+            page_token = response.get("nextPageToken")
+            if not page_token:
+                break
+        return IntegrationResult(True, f"{len(channels)} canal(is) encontrado(s) na conta {account.get('email')}.", {"status": "listed", "email": account.get("email", ""), "channels": channels, "count": len(channels)})
+    except ImportError as exc:
+        return IntegrationResult(False, "A biblioteca Google API Client ainda não está instalada. Execute a instalação do Thunderbolt novamente.", {"status": "missing_dependencies", "error": str(exc)})
+    except Exception as exc:
+        return IntegrationResult(False, f"Não foi possível listar os canais da conta {account.get('email', '')}: {exc}", {"status": "list_failed", "email": account.get("email", ""), "error": str(exc)})

package/package.json

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