@danhachuel/thunderbolt 0.2.44 → 0.2.46

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.44
+> **Versão deste manual:** 0.2.46
 > **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.44 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.46 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes @danhachuel/thunderbolt@0.2.44 install
+npx --yes @danhachuel/thunderbolt@0.2.46 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.
@@ -371,7 +371,7 @@ As credenciais devem ser inseridas apenas na configuração local. A Kaggle API
 
 ## OpenAI/ NVIDIA NIM — API key, Base URL e modelo
 
-A secção **LLM — providers e modelos** mantém o provider técnico `openai`, mas a área visual passou a chamar-se **OpenAI/ NVIDIA NIM — API key, Base URL e modelo**. Isto permite usar a API oficial da OpenAI, a API pública NVIDIA NIM/NVIDIA Build ou qualquer servidor local OpenAI-compatible sem alterar o restante fluxo do MoneyPrinterTurbo.
+A secção **LLM — providers e modelos** mantém o provider técnico `openai`, mas a área visual passou a chamar-se **OpenAI/ NVIDIA NIM — API key, Base URL e modelo**. Isto permite usar a API oficial da OpenAI, a API pública NVIDIA NIM/NVIDIA Build ou qualquer servidor local OpenAI-compatible sem alterar o restante fluxo do MoneyPrinterTurbo. O campo de modelo manual utiliza o parâmetro `help` compatível com as versões de Streamlit instaladas pelo Thunderbolt; não utiliza `help_text`.
 
 Para usar NVIDIA NIM, abra **Configurações > Configurações Técnicas**, mantenha ou preencha a Base URL `https://integrate.api.nvidia.com/v1` e introduza a API key do NVIDIA Build. Clique em **Consultar/actualizar modelos NIM**. O Thunderbolt executa a consulta apenas nesse momento, acrescentando `/models` à Base URL, envia a API key como `Authorization: Bearer ...` e interpreta a resposta OpenAI-compatible `data[].id`. Os IDs devolvidos aparecem num selector; ao escolher um, o valor é guardado em `openai_model_name` e continua a ser enviado para o `config.toml` do MoneyPrinterTurbo.
 
@@ -397,7 +397,7 @@ Após iniciar a aplicação, valide o seguinte percurso:
 12. **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`.
 13. **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.
 14. **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.
-15. **Upload directo:** em **Configurações > Configurações Técnicas > Contas Google/YouTube — canais em lote**, adicione cada conta Google. No painel aberto **Upload directo — sessão YouTube Frontend API**, preencha o `sessionInfo token` dessa conta, carregue o ficheiro de cookies e clique em **Guardar cookies e sessionInfo por conta**. Em **Canais > Canais cadastrados**, use o painel aberto **Upload directo — conta e canal** para preencher o `DELEGATED_SESSION_ID deste canal (individual)` e clique em **Guardar credenciais deste canal**. 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. **Upload directo:** em **Configurações > Configurações Técnicas > Contas Google/YouTube — canais em lote**, cada cartão Gmail apresenta apenas o uploader **Documento de credenciais desta conta Google**. O documento JSON reúne `SID`, `SSID`, `HSID`, `APISID`, `SAPISID`, `sessionInfo`, `INNERTUBE_API_KEY`, `chunk_size` e `delegated_session_ids` por canal. Em **Canais > Canais cadastrados**, associe cada canal à conta Google do documento; a UI não mostra nem edita o `DELEGATED_SESSION_ID`. O documento é guardado em `storage/youtube_direct_accounts/<id-da-conta>/credentials.json`, e o uploader lê todos os valores exclusivamente desse documento. Não existem campos técnicos do Upload directo na parte inferior da UI e o método não extrai cookies automaticamente do navegador.
 16. **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.
 17. **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.
 18. **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.
@@ -418,7 +418,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.44 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.46 install`; o instalador detecta e reutiliza o que já estiver válido.
 
 ### Niche Finder Apify
 
@@ -448,13 +448,13 @@ A área **Teste de vozes**, dentro de **Configurações > Configurações Técni
 
 ## Upload directo
 
-Em **Canais > Canais cadastrados**, o painel **Upload directo — conta e canal** fica aberto por defeito em cada cartão. Seleccione a conta Google responsável pelo canal, preencha o campo **DELEGATED_SESSION_ID deste canal (individual)** e clique em **Guardar credenciais deste canal**. Este valor não é global: cada canal deve ter o seu próprio ID delegado.
+Em **Configurações > Configurações Técnicas > Contas Google/YouTube — canais em lote**, cada cartão Gmail mostra apenas o uploader **Documento de credenciais desta conta Google**. O documento JSON único pode conter cookies, sessionInfo, INNERTUBE_API_KEY, chunk_size e o mapa de IDs delegados por canal. Os valores nunca aparecem como inputs separados; o ficheiro validado é guardado por conta em `storage/youtube_direct_accounts/<id-da-conta>/credentials.json`.
 
-Em **Configurações Técnicas > Upload directo — sessão YouTube Frontend API**, o painel fica aberto por defeito. Para cada conta listada, preencha o **sessionInfo token**, carregue em **Ficheiro de cookies** o ficheiro JSON/lista JSON/Netscape que contém `SID`, `SSID`, `HSID`, `APISID` e `SAPISID`, e clique em **Guardar cookies e sessionInfo por conta**. O ficheiro é gravado separadamente em `storage/youtube_direct_accounts/<id-da-conta>/cookies.json`; não é uma configuração global. Se ainda não existir nenhuma conta, adicione-a primeiro em **Contas Google/YouTube — canais em lote**.
+Em **Canais > Canais cadastrados**, a secção **Upload directo — documento da conta deste canal** mostra apenas a conta Google associada e confirma se o documento contém o ID delegado desse canal. O `DELEGATED_SESSION_ID` permanece exclusivamente no mapa do documento; o upload bloqueia a operação se faltar qualquer elemento técnico.
 
-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 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.
+A subaba **Upload directo** adapta o [YouTube-Video-Upload-Frontend-Api](https://github.com/Nojus10/YouTube-Video-Upload-Frontend-Api). Cada conta Google tem um único `credentials.json`, com cookies, sessionInfo, INNERTUBE_API_KEY, chunk_size e `delegated_session_ids` por canal. O parser aceita o documento JSON completo, valida os cinco cookies obrigatórios e grava-o 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.
+Associe cada canal à conta Google correcta em **Canais**; não introduza o ID delegado na UI. No momento do upload, o Thunderbolt lê o documento da conta, encontra o `DELEGATED_SESSION_ID` pela chave do canal e bloqueia a operação se faltar conta, documento válido, cookies, sessionInfo, INNERTUBE_API_KEY, ID delegado ou vídeo elegível. O tamanho de chunk é normalizado para múltiplos de 262144 bytes. O método é uma integração não oficial de sessão do YouTube; não extraia cookies automaticamente, não os coloque no repositório e não os partilhe.
 
 ## MCP e integrações externas
 

package/README.md

@@ -27,22 +27,22 @@ A primeira versão implementa a camada UI independente com:
 
 ## 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**, o painel fica aberto por defeito e cada conta Google cadastrada possui o seu próprio ficheiro de cookies e o seu próprio `sessionInfo token`. Primeiro adicione a conta em **Contas Google/YouTube — canais em lote**; depois, no painel da conta, surgem o campo `sessionInfo token`, o uploader **Ficheiro de cookies**, o estado do ficheiro e o botão **Guardar cookies e sessionInfo por conta**. 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`.
+O Upload directo baseado no [YouTube-Video-Upload-Frontend-Api](https://github.com/Nojus10/YouTube-Video-Upload-Frontend-Api) usa um único documento JSON por conta Google. Em **Configurações Técnicas > Contas Google/YouTube — canais em lote**, cada cartão Gmail possui apenas o uploader **Documento de credenciais desta conta Google**. Esse documento reúne `SID`, `SSID`, `HSID`, `APISID`, `SAPISID`, `sessionInfo`, `INNERTUBE_API_KEY`, `chunk_size` e o mapa `delegated_session_ids` por canal. A UI não contém inputs separados para nenhum destes valores.
 
-Em **Canais > Canais cadastrados**, o painel **Upload directo — conta e canal** fica aberto por defeito em cada cartão. Cada canal é associado à conta Google que fornece os cookies e o `sessionInfo token`, e possui o seu próprio `DELEGATED_SESSION_ID` no campo **DELEGATED_SESSION_ID deste canal (individual)**. 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.
+O documento é validado e guardado por Gmail em `storage/youtube_direct_accounts/<id-da-conta>/credentials.json`, com permissões locais restritas. Em **Canais > Canais cadastrados**, a UI apenas associa o canal à conta Google do documento; não mostra nem edita o `DELEGATED_SESSION_ID`. O uploader procura o ID do canal dentro do mapa `delegated_session_ids` do documento e usa-o como `pageId`/`onBehalfOfUser`. O Upload directo fica bloqueado quando faltar qualquer elemento no documento. Não existem campos técnicos do Upload directo na parte inferior de Configurações Técnicas.
 
 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.44
+## Navegação da UI 0.2.46
 
 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.
 
 ## OpenAI/ NVIDIA NIM — descoberta de modelos
 
-Em **Configurações Técnicas > LLM — providers e modelos**, a área anteriormente chamada **OpenAI — API key, Base URL e modelo** passa a chamar-se **OpenAI/ NVIDIA NIM — API key, Base URL e modelo**. O provider interno continua a ser `openai`, para preservar a compatibilidade com o MoneyPrinterTurbo e com os restantes endpoints OpenAI-compatible.
+Em **Configurações Técnicas > LLM — providers e modelos**, a área anteriormente chamada **OpenAI — API key, Base URL e modelo** passa a chamar-se **OpenAI/ NVIDIA NIM — API key, Base URL e modelo**. O campo de modelo manual usa o parâmetro `help` suportado pelas versões do Streamlit instaladas pelo Thunderbolt, evitando o erro de argumento `help_text`. O provider interno continua a ser `openai`, para preservar a compatibilidade com o MoneyPrinterTurbo e com os restantes endpoints OpenAI-compatible.
 
 A Base URL predefinida para NVIDIA NIM é `https://integrate.api.nvidia.com/v1`. Depois de inserir a API key, clique em **Consultar/actualizar modelos NIM**. O Thunderbolt consulta a Base URL acrescentando `/models`, lê os identificadores do formato OpenAI (`data[].id`) e apresenta-os num selector. O modelo escolhido é guardado em `openai_model_name` e é sincronizado para o `config.toml` do motor.
 
@@ -133,9 +133,9 @@ thunderbolt
 No Windows PowerShell, se `npx` for bloqueado por `npx.ps1`, use directamente `npx.cmd`:
 
 ```powershell
-npx.cmd --yes @danhachuel/thunderbolt@0.2.44 install
-npx.cmd --yes @danhachuel/thunderbolt@0.2.44 doctor
-npx.cmd --yes @danhachuel/thunderbolt@0.2.44
+npx.cmd --yes @danhachuel/thunderbolt@0.2.46 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.46 doctor
+npx.cmd --yes @danhachuel/thunderbolt@0.2.46
 ```
 
 Como alternativa, pode permitir scripts para o seu utilizador:
@@ -159,7 +159,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.44 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.46 install`; o instalador detecta e reutiliza componentes já válidos.
 
 ## Editor Python baseado no PYEdit
 

package/app/main.py

@@ -7,6 +7,7 @@ from datetime import date, datetime
 import sys
 import uuid
 from pathlib import Path
+from typing import Any
 
 import requests
 import streamlit as st
@@ -35,7 +36,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_direct_credentials import direct_account_status, document_status, parse_credentials_document, save_credentials_document
 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
@@ -396,7 +397,7 @@ def render_channels():
                 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")
+                st.caption("O DELEGATED_SESSION_ID é lido exclusivamente do documento JSON da conta Google associada.")
                 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")
                 description = st.text_area("Descrição", value=imported.get("description", ""), key="yt_import_description")
@@ -421,7 +422,6 @@ def render_channels():
                             "default_blueprint_id": blueprint.strip(),
                             "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),
@@ -543,7 +543,7 @@ def render_channels():
             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")
+            st.caption("O DELEGATED_SESSION_ID é lido exclusivamente do documento JSON da conta Google associada.")
             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")
             thumbnail_url = st.text_input("URL da imagem do canal", key="manual_channel_thumbnail")
@@ -567,7 +567,6 @@ def render_channels():
                         "default_blueprint_id": blueprint.strip(),
                         "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),
@@ -593,16 +592,33 @@ def render_channels():
             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=True):
-                st.caption("Defina aqui a conta Google deste canal e o DELEGATED_SESSION_ID individual. Os cookies e o sessionInfo token são carregados na área da conta em Configurações Técnicas.")
-                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 (individual)", 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()
+            st.markdown("**Upload directo — documento da conta deste canal**")
+            st.caption("O DELEGATED_SESSION_ID deste canal é individual, mas fica apenas no documento JSON da conta Google. A UI não mostra nem edita esse valor; associe apenas o canal à conta que contém o documento.")
+            with st.form(f"channel_direct_credentials_{channel['id']}"):
+                channel_account_id = st.selectbox("Conta Google do documento deste canal", 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']}")
+                save_channel_direct_credentials = st.form_submit_button("Associar conta Google ao canal", type="primary", use_container_width=True)
+            selected_channel_account = youtube_accounts_by_id.get(channel_account_id)
+            if selected_channel_account:
+                selected_account_status = document_status(STORAGE, selected_channel_account, channel, settings, channels)
+                if selected_account_status["ready"]:
+                    st.success("Documento da conta completo e DELEGATED_SESSION_ID deste canal encontrado no documento.")
+                elif not selected_account_status["document_exists"]:
+                    st.warning("A conta seleccionada ainda não tem documento JSON de credenciais.")
+                else:
+                    missing_channel_parts = list(selected_account_status["missing_cookies"])
+                    if not selected_account_status["has_session_info"]:
+                        missing_channel_parts.append("sessionInfo")
+                    if not selected_account_status["has_innertube_api_key"]:
+                        missing_channel_parts.append("INNERTUBE_API_KEY")
+                    if not selected_account_status["has_delegated_session_id"]:
+                        missing_channel_parts.append("DELEGATED_SESSION_ID deste canal")
+                    st.warning(f"Documento incompleto: {', '.join(missing_channel_parts)}")
+            else:
+                st.info("Associe este canal a uma conta Google para validar o documento de credenciais.")
+            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", ""))})
+                st.success("Conta Google associada ao canal. O DELEGATED_SESSION_ID continua exclusivamente no documento da conta.")
+                st.rerun()
             cols = st.columns([0.6, 2.2, 1.2, 1.2, 1.2, 1])
             with cols[0]:
                 if channel.get("thumbnail_url"):
@@ -1276,31 +1292,35 @@ def render_upload_direct():
             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.")
+            credential_status = document_status(STORAGE, account, channel, settings, channels) if account else None
             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")
+                st.warning("Este canal não tem uma conta Google associada. Associe a conta no cartão deste canal em Canais cadastrados.")
+            elif not credential_status["ready"]:
+                missing_direct_parts = list(credential_status["missing_cookies"])
+                if not credential_status["has_session_info"]:
+                    missing_direct_parts.append("sessionInfo")
+                if not credential_status["has_innertube_api_key"]:
+                    missing_direct_parts.append("INNERTUBE_API_KEY")
+                if not credential_status["has_delegated_session_id"]:
+                    missing_direct_parts.append("DELEGATED_SESSION_ID deste canal")
+                st.warning(f"Documento de credenciais incompleto: {', '.join(missing_direct_parts)}")
+            else:
+                st.caption(f"Documento de credenciais pronto: {account.get('email', 'conta Google')} · dados do canal encontrados no documento")
             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']}")
             with direct_cols[1]:
                 privacy = st.selectbox("Privacidade", ["private", "unlisted", "public"], key=f"direct_privacy_{task['id']}")
             with direct_cols[2]:
-                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']}")
+                st.caption("Chunk size lido do documento JSON da conta")
             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']}"):
                 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.")
+                    st.error("Associe primeiro este canal a uma conta Google no cartão Upload directo — credenciais deste canal em Canais cadastrados.")
+                elif not document_status(STORAGE, account, channel, settings, channels)["ready"]:
+                    st.error("Complete o documento JSON desta conta, incluindo cookies, sessionInfo, INNERTUBE_API_KEY e DELEGATED_SESSION_ID deste canal.")
                 else:
-                    result = YouTubeDirectUploader(settings, channel, account=account, storage_root=STORAGE).upload(video_path, title=title, description=description, visibility=privacy, chunk_size=int(chunk_size))
+                    result = YouTubeDirectUploader(settings, channel, account=account, storage_root=STORAGE).upload(video_path, title=title, description=description, visibility=privacy)
                     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)
@@ -1427,6 +1447,8 @@ def render_settings():
     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")]
+    direct_document_uploads: dict[str, Any] = {}
+    direct_account_save_buttons: dict[str, bool] = {}
     for batch_account in batch_accounts:
         account_id = str(batch_account["id"])
         with st.container(border=True):
@@ -1440,7 +1462,27 @@ def render_settings():
                     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)
+                save_account = st.form_submit_button("Guardar dados da conta Google", type="primary", use_container_width=True)
+            direct_status = direct_account_status(STORAGE, batch_account)
+            st.markdown("**Credenciais do Upload directo desta conta Google**")
+            st.caption("Estas credenciais pertencem apenas a este Gmail. O ficheiro contém SID, SSID, HSID, APISID e SAPISID e é guardado por ID da conta.")
+            direct_account_cols = st.columns([2.4, 1])
+            with direct_account_cols[0]:
+                direct_document_uploads[account_id] = st.file_uploader("Documento de credenciais desta conta Google", type=["json"], key=f"direct_credentials_document_{account_id}", help="Documento JSON com cookies SID/SSID/HSID/APISID/SAPISID, sessionInfo token, INNERTUBE_API_KEY, chunk_size e mapa delegated_session_ids.")
+            with direct_account_cols[1]:
+                if direct_status["document_exists"] and direct_status["ready"]:
+                    st.success("Documento completo")
+                elif direct_status["document_exists"]:
+                    missing_document_parts = list(direct_status["missing_cookies"])
+                    if not direct_status["has_session_info"]:
+                        missing_document_parts.append("sessionInfo")
+                    if not direct_status["has_innertube_api_key"]:
+                        missing_document_parts.append("INNERTUBE_API_KEY")
+                    st.warning(f"Documento incompleto: {', '.join(missing_document_parts)}")
+                else:
+                    st.warning("Sem documento de credenciais")
+            st.caption("Documento guardado em: storage/youtube_direct_accounts/<id-da-conta>/credentials.json")
+            direct_account_save_buttons[account_id] = st.button("Guardar documento de Upload directo desta conta", type="secondary", use_container_width=True, key=f"save_direct_account_{account_id}")
             account_status = youtube_batch_account_status(batch_account, STORAGE)
             status_cols = st.columns([2, 1, 1])
             with status_cols[0]:
@@ -1476,7 +1518,23 @@ def render_settings():
                     write_json("settings.json", settings)
                     st.success("Conta Google/YouTube guardada.")
                     st.rerun()
+            if direct_account_save_buttons.get(account_id):
+                uploaded_document = direct_document_uploads.get(account_id)
+                if uploaded_document is None:
+                    st.error("Seleccione o documento JSON completo desta conta Google antes de guardar.")
+                else:
+                    try:
+                        document = parse_credentials_document(uploaded_document.getvalue(), uploaded_document.name)
+                        document["account_id"] = account_id
+                        document["email"] = str(batch_account.get("email", ""))
+                        save_credentials_document(STORAGE, batch_account, document)
+                        st.success("Documento de Upload directo guardado exclusivamente para esta conta Google.")
+                        st.rerun()
+                    except ValueError as exc:
+                        st.error(str(exc))
     with st.form("add_batch_account_form"):
+        st.markdown("**Credenciais do Upload directo desta conta Google**")
+        st.caption("Estes campos pertencem a este Gmail. O ficheiro será guardado numa pasta exclusiva da conta e nunca será uma configuração global.")
         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")
@@ -1486,19 +1544,36 @@ def render_settings():
             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)
+        new_account_document = st.file_uploader("Documento de credenciais desta conta Google", type=["json"], key="new_batch_account_credentials_document", help="Documento JSON único com cookies SID/SSID/HSID/APISID/SAPISID, sessionInfo, INNERTUBE_API_KEY, chunk_size e delegated_session_ids.")
+        st.caption("O documento é guardado em storage/youtube_direct_accounts/<id-da-conta>/credentials.json. Não existem inputs separados para cookies ou sessionInfo.")
+        add_account = st.form_submit_button("Adicionar conta Google/YouTube com documento de Upload directo", use_container_width=True)
     if add_account:
+        document_error = ""
         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:
+        elif new_account_document is not None:
+            try:
+                parse_credentials_document(new_account_document.getvalue(), new_account_document.name)
+            except ValueError as exc:
+                document_error = str(exc)
+                st.error(document_error)
+        if "@" in new_account_email.strip() and new_account_client_id.strip() and new_account_client_secret.strip() and not document_error:
             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()}
+            if new_account_document is not None:
+                document = parse_credentials_document(new_account_document.getvalue(), new_account_document.name)
+                document["account_id"] = new_account["id"]
+                document["email"] = new_account["email"]
+                save_credentials_document(STORAGE, new_account, document)
             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.")
+            if new_account_document is not None:
+                st.success(f"Conta {new_account['email']} adicionada com documento de Upload directo por Gmail.")
+            else:
+                st.warning(f"Conta {new_account['email']} adicionada. Carregue o documento completo no cartão desta conta antes do Upload directo.")
             st.rerun()
 
     with st.form("settings_form"):
@@ -1539,51 +1614,9 @@ 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 = {}
-        save_direct_credentials = False
-        with st.expander("Upload directo — sessão YouTube Frontend API", expanded=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.warning("Ainda não existe uma conta Google/YouTube cadastrada. Adicione primeiro a conta acima; depois deste formulário aparecerão, para cada Gmail, o campo de `sessionInfo token` e o uploader do ficheiro com SID, SSID, HSID, APISID e SAPISID.")
-            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
-                if direct_accounts:
-                    save_direct_credentials = st.form_submit_button("Guardar cookies e sessionInfo por conta", type="secondary", use_container_width=True)
-
-            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)))
+        st.caption("As credenciais e parâmetros do Upload directo — cookies, sessionInfo, INNERTUBE_API_KEY, chunk_size e DELEGATED_SESSION_ID — são lidos exclusivamente do documento JSON por conta Google. Não são editados nesta UI.")
+        direct_innertube_api_key = str(settings.get("direct_innertube_api_key", "") or "")
+        direct_chunk_size = int(settings.get("direct_chunk_size", 262144) or 262144)
 
         with st.expander("Serviço, materiais e rede"):
             cols = st.columns(2)
@@ -1619,7 +1652,7 @@ def render_settings():
                     model_index = model_options.index(current_model_name) if current_model_name in model_options else 0
                     selected_model = st.selectbox("Modelo OpenAI/ NVIDIA NIM", model_options, index=model_index, format_func=lambda value: "Escrever modelo manualmente" if value == manual_option else value, key="settings_openai_model_select")
                     if selected_model == manual_option:
-                        openai_model_name = st.text_input("Modelo manual", value=current_model_name if current_model_name not in cached_models else "", help_text="Ex.: nvidia_nim/minimaxai/minimax-m3", key="settings_openai_model_manual")
+                        openai_model_name = st.text_input("Modelo manual", value=current_model_name if current_model_name not in cached_models else "", help="Ex.: nvidia_nim/minimaxai/minimax-m3", key="settings_openai_model_manual")
                     else:
                         openai_model_name = selected_model
                 else:
@@ -1715,27 +1748,13 @@ def render_settings():
                 st.rerun()
 
         save_all_settings = st.form_submit_button("Guardar configurações do Thunderbolt", type="primary")
-        if save_all_settings or save_direct_credentials:
-            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)
+        if save_all_settings:
             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,
                 "kaggle_username": kaggle_username.strip(), "kaggle_api_key": kaggle_api_key.strip(), "kaggle_kernel_slug": kaggle_kernel_slug.strip() or "thunderbolt-niche-finder",
                 "apify_api_token": apify_api_token.strip(), "apify_actor_id": apify_actor_id.strip() or DEFAULT_ACTOR_ID, "apify_poll_interval_seconds": int(apify_poll_interval), "apify_run_timeout_seconds": int(apify_run_timeout),
-                "direct_cookie_sid": direct_cookie_sid, "direct_cookie_ssid": direct_cookie_ssid, "direct_cookie_hsid": direct_cookie_hsid, "direct_cookie_apisid": direct_cookie_apisid, "direct_cookie_sapisid": direct_cookie_sapisid, "direct_session_info": direct_session_info, "direct_innertube_api_key": direct_innertube_api_key, "direct_chunk_size": direct_chunk_size,
+                "direct_innertube_api_key": direct_innertube_api_key, "direct_chunk_size": direct_chunk_size,
                 "log_level": log_level, "listen_host": listen_host, "listen_port": listen_port, "video_source": video_source,
                 "endpoint": endpoint, "proxy_http": proxy_http, "proxy_https": proxy_https, "match_materials_to_script": match_materials_to_script,
                 "llm_provider": llm_provider, "openai_api_key": openai_api_key, "openai_base_url": openai_base_url, "openai_model_name": openai_model_name,
@@ -1754,17 +1773,14 @@ def render_settings():
                 "upload_post_auto_upload": upload_post_auto_upload,
             })
             write_json("settings.json", settings)
-            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}")
+            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

@@ -8,6 +8,8 @@ from pathlib import Path
 from typing import Any
 
 COOKIE_KEYS = ("SID", "SSID", "HSID", "APISID", "SAPISID")
+DIRECT_DOCUMENT_NAME = "credentials.json"
+DEFAULT_CHUNK_SIZE = 262144
 
 
 def account_key(account: dict[str, Any]) -> str:
@@ -20,7 +22,12 @@ def account_directory(storage_root: Path, account: dict[str, Any]) -> Path:
     return Path(storage_root) / "youtube_direct_accounts" / account_key(account)
 
 
+def credentials_document_path(storage_root: Path, account: dict[str, Any]) -> Path:
+    return account_directory(storage_root, account) / DIRECT_DOCUMENT_NAME
+
+
 def cookie_file_path(storage_root: Path, account: dict[str, Any]) -> Path:
+    """Legacy path retained only to migrate pre-document installations."""
     return account_directory(storage_root, account) / "cookies.json"
 
 
@@ -71,12 +78,107 @@ def parse_cookie_file(content: bytes, filename: str = "cookies.json") -> dict[st
     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)
+def parse_credentials_document(content: bytes, filename: str = DIRECT_DOCUMENT_NAME) -> dict[str, Any]:
+    try:
+        raw = json.loads(content.decode("utf-8-sig", errors="replace"))
+    except (UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise ValueError(f"O documento de credenciais {filename} deve ser JSON válido.") from exc
+    if not isinstance(raw, dict):
+        raise ValueError(f"O documento de credenciais {filename} deve conter um objecto JSON.")
+    document = _normalise_document(raw, {"id": raw.get("account_id", ""), "email": raw.get("email", "")})
+    missing = [key for key in COOKIE_KEYS if not document["cookies"].get(key)]
+    if missing:
+        raise ValueError(f"Faltam cookies obrigatórios no documento {filename}: {', '.join(missing)}.")
+    if not document["sessionInfo"]:
+        raise ValueError(f"Falta sessionInfo no documento {filename}.")
+    if not document["INNERTUBE_API_KEY"]:
+        raise ValueError(f"Falta INNERTUBE_API_KEY no documento {filename}.")
+    return document
+
+
+def _safe_chunk_size(value: Any) -> int:
+    try:
+        chunk = max(DEFAULT_CHUNK_SIZE, int(value))
+    except (TypeError, ValueError):
+        chunk = DEFAULT_CHUNK_SIZE
+    chunk -= chunk % DEFAULT_CHUNK_SIZE
+    return chunk or DEFAULT_CHUNK_SIZE
+
+
+def _channel_keys(channel: dict[str, Any]) -> list[str]:
+    keys: list[str] = []
+    for field in ("id", "youtube_channel_id"):
+        value = str(channel.get(field) or "").strip()
+        if value and value not in keys:
+            keys.append(value)
+    return keys
+
+
+def _normalise_document(raw: Any, account: dict[str, Any]) -> dict[str, Any]:
+    raw = raw if isinstance(raw, dict) else {}
+    cookies = _normalise_pairs(raw.get("cookies", raw))
+    delegated_raw = raw.get("delegated_session_ids", {})
+    delegated: dict[str, str] = {}
+    if isinstance(delegated_raw, dict):
+        for key, value in delegated_raw.items():
+            if isinstance(value, dict):
+                value = value.get("DELEGATED_SESSION_ID") or value.get("delegated_session_id") or ""
+            value = str(value or "").strip()
+            if value:
+                delegated[str(key)] = value
+    return {
+        "account_id": str(raw.get("account_id") or account.get("id") or "").strip(),
+        "email": str(raw.get("email") or account.get("email") or "").strip(),
+        "sessionInfo": str(raw.get("sessionInfo") or raw.get("session_info") or raw.get("direct_session_info") or "").strip(),
+        "cookies": {key: cookies.get(key, "") for key in COOKIE_KEYS},
+        "INNERTUBE_API_KEY": str(raw.get("INNERTUBE_API_KEY") or raw.get("innertube_api_key") or raw.get("direct_innertube_api_key") or "").strip(),
+        "chunk_size": _safe_chunk_size(raw.get("chunk_size", raw.get("direct_chunk_size", DEFAULT_CHUNK_SIZE))),
+        "delegated_session_ids": delegated,
+    }
+
+
+def _legacy_document(storage_root: Path, account: dict[str, Any], settings: dict[str, Any] | None, channels: list[dict[str, Any]] | None) -> dict[str, Any]:
+    settings = settings or {}
+    legacy_cookies = load_cookie_file(storage_root, account)
+    if not legacy_cookies:
+        legacy_cookies = {
+            key: str(settings.get(f"direct_cookie_{key.lower()}") or "").strip()
+            for key in COOKIE_KEYS
+        }
+    delegated: dict[str, str] = {}
+    for channel in channels or []:
+        if str(channel.get("google_account_id") or "") != str(account.get("id") or ""):
+            continue
+        delegated_value = str(channel.get("delegated_session_id") or "").strip()
+        if delegated_value:
+            for key in _channel_keys(channel)[:1]:
+                delegated[key] = delegated_value
+    return _normalise_document({
+        "account_id": account.get("id"),
+        "email": account.get("email"),
+        "sessionInfo": account.get("direct_session_info") or settings.get("direct_session_info"),
+        "cookies": legacy_cookies,
+        "INNERTUBE_API_KEY": settings.get("direct_innertube_api_key"),
+        "chunk_size": settings.get("direct_chunk_size", DEFAULT_CHUNK_SIZE),
+        "delegated_session_ids": delegated,
+    }, account)
+
+
+def save_credentials_document(storage_root: Path, account: dict[str, Any], document: dict[str, Any]) -> Path:
+    normalised = _normalise_document(document, account)
+    destination = credentials_document_path(storage_root, account)
     destination.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "account_id": normalised["account_id"],
+        "email": normalised["email"],
+        "sessionInfo": normalised["sessionInfo"],
+        "cookies": normalised["cookies"],
+        "INNERTUBE_API_KEY": normalised["INNERTUBE_API_KEY"],
+        "chunk_size": normalised["chunk_size"],
+        "delegated_session_ids": normalised["delegated_session_ids"],
+    }
     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")
+    temporary.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
     try:
         os.chmod(temporary, 0o600)
     except OSError:
@@ -89,25 +191,108 @@ def save_cookie_file(storage_root: Path, account: dict[str, Any], content: bytes
     return destination
 
 
+def _read_json_document(path: Path) -> dict[str, Any] | None:
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    return raw if isinstance(raw, dict) else None
+
+
+def load_credentials_document(storage_root: Path, account: dict[str, Any], settings: dict[str, Any] | None = None, channels: list[dict[str, Any]] | None = None, *, create: bool = True) -> dict[str, Any]:
+    path = credentials_document_path(storage_root, account)
+    raw = _read_json_document(path) if path.exists() else None
+    if raw is None:
+        document = _legacy_document(storage_root, account, settings, channels)
+        if create:
+            save_credentials_document(storage_root, account, document)
+        return document
+    document = _normalise_document(raw, account)
+    changed = False
+    for channel in channels or []:
+        if str(channel.get("google_account_id") or "") != str(account.get("id") or ""):
+            continue
+        keys = _channel_keys(channel)
+        if keys and keys[0] not in document["delegated_session_ids"]:
+            document["delegated_session_ids"][keys[0]] = ""
+            changed = True
+    if changed and create:
+        save_credentials_document(storage_root, account, document)
+    return document
+
+
+def ensure_credentials_document(storage_root: Path, account: dict[str, Any], settings: dict[str, Any] | None = None, channels: list[dict[str, Any]] | None = None) -> Path:
+    load_credentials_document(storage_root, account, settings, channels, create=True)
+    return credentials_document_path(storage_root, account)
+
+
+def delegated_session_id(document: dict[str, Any], channel: dict[str, Any]) -> str:
+    mapping = document.get("delegated_session_ids", {}) if isinstance(document, dict) else {}
+    if not isinstance(mapping, dict):
+        return ""
+    for key in _channel_keys(channel):
+        value = mapping.get(key, "")
+        if isinstance(value, dict):
+            value = value.get("DELEGATED_SESSION_ID") or value.get("delegated_session_id") or ""
+        if str(value or "").strip():
+            return str(value).strip()
+    return ""
+
+
+def document_status(storage_root: Path, account: dict[str, Any], channel: dict[str, Any] | None = None, settings: dict[str, Any] | None = None, channels: list[dict[str, Any]] | None = None) -> dict[str, Any]:
+    path = credentials_document_path(storage_root, account)
+    document = load_credentials_document(storage_root, account, settings, channels, create=True)
+    missing_cookies = [key for key in COOKIE_KEYS if not document["cookies"].get(key)]
+    delegated = delegated_session_id(document, channel or {}) if channel else ""
+    return {
+        "document_file": str(path),
+        "document_exists": path.exists(),
+        "missing_cookies": missing_cookies,
+        "has_session_info": bool(document.get("sessionInfo")),
+        "has_innertube_api_key": bool(document.get("INNERTUBE_API_KEY")),
+        "has_delegated_session_id": bool(delegated) if channel is not None else None,
+        "ready": not missing_cookies and bool(document.get("sessionInfo")) and bool(document.get("INNERTUBE_API_KEY")) and (channel is None or bool(delegated)),
+    }
+
+
 def load_cookie_file(storage_root: Path, account: dict[str, Any]) -> dict[str, str]:
+    """Load cookies from the legacy cookies.json file for migration only."""
     path = cookie_file_path(storage_root, account)
     if not path.exists():
         return {}
+    raw = _read_json_document(path)
+    return _normalise_pairs(raw or {})
+
+
+def save_cookie_file(storage_root: Path, account: dict[str, Any], content: bytes, filename: str = "cookies.json") -> Path:
+    """Legacy helper retained for migration tests; new writes must use credentials.json."""
+    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:
-        raw = json.loads(path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return {}
-    return _normalise_pairs(raw)
+        os.chmod(temporary, 0o600)
+    except OSError:
+        pass
+    temporary.replace(destination)
+    try:
+        os.chmod(destination, 0o600)
+    except OSError:
+        pass
+    return destination
 
 
 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()
+    """Backward-compatible account status; the source of truth is credentials.json."""
+    status = document_status(storage_root, account)
     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),
+        "cookie_file": status["document_file"],
+        "document_exists": status["document_exists"],
+        "cookie_file_exists": status["document_exists"],
+        "missing_cookies": status["missing_cookies"],
+        "has_session_info": status["has_session_info"],
+        "has_innertube_api_key": status["has_innertube_api_key"],
+        "ready": status["ready"],
+        "document_file": status["document_file"],
     }

package/integrations/youtube_direct_upload.py

@@ -9,7 +9,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
-from integrations.youtube_direct_credentials import COOKIE_KEYS, load_cookie_file
+from integrations.youtube_direct_credentials import COOKIE_KEYS, delegated_session_id, load_credentials_document
 from urllib.parse import quote
 
 import requests
@@ -26,18 +26,37 @@ class DirectUploadResult:
     data: dict[str, Any]
 
 
-def _cookie_settings(settings: dict[str, Any], account: dict[str, Any] | None = None, storage_root: Path | None = None) -> dict[str, str]:
+def _direct_document(settings: dict[str, Any], channel: dict[str, Any], account: dict[str, Any] | None, storage_root: Path | None) -> dict[str, Any]:
     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}
+        return load_credentials_document(storage_root, account, settings, [channel], create=True)
+    return {
+        "cookies": {key: str(settings.get(f"direct_cookie_{key.lower()}", "") or "").strip() for key in COOKIE_KEYS},
+        "sessionInfo": str(settings.get("direct_session_info", "") or "").strip(),
+        "INNERTUBE_API_KEY": str(settings.get("direct_innertube_api_key", "") or "").strip(),
+        "chunk_size": int(settings.get("direct_chunk_size", CHUNK_GRANULARITY) or CHUNK_GRANULARITY),
+        "delegated_session_ids": {str(channel.get("id") or ""): str(channel.get("delegated_session_id") or "").strip()},
+    }
 
 
-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_settings(settings: dict[str, Any], channel: dict[str, Any], account: dict[str, Any] | None = None, storage_root: Path | None = None) -> dict[str, str]:
+    document = _direct_document(settings, channel, account, storage_root)
+    cookies = document.get("cookies", {})
+    return {key: str(cookies.get(key, "") or "").strip() for key in COOKIE_KEYS}
+
+
+def _session_info(settings: dict[str, Any], channel: dict[str, Any], account: dict[str, Any] | None = None, storage_root: Path | None = None) -> str:
+    return str(_direct_document(settings, channel, account, storage_root).get("sessionInfo", "") or "").strip()
+
+
+def _innertube_api_key(settings: dict[str, Any], channel: dict[str, Any], account: dict[str, Any] | None = None, storage_root: Path | None = None) -> str:
+    return str(_direct_document(settings, channel, account, storage_root).get("INNERTUBE_API_KEY", "") or "").strip()
+
+
+def _delegated_session(settings: dict[str, Any], channel: dict[str, Any], account: dict[str, Any] | None = None, storage_root: Path | None = None) -> str:
+    document = _direct_document(settings, channel, account, storage_root)
+    if account is not None and storage_root is not None:
+        return delegated_session_id(document, channel) or str(channel.get("delegated_session_id") or "").strip()
+    return str(channel.get("delegated_session_id") or "").strip()
 
 
 def _cookie_header(cookies: dict[str, str]) -> str:
@@ -70,15 +89,16 @@ 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, account, storage_root).items() if not value]
+    cookies = _cookie_settings(settings, channel, account, storage_root)
+    missing_cookies = [key for key, value in cookies.items() if not value]
     if missing_cookies:
-        return f"Faltam cookies de sessão para upload directo: {', '.join(missing_cookies)}."
-    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."
-    if not str(channel.get("delegated_session_id", "") or "").strip():
-        return "Este canal não tem DELEGATED_SESSION_ID configurado."
+        return f"Faltam cookies no documento de credenciais da conta: {', '.join(missing_cookies)}."
+    if not _session_info(settings, channel, account, storage_root):
+        return "Falta sessionInfo no documento de credenciais da conta."
+    if not _innertube_api_key(settings, channel, account, storage_root):
+        return "Falta INNERTUBE_API_KEY no documento de credenciais da conta."
+    if not _delegated_session(settings, channel, account, storage_root):
+        return "Falta DELEGATED_SESSION_ID deste canal no documento de credenciais da conta."
     return None
 
 
@@ -89,8 +109,11 @@ class YouTubeDirectUploader:
         self.account = account
         self.storage_root = storage_root
         self.session = session or requests.Session()
-        self.cookies = _cookie_settings(settings, account, storage_root)
-        self.session_info = _session_info(settings, account)
+        self.document = _direct_document(settings, channel, account, storage_root)
+        self.cookies = _cookie_settings(settings, channel, account, storage_root)
+        self.session_info = _session_info(settings, channel, account, storage_root)
+        self.delegated_session_id = _delegated_session(settings, channel, account, storage_root)
+        self.innertube_api_key = _innertube_api_key(settings, channel, account, storage_root)
         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()
@@ -139,12 +162,11 @@ class YouTubeDirectUploader:
             "context": {
                 "client": {"clientName": 62, "clientVersion": "1.20210806.02.00", "hl": "pt-BR", "gl": "BR", "experimentsToken": "", "utcOffsetMinutes": 0},
                 "request": {"sessionInfo": {"token": self.session_info}},
-                "user": {"onBehalfOfUser": str(self.channel.get("delegated_session_id", ""))},
+                "user": {"onBehalfOfUser": self.delegated_session_id},
             },
         }
-        api_key = str(self.settings.get("direct_innertube_api_key", "")).strip()
-        endpoint = f"https://studio.youtube.com/youtubei/v1/upload/createvideo?alt=json&key={quote(api_key)}"
-        headers = {**self._base_headers(), "Content-Type": "application/json", "X-Youtube-Client-Name": "62", "X-Youtube-Client-Version": "1.20210806.02.00", "X-Goog-PageId": str(self.channel.get("delegated_session_id", "")), "Authorization": f"SAPISIDHASH {_sapishash(self.cookies['SAPISID'])}"}
+        endpoint = f"https://studio.youtube.com/youtubei/v1/upload/createvideo?alt=json&key={quote(self.innertube_api_key)}"
+        headers = {**self._base_headers(), "Content-Type": "application/json", "X-Youtube-Client-Name": "62", "X-Youtube-Client-Version": "1.20210806.02.00", "X-Goog-PageId": self.delegated_session_id, "Authorization": f"SAPISIDHASH {_sapishash(self.cookies['SAPISID'])}"}
         response = self.session.post(endpoint, headers=headers, data=json.dumps(payload), timeout=60)
         response.raise_for_status()
         body = response.json() if response.content else {}
@@ -169,7 +191,7 @@ class YouTubeDirectUploader:
                 response.raise_for_status()
                 offset += len(chunk)
 
-    def upload(self, video_path: str | Path, *, title: str, description: str = "", visibility: str = "private", chunk_size: int = CHUNK_GRANULARITY) -> DirectUploadResult:
+    def upload(self, video_path: str | Path, *, title: str, description: str = "", visibility: str = "private", chunk_size: int | None = None) -> DirectUploadResult:
         path = Path(video_path)
         validation_error = validate_direct_upload(path, self.channel, self.settings, self.account, self.storage_root)
         if validation_error:
@@ -177,7 +199,8 @@ class YouTubeDirectUploader:
         try:
             self.describe_file(path)
             self.create_video(title, description, visibility)
-            self.upload_chunks(path, chunk_size)
+            configured_chunk_size = int(chunk_size or self.document.get("chunk_size") or CHUNK_GRANULARITY)
+            self.upload_chunks(path, configured_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", ""), "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.44",
+  "version": "0.2.46",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "main": "scripts/cli.mjs",
   "type": "module",