@danhachuel/thunderbolt 0.2.41 → 0.2.42

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.41
+> **Versão deste manual:** 0.2.42
 > **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.41 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.42 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes @danhachuel/thunderbolt@0.2.41 install
+npx --yes @danhachuel/thunderbolt@0.2.42 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.
@@ -383,7 +383,7 @@ Após iniciar a aplicação, valide o seguinte percurso:
 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.
-14. **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. **Upload directo:** em **Configurações > Configurações Técnicas > Contas Google/YouTube — canais em lote**, seleccione cada conta Google e carregue o seu ficheiro de cookies no painel **Upload directo — sessão YouTube Frontend API**. São aceites JSON de navegador, lista JSON e formato Netscape; o Thunderbolt valida `SID`, `SSID`, `HSID`, `APISID` e `SAPISID` e guarda o ficheiro em `storage/youtube_direct_accounts/<id-da-conta>/cookies.json`. Preencha também o `sessionInfo token` da mesma conta. Em **Canais > Upload directo — conta e canal**, associe o canal à conta e preencha o `DELEGATED_SESSION_ID` individual. Configure `INNERTUBE_API_KEY`, teste apenas com um vídeo de validação e confirme que o botão só fica disponível quando os três dados — cookies, sessionInfo e ID delegado — estão configurados. O método envia chunks de 256 KiB e não extrai cookies do navegador.
 15. **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.
 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.
@@ -404,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.41 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.42 install`; o instalador detecta e reutiliza o que já estiver válido.
 
 ### Niche Finder Apify
 
@@ -434,7 +434,9 @@ A área **Teste de vozes**, dentro de **Configurações > Configurações Técni
 
 ## Upload directo
 
-A subaba **Upload directo** adapta o [YouTube-Video-Upload-Frontend-Api](https://github.com/Nojus10/YouTube-Video-Upload-Frontend-Api). Em cada canal, preencha `DELEGATED_SESSION_ID`; em Configurações, preencha manualmente os cookies `SID`, `SSID`, `HSID`, `APISID`, `SAPISID`, o token `sessionInfo` e `INNERTUBE_API_KEY`. O adaptador valida o vídeo, cria a sessão interna e envia chunks múltiplos de 256 KiB. Estes valores são segredos locais e não devem ser enviados para o Git.
+A subaba **Upload directo** adapta o [YouTube-Video-Upload-Frontend-Api](https://github.com/Nojus10/YouTube-Video-Upload-Frontend-Api). As credenciais deixam de ser globais: cada conta Google/YouTube cadastrada em **Configurações Técnicas > Contas Google/YouTube — canais em lote** tem um ficheiro de cookies próprio e um `sessionInfo token` próprio. O carregador aceita três representações: objecto JSON com os cookies, lista JSON de cookies e formato Netscape; os cinco nomes obrigatórios são `SID`, `SSID`, `HSID`, `APISID` e `SAPISID`. O ficheiro validado é guardado em `storage/youtube_direct_accounts/<id-da-conta>/cookies.json`, fora de `storage/state/`, com permissões locais restritas.
+
+Em **Canais > Upload directo — conta e canal**, associe cada canal à conta Google que detém os cookies e o `sessionInfo token`, e preencha o `DELEGATED_SESSION_ID` individual desse canal. O upload lê os cookies e o token da conta associada e usa o ID delegado do canal como `pageId`/destino. No momento do upload, o Thunderbolt bloqueia a operação se não existir conta associada, ficheiro de cookies válido, `sessionInfo token`, `DELEGATED_SESSION_ID`, `INNERTUBE_API_KEY` ou vídeo elegível. O tamanho de chunk é validado e normalizado para múltiplos de 262144 bytes. O método é uma integração não oficial de sessão do YouTube; não extraia cookies automaticamente, não os coloque no repositório e não os partilhe.
 
 ## MCP e integrações externas
 

package/README.md

@@ -20,14 +20,23 @@ A primeira versão implementa a camada UI independente com:
 | Models AI | Menu expansível com Personagens e Redes Sociais reservados para desenvolvimento futuro |
 | Niche Finder | Menu expansível com duas alternativas independentes: Niche Finder Kaggle e Niche Finder Apify, com parâmetros, execução e resultados separados |
 | Edição | Menu expansível abaixo de Automação com Limpador de Metadados 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 |
+| Upload | YouTube via `youtube-automation-agent` adaptado internamente, OAuth directo de redundância, Upload directo via sessão Frontend API com cookies/sessionInfo por conta e DELEGATED_SESSION_ID por canal, TikTok, Instagram e Facebook Pages no front end |
 | 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, 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 |
+| 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, cookies SID/SSID/HSID/APISID/SAPISID e sessionInfo 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 |
 
+## Upload directo — credenciais por conta e por canal
+
+O Upload directo baseado no [YouTube-Video-Upload-Frontend-Api](https://github.com/Nojus10/YouTube-Video-Upload-Frontend-Api) usa dois níveis de configuração. Em **Configurações Técnicas > Upload directo — sessão YouTube Frontend API**, cada conta Google cadastrada possui o seu próprio ficheiro de cookies e o seu próprio `sessionInfo token`. O ficheiro pode ser um JSON exportado do navegador, uma lista JSON de cookies ou um ficheiro Netscape; o Thunderbolt valida e guarda apenas `SID`, `SSID`, `HSID`, `APISID` e `SAPISID` em `storage/youtube_direct_accounts/<id-da-conta>/cookies.json`.
+
+Em **Canais > Upload directo — conta e canal**, cada canal é associado à conta Google que fornece os cookies e o `sessionInfo token`, e possui o seu próprio `DELEGATED_SESSION_ID`. O upload lê os cookies e o token da conta associada e envia o ID delegado individual do canal como `pageId`/`onBehalfOfUser`. O botão é bloqueado quando falta qualquer destes elementos. O `INNERTUBE_API_KEY` e o tamanho de chunk continuam nas configurações directas; o tamanho é normalizado para múltiplos de 262144 bytes.
+
+Os dados são segredos de sessão. Os valores não aparecem em tabelas ou logs, o ficheiro é escrito com permissões locais restritas e não é incluído no Git. O Thunderbolt não extrai cookies automaticamente do browser e não envia as credenciais para o GitHub. O método é não oficial e pode deixar de funcionar se o YouTube alterar os endpoints internos.
+
+
 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.41
+## Navegação da UI 0.2.42
 
 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 +125,9 @@ thunderbolt
 No Windows PowerShell, se `npx` for bloqueado por `npx.ps1`, use directamente `npx.cmd`:
 
 ```powershell
-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
+npx.cmd --yes @danhachuel/thunderbolt@0.2.42 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.42 doctor
+npx.cmd --yes @danhachuel/thunderbolt@0.2.42
 ```
 
 Como alternativa, pode permitir scripts para o seu utilizador:
@@ -142,7 +151,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.41 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.42 install`; o instalador detecta e reutiliza componentes já válidos.
 
 ## Editor Python baseado no PYEdit
 

package/app/main.py

@@ -34,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_direct_credentials import COOKIE_KEYS as DIRECT_COOKIE_KEYS, direct_account_status, save_cookie_file
 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
@@ -341,6 +342,11 @@ 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)
+    youtube_accounts = [account for account in settings.get("youtube_batch_accounts", []) if isinstance(account, dict) and account.get("id")]
+    youtube_account_ids = [""] + [str(account["id"]) for account in youtube_accounts]
+    youtube_account_labels = {"": "Sem conta Google associada"}
+    youtube_account_labels.update({str(account["id"]): f"{account.get('label', 'Canais YouTube')} — {account.get('email', 'sem e-mail')}" for account in youtube_accounts})
+    youtube_accounts_by_id = {str(account["id"]): account for account in youtube_accounts}
     import_tab, batch_tab, manual_tab = st.tabs(["Importar do YouTube", "Canais em lote gmail", "Cadastro manual"])
 
     with import_tab:
@@ -386,6 +392,8 @@ def render_channels():
                 voice_options = voice_catalog(imported.get("default_voice") or imported.get("voice", ""))
                 current_voice = imported.get("default_voice") or imported.get("voice", "")
                 voice = st.selectbox("Voz padrão do canal", voice_options, index=voice_options.index(current_voice) if current_voice in voice_options else 0, format_func=lambda item: item or "Sem voz padrão", key="yt_import_voice")
+                imported_account_id = str(imported.get("google_account_id", ""))
+                google_account_id = st.selectbox("Conta Google para Upload directo", youtube_account_ids, index=youtube_account_ids.index(imported_account_id) if imported_account_id in youtube_account_ids else 0, format_func=lambda item: youtube_account_labels.get(item, item), key="yt_import_google_account_id")
                 delegated_session_id = st.text_input("DELEGATED_SESSION_ID", value=imported.get("delegated_session_id", ""), type="password", key="yt_import_delegated_session_id")
                 automation_on = st.toggle("Automação ON", value=bool(imported.get("automation_on", False)), key="yt_import_automation_on")
                 automation_time = st.text_input("Horário diário (HH:MM)", value=imported.get("automation_time", "00:00"), key="yt_import_automation_time")
@@ -412,6 +420,8 @@ def render_channels():
                             "default_voice": voice.strip(),
                             "voice": voice.strip(),
                             "delegated_session_id": delegated_session_id.strip(),
+                            "google_account_id": google_account_id.strip(),
+                            "google_account_email": str(youtube_accounts_by_id.get(google_account_id, {}).get("email", "")),
                             "automation_on": bool(automation_on),
                             "automation_time": automation_time.strip() if valid_hhmm(automation_time) else "00:00",
                             "subscriber_count": int(subscriber_count) or None,
@@ -530,6 +540,7 @@ def render_channels():
             blueprint = st.selectbox("Blueprint padrão do canal", manual_blueprint_ids, format_func=lambda item: manual_blueprint_labels.get(item, item or "Sem Blueprint padrão"), key="manual_channel_blueprint")
             voice_options = voice_catalog()
             voice = st.selectbox("Voz padrão do canal", voice_options, format_func=lambda item: item or "Sem voz padrão", key="manual_channel_voice")
+            google_account_id = st.selectbox("Conta Google para Upload directo", youtube_account_ids, format_func=lambda item: youtube_account_labels.get(item, item), key="manual_channel_google_account_id")
             delegated_session_id = st.text_input("DELEGATED_SESSION_ID", type="password", key="manual_channel_delegated_session_id")
             automation_on = st.toggle("Automação ON", value=False, key="manual_channel_automation_on")
             automation_time = st.text_input("Horário diário (HH:MM)", value="00:00", key="manual_channel_automation_time")
@@ -555,6 +566,8 @@ def render_channels():
                         "default_voice": voice.strip(),
                         "voice": voice.strip(),
                         "delegated_session_id": delegated_session_id.strip(),
+                        "google_account_id": google_account_id.strip(),
+                        "google_account_email": str(youtube_accounts_by_id.get(google_account_id, {}).get("email", "")),
                         "automation_on": bool(automation_on),
                         "automation_time": automation_time.strip(),
                         "thumbnail_url": thumbnail_url.strip(),
@@ -573,6 +586,20 @@ def render_channels():
         return
     for channel in channels:
         with st.container(border=True):
+            channel_account_ids = list(youtube_account_ids)
+            current_channel_account_id = str(channel.get("google_account_id", ""))
+            if current_channel_account_id and current_channel_account_id not in channel_account_ids:
+                channel_account_ids.append(current_channel_account_id)
+                youtube_account_labels[current_channel_account_id] = "Conta Google não configurada"
+            with st.expander("Upload directo — conta e canal", expanded=False):
+                with st.form(f"channel_direct_credentials_{channel['id']}"):
+                    channel_account_id = st.selectbox("Conta Google dos cookies/sessionInfo", channel_account_ids, index=channel_account_ids.index(current_channel_account_id) if current_channel_account_id in channel_account_ids else 0, format_func=lambda item: youtube_account_labels.get(item, item or "Sem conta Google associada"), key=f"channel_account_{channel['id']}")
+                    channel_delegated_session_id = st.text_input("DELEGATED_SESSION_ID deste canal", value=str(channel.get("delegated_session_id", "")), type="password", key=f"channel_delegated_session_id_{channel['id']}")
+                    save_channel_direct_credentials = st.form_submit_button("Guardar credenciais deste canal", type="primary")
+                if save_channel_direct_credentials:
+                    update_channel(channel["id"], {"google_account_id": channel_account_id.strip(), "google_account_email": str(youtube_accounts_by_id.get(channel_account_id, {}).get("email", "")), "delegated_session_id": channel_delegated_session_id.strip()})
+                    st.success("Conta Google e DELEGATED_SESSION_ID guardados neste canal.")
+                    st.rerun()
             cols = st.columns([0.6, 2.2, 1.2, 1.2, 1.2, 1])
             with cols[0]:
                 if channel.get("thumbnail_url"):
@@ -1237,6 +1264,7 @@ def render_upload_direct():
     if not tasks:
         st.info("Não há vídeos prontos para upload directo.")
         return
+    direct_accounts = {str(account.get("id")): account for account in settings.get("youtube_batch_accounts", []) if isinstance(account, dict) and account.get("id")}
     channel_map = {channel.get("id"): channel for channel in channels}
     for task in tasks:
         channel = channel_map.get(task.get("channel_id"), {})
@@ -1244,8 +1272,15 @@ def render_upload_direct():
         with st.container(border=True):
             st.write(f"**{task.get('topic', 'Sem tópico')}** — {task.get('channel_name', 'Canal')}")
             st.caption(video_path or "Sem caminho de vídeo registado")
+            account = direct_accounts.get(str(channel.get("google_account_id", "")))
             if not channel.get("delegated_session_id"):
                 st.warning("Este canal não tem DELEGATED_SESSION_ID configurado na aba Canais.")
+            if not account:
+                st.warning("Este canal não tem uma conta Google associada. Configure-a em Canais > Upload directo — conta e canal.")
+            elif not direct_account_status(STORAGE, account)["ready"]:
+                st.warning("A conta Google deste canal não tem cookies completos e sessionInfo token configurados em Configurações Técnicas.")
+            elif channel.get("delegated_session_id"):
+                st.caption(f"Credenciais directas: {account.get('email', 'conta Google')} · DELEGATED_SESSION_ID configurado")
             direct_cols = st.columns([2.2, 1, 1])
             with direct_cols[0]:
                 title = st.text_input("Título", value=task.get("topic", "Vídeo Thunderbolt"), key=f"direct_title_{task['id']}")
@@ -1255,12 +1290,19 @@ def render_upload_direct():
                 chunk_size = st.number_input("Chunk bytes", min_value=262144, step=262144, value=int(settings.get("direct_chunk_size", 262144)), key=f"direct_chunk_{task['id']}")
             description = st.text_area("Descrição", value=task.get("description", ""), key=f"direct_description_{task['id']}", height=90)
             if st.button("Enviar por Upload directo", type="primary", key=f"direct_upload_{task['id']}"):
-                result = YouTubeDirectUploader(settings, channel).upload(video_path, title=title, description=description, visibility=privacy, chunk_size=int(chunk_size))
-                record = {"task_id": task.get("id"), "channel_id": channel.get("id"), "destination": "YouTube direct frontend", "status": "published" if result.ok else "failed", "message": result.message, "data": result.data, "created_at": now()}
-                uploads = read_json("uploads.json", [])
-                uploads.append(record)
-                write_json("uploads.json", uploads)
-                (st.success if result.ok else st.error)(result.message)
+                if not account:
+                    st.error("Associe primeiro este canal a uma conta Google em Canais.")
+                elif not channel.get("delegated_session_id"):
+                    st.error("Configure primeiro o DELEGATED_SESSION_ID individual deste canal em Canais.")
+                elif not direct_account_status(STORAGE, account)["ready"]:
+                    st.error("Configure primeiro o ficheiro de cookies e o sessionInfo token desta conta em Configurações Técnicas.")
+                else:
+                    result = YouTubeDirectUploader(settings, channel, account=account, storage_root=STORAGE).upload(video_path, title=title, description=description, visibility=privacy, chunk_size=int(chunk_size))
+                    record = {"task_id": task.get("id"), "channel_id": channel.get("id"), "google_account_id": account.get("id", ""), "destination": "YouTube direct frontend", "status": "published" if result.ok else "failed", "message": result.message, "data": result.data, "created_at": now()}
+                    uploads = read_json("uploads.json", [])
+                    uploads.append(record)
+                    write_json("uploads.json", uploads)
+                    (st.success if result.ok else st.error)(result.message)
 
 
 def render_upload():
@@ -1494,18 +1536,46 @@ def render_settings():
             st.caption("A YouTube Data API Key é uma credencial Google Cloud separada do OAuth. Só é necessária se escolher o método YouTube Data API para consultar métricas oficiais. Não é necessária para Página pública — sem API Key, para autorizar OAuth ou para fazer upload.")
             youtube_api_key = text_setting("YouTube Data API Key (opcional)", "youtube_api_key", secret=True, help_text="Credencial separada, criada em Google Cloud > APIs e serviços > Credenciais > Chave de API. Não cole aqui o Client ID nem o Client Secret.")
 
+        direct_account_session_fields = {}
+        direct_cookie_uploads = {}
         with st.expander("Upload directo — sessão YouTube Frontend API"):
-            st.caption("Campos usados apenas pelo método Upload directo. Não são necessários para o youtube-automation-agent nem para a Data API pública.")
-            direct_cookie_cols = st.columns(3)
-            with direct_cookie_cols[0]:
-                direct_cookie_sid = text_setting("SID", "direct_cookie_sid", secret=True)
-                direct_cookie_ssid = text_setting("SSID", "direct_cookie_ssid", secret=True)
-            with direct_cookie_cols[1]:
-                direct_cookie_hsid = text_setting("HSID", "direct_cookie_hsid", secret=True)
-                direct_cookie_apisid = text_setting("APISID", "direct_cookie_apisid", secret=True)
-            with direct_cookie_cols[2]:
-                direct_cookie_sapisid = text_setting("SAPISID", "direct_cookie_sapisid", secret=True)
-                direct_session_info = text_setting("sessionInfo token", "direct_session_info", secret=True)
+            st.caption("Os cookies e o sessionInfo token são configurados por conta Google/YouTube. O DELEGATED_SESSION_ID é configurado separadamente em cada canal.")
+            direct_accounts = [account for account in settings.get("youtube_batch_accounts", []) if isinstance(account, dict) and account.get("id")]
+            if not direct_accounts:
+                st.info("Adicione primeiro uma conta em Contas Google/YouTube — canais em lote. Cada conta terá o seu ficheiro de cookies e sessionInfo token.")
+            for direct_account in direct_accounts:
+                direct_account_id = str(direct_account["id"])
+                direct_status = direct_account_status(STORAGE, direct_account)
+                with st.container(border=True):
+                    st.markdown(f"**{direct_account.get('label', 'Canais YouTube')}** — `{direct_account.get('email', 'sem e-mail')}`")
+                    direct_account_cols = st.columns([1.6, 1.6, 1])
+                    with direct_account_cols[0]:
+                        direct_session_info_value = st.text_input("sessionInfo token", value=str(direct_account.get("direct_session_info", "")), type="password", key=f"direct_session_info_{direct_account_id}")
+                    with direct_account_cols[1]:
+                        direct_cookie_uploads[direct_account_id] = st.file_uploader("Ficheiro de cookies", type=["json", "txt", "cookies", "tsv"], key=f"direct_cookie_file_{direct_account_id}", help="JSON de cookies do navegador ou ficheiro Netscape com SID, SSID, HSID, APISID e SAPISID.")
+                    with direct_account_cols[2]:
+                        if direct_status["cookie_file_exists"] and not direct_status["missing_cookies"]:
+                            st.success("Cookies guardados")
+                        elif direct_status["cookie_file_exists"]:
+                            st.warning(f"Faltam: {', '.join(direct_status['missing_cookies'])}")
+                        else:
+                            st.warning("Sem ficheiro de cookies")
+                    st.caption("O ficheiro é guardado em storage/youtube_direct_accounts/<conta>/cookies.json. Os valores não são mostrados nem enviados para o Git.")
+                    direct_account_session_fields[direct_account_id] = direct_session_info_value
+
+            with st.container(border=True):
+                st.markdown("**Compatibilidade com instalação antiga — credenciais globais**")
+                st.caption("Use apenas para manter instalações antigas. Quando houver uma conta Google configurada, o Upload directo usa o ficheiro e o sessionInfo dessa conta.")
+                direct_cookie_cols = st.columns(3)
+                with direct_cookie_cols[0]:
+                    direct_cookie_sid = text_setting("SID", "direct_cookie_sid", secret=True)
+                    direct_cookie_ssid = text_setting("SSID", "direct_cookie_ssid", secret=True)
+                with direct_cookie_cols[1]:
+                    direct_cookie_hsid = text_setting("HSID", "direct_cookie_hsid", secret=True)
+                    direct_cookie_apisid = text_setting("APISID", "direct_cookie_apisid", secret=True)
+                with direct_cookie_cols[2]:
+                    direct_cookie_sapisid = text_setting("SAPISID", "direct_cookie_sapisid", secret=True)
+                    direct_session_info = text_setting("sessionInfo token global", "direct_session_info", secret=True)
             direct_innertube_api_key = text_setting("INNERTUBE_API_KEY", "direct_innertube_api_key", secret=True)
             direct_chunk_size = st.number_input("Chunk size (múltiplo de 262144)", min_value=262144, step=262144, value=int(settings.get("direct_chunk_size", 262144)))
 
@@ -1607,6 +1677,20 @@ def render_settings():
             upload_post_auto_upload = st.checkbox("Publicar automaticamente após gerar", bool(settings.get("upload_post_auto_upload", False)))
 
         if st.form_submit_button("Guardar configurações do Thunderbolt", type="primary"):
+            direct_cookie_error = ""
+            configured_direct_accounts = [account for account in settings.get("youtube_batch_accounts", []) if isinstance(account, dict) and account.get("id")]
+            for direct_account in configured_direct_accounts:
+                direct_account_id = str(direct_account["id"])
+                direct_account["direct_session_info"] = str(direct_account_session_fields.get(direct_account_id, direct_account.get("direct_session_info", "")) or "").strip()
+                uploaded_cookie_file = direct_cookie_uploads.get(direct_account_id)
+                if uploaded_cookie_file is not None:
+                    try:
+                        save_cookie_file(STORAGE, direct_account, uploaded_cookie_file.getvalue(), uploaded_cookie_file.name)
+                    except ValueError as exc:
+                        direct_cookie_error = str(exc)
+            settings["youtube_batch_accounts"] = configured_direct_accounts
+            if direct_cookie_error:
+                st.error(direct_cookie_error)
             settings.update({
                 "port": port, "moneyprinter_path": moneyprinter_path, "youtube_api_key": youtube_api_key,
                 "youtube_client_id": youtube_client_id, "youtube_client_secret": youtube_client_secret,
@@ -1631,14 +1715,17 @@ def render_settings():
                 "upload_post_auto_upload": upload_post_auto_upload,
             })
             write_json("settings.json", settings)
-            try:
-                synced = sync_moneyprinter_config(settings, moneyprinter_path)
-                if synced:
-                    st.success(f"Configurações guardadas e sincronizadas com {synced}")
-                else:
-                    st.success("Configurações guardadas localmente. Indique uma pasta válida do motor de vídeo para sincronizar config.toml.")
-            except Exception as exc:
-                st.warning(f"Configurações locais guardadas, mas não foi possível sincronizar config.toml: {exc}")
+            if direct_cookie_error:
+                st.warning("As restantes configurações foram guardadas, mas o ficheiro de cookies não foi substituído. Corrija o ficheiro e tente novamente.")
+            else:
+                try:
+                    synced = sync_moneyprinter_config(settings, moneyprinter_path)
+                    if synced:
+                        st.success(f"Configurações guardadas e sincronizadas com {synced}")
+                    else:
+                        st.success("Configurações guardadas localmente. Indique uma pasta válida do motor de vídeo para sincronizar config.toml.")
+                except Exception as exc:
+                    st.warning(f"Configurações locais guardadas, mas não foi possível sincronizar config.toml: {exc}")
 
     st.divider()
     st.subheader("Teste de vozes")

package/integrations/youtube_direct_credentials.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+import secrets
+from pathlib import Path
+from typing import Any
+
+COOKIE_KEYS = ("SID", "SSID", "HSID", "APISID", "SAPISID")
+
+
+def account_key(account: dict[str, Any]) -> str:
+    raw = str(account.get("id") or "").strip()
+    safe = re.sub(r"[^A-Za-z0-9._-]+", "-", raw).strip(".-")
+    return safe[:80] or "google-account"
+
+
+def account_directory(storage_root: Path, account: dict[str, Any]) -> Path:
+    return Path(storage_root) / "youtube_direct_accounts" / account_key(account)
+
+
+def cookie_file_path(storage_root: Path, account: dict[str, Any]) -> Path:
+    return account_directory(storage_root, account) / "cookies.json"
+
+
+def _normalise_pairs(value: Any) -> dict[str, str]:
+    pairs: dict[str, str] = {}
+    if isinstance(value, dict):
+        if isinstance(value.get("cookies"), list):
+            return _normalise_pairs(value["cookies"])
+        for key, item in value.items():
+            key_text = str(key).strip()
+            if key_text in COOKIE_KEYS:
+                pairs[key_text] = str(item or "").strip()
+        return pairs
+    if isinstance(value, list):
+        for item in value:
+            if isinstance(item, dict):
+                name = str(item.get("name") or item.get("key") or "").strip()
+                content = str(item.get("value") or "").strip()
+                if name in COOKIE_KEYS:
+                    pairs[name] = content
+        return pairs
+    return pairs
+
+
+def parse_cookie_file(content: bytes, filename: str = "cookies.json") -> dict[str, str]:
+    text = content.decode("utf-8-sig", errors="replace").strip()
+    pairs: dict[str, str] = {}
+    try:
+        parsed = json.loads(text)
+        pairs.update(_normalise_pairs(parsed))
+    except json.JSONDecodeError:
+        for line in text.splitlines():
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            fields = line.split("\t")
+            if len(fields) >= 7 and fields[5].strip() in COOKIE_KEYS:
+                pairs[fields[5].strip()] = fields[6].strip()
+                continue
+            if "=" in line:
+                name, value = line.split("=", 1)
+                name = name.strip()
+                if name in COOKIE_KEYS:
+                    pairs[name] = value.strip().rstrip(";")
+    missing = [key for key in COOKIE_KEYS if not pairs.get(key)]
+    if missing:
+        raise ValueError(f"Faltam cookies obrigatórios no ficheiro {filename}: {', '.join(missing)}.")
+    return {key: pairs[key] for key in COOKIE_KEYS}
+
+
+def save_cookie_file(storage_root: Path, account: dict[str, Any], content: bytes, filename: str = "cookies.json") -> Path:
+    cookies = parse_cookie_file(content, filename)
+    destination = cookie_file_path(storage_root, account)
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    temporary = destination.with_name(f".{destination.name}.{secrets.token_hex(6)}.tmp")
+    temporary.write_text(json.dumps(cookies, ensure_ascii=False, indent=2), encoding="utf-8")
+    try:
+        os.chmod(temporary, 0o600)
+    except OSError:
+        pass
+    temporary.replace(destination)
+    try:
+        os.chmod(destination, 0o600)
+    except OSError:
+        pass
+    return destination
+
+
+def load_cookie_file(storage_root: Path, account: dict[str, Any]) -> dict[str, str]:
+    path = cookie_file_path(storage_root, account)
+    if not path.exists():
+        return {}
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return _normalise_pairs(raw)
+
+
+def direct_account_status(storage_root: Path, account: dict[str, Any]) -> dict[str, Any]:
+    cookies = load_cookie_file(storage_root, account)
+    missing = [key for key in COOKIE_KEYS if not cookies.get(key)]
+    session_info = str(account.get("direct_session_info") or "").strip()
+    return {
+        "cookie_file": str(cookie_file_path(storage_root, account)),
+        "cookie_file_exists": cookie_file_path(storage_root, account).exists(),
+        "missing_cookies": missing,
+        "has_session_info": bool(session_info),
+        "ready": not missing and bool(session_info),
+    }

package/integrations/youtube_direct_upload.py

@@ -8,6 +8,8 @@ import time
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
+
+from integrations.youtube_direct_credentials import COOKIE_KEYS, load_cookie_file
 from urllib.parse import quote
 
 import requests
@@ -15,7 +17,6 @@ import requests
 
 CHUNK_GRANULARITY = 262144
 SUPPORTED_EXTENSIONS = {".mp4", ".mov", ".webm", ".avi", ".mpeg", ".mpg", ".flv", ".wmv", ".3gpp"}
-COOKIE_KEYS = ("SID", "SSID", "HSID", "APISID", "SAPISID")
 
 
 @dataclass
@@ -25,10 +26,20 @@ class DirectUploadResult:
     data: dict[str, Any]
 
 
-def _cookie_settings(settings: dict[str, Any]) -> dict[str, str]:
+def _cookie_settings(settings: dict[str, Any], account: dict[str, Any] | None = None, storage_root: Path | None = None) -> dict[str, str]:
+    if account is not None and storage_root is not None:
+        account_cookies = load_cookie_file(storage_root, account)
+        if account_cookies:
+            return {key: str(account_cookies.get(key, "") or "").strip() for key in COOKIE_KEYS}
     return {key: str(settings.get(f"direct_cookie_{key.lower()}", "") or "").strip() for key in COOKIE_KEYS}
 
 
+def _session_info(settings: dict[str, Any], account: dict[str, Any] | None = None) -> str:
+    if account is not None:
+        return str(account.get("direct_session_info", "") or "").strip()
+    return str(settings.get("direct_session_info", "") or "").strip()
+
+
 def _cookie_header(cookies: dict[str, str]) -> str:
     return ";".join(["CONSENT=YES+cb"] + [f"{key}={value}" for key, value in cookies.items() if value])
 
@@ -51,7 +62,7 @@ def _header(response: requests.Response, name: str) -> str:
     return ""
 
 
-def validate_direct_upload(video_path: str | Path, channel: dict[str, Any], settings: dict[str, Any]) -> str | None:
+def validate_direct_upload(video_path: str | Path, channel: dict[str, Any], settings: dict[str, Any], account: dict[str, Any] | None = None, storage_root: Path | None = None) -> str | None:
     path = Path(video_path)
     if not path.exists() or not path.is_file():
         return "Ficheiro de vídeo não encontrado."
@@ -59,10 +70,10 @@ def validate_direct_upload(video_path: str | Path, channel: dict[str, Any], sett
         return "Formato de vídeo não suportado pelo upload directo."
     if path.stat().st_size <= 0:
         return "O ficheiro de vídeo está vazio."
-    missing_cookies = [key for key, value in _cookie_settings(settings).items() if not value]
+    missing_cookies = [key for key, value in _cookie_settings(settings, account, storage_root).items() if not value]
     if missing_cookies:
         return f"Faltam cookies de sessão para upload directo: {', '.join(missing_cookies)}."
-    if not str(settings.get("direct_session_info", "") or "").strip():
+    if not _session_info(settings, account):
         return "Configure o token sessionInfo do upload directo."
     if not str(settings.get("direct_innertube_api_key", "") or "").strip():
         return "Configure o INNERTUBE_API_KEY do upload directo."
@@ -72,11 +83,14 @@ def validate_direct_upload(video_path: str | Path, channel: dict[str, Any], sett
 
 
 class YouTubeDirectUploader:
-    def __init__(self, settings: dict[str, Any], channel: dict[str, Any], *, session: requests.Session | None = None):
+    def __init__(self, settings: dict[str, Any], channel: dict[str, Any], *, account: dict[str, Any] | None = None, storage_root: Path | None = None, session: requests.Session | None = None):
         self.settings = settings
         self.channel = channel
+        self.account = account
+        self.storage_root = storage_root
         self.session = session or requests.Session()
-        self.cookies = _cookie_settings(settings)
+        self.cookies = _cookie_settings(settings, account, storage_root)
+        self.session_info = _session_info(settings, account)
         self.cookie_header = _cookie_header(self.cookies)
         self.user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/124 Safari/537.36"
         self.inner_tube = _innertube_id()
@@ -124,7 +138,7 @@ class YouTubeDirectUploader:
             "botguardClientResponse": f"${hashlib.sha1(os.urandom(16)).hexdigest()}",
             "context": {
                 "client": {"clientName": 62, "clientVersion": "1.20210806.02.00", "hl": "pt-BR", "gl": "BR", "experimentsToken": "", "utcOffsetMinutes": 0},
-                "request": {"sessionInfo": {"token": str(self.settings.get("direct_session_info", ""))}},
+                "request": {"sessionInfo": {"token": self.session_info}},
                 "user": {"onBehalfOfUser": str(self.channel.get("delegated_session_id", ""))},
             },
         }
@@ -157,13 +171,13 @@ class YouTubeDirectUploader:
 
     def upload(self, video_path: str | Path, *, title: str, description: str = "", visibility: str = "private", chunk_size: int = CHUNK_GRANULARITY) -> DirectUploadResult:
         path = Path(video_path)
-        validation_error = validate_direct_upload(path, self.channel, self.settings)
+        validation_error = validate_direct_upload(path, self.channel, self.settings, self.account, self.storage_root)
         if validation_error:
             return DirectUploadResult(False, validation_error, {"mechanism": "youtube-frontend-direct"})
         try:
             self.describe_file(path)
             self.create_video(title, description, visibility)
             self.upload_chunks(path, chunk_size)
-            return DirectUploadResult(True, f"Upload directo concluído: {self.video_id}", {"mechanism": "youtube-frontend-direct", "video_id": self.video_id, "page_id": self.channel.get("delegated_session_id", "")})
+            return DirectUploadResult(True, f"Upload directo concluído: {self.video_id}", {"mechanism": "youtube-frontend-direct", "video_id": self.video_id, "page_id": self.channel.get("delegated_session_id", ""), "google_account_id": (self.account or {}).get("id", "")})
         except (requests.RequestException, OSError, ValueError, RuntimeError) as exc:
             return DirectUploadResult(False, f"Upload directo falhou: {exc}", {"mechanism": "youtube-frontend-direct", "video_id": self.video_id})

package/package.json

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