@danhachuel/thunderbolt 0.2.16 → 0.2.18

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.16
+> **Versão deste manual:** 0.2.18
 > **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.16 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.18 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes @danhachuel/thunderbolt@0.2.16 install
+npx --yes @danhachuel/thunderbolt@0.2.18 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.
@@ -345,7 +345,11 @@ Na primeira execução, abra **Configurações** e reveja:
 |---|---|
 | Porta Streamlit | Definir a porta local da UI |
 | Pasta MoneyPrinterTurbo | Indicar o clone local que será sincronizado com `config.toml` |
-| YouTube Data API key | Permitir importar nome, handle e métricas de canais |
+| YouTube Data API Key | Permitir importar nome, handle e métricas públicas de canais |
+| YouTube OAuth Client ID | Identificar a aplicação OAuth 2.0 do Google para operações autenticadas |
+| YouTube OAuth Client Secret | Secret do mesmo cliente OAuth 2.0; não é a Data API Key |
+| YouTube upload principal | Lógica do `youtube-automation-agent` adaptada e executada dentro do Thunderbolt |
+| OAuth directo de redundância | Caminho alternativo accionado automaticamente se o agente falhar |
 | TikTok Client ID/Secret | Credenciais da aplicação; Redirect URI, scopes e autorização ficam no TikTok for Developers Playground |
 
 As chaves devem ser inseridas apenas na configuração local. Não as coloque no GitHub, no `package.json`, em blueprints ou em ficheiros de estado versionados.
@@ -357,10 +361,10 @@ Após iniciar a aplicação, valide o seguinte percurso:
 1. **Dashboard:** confirme que a UI abre e mostra o estado local.
 2. **Blueprints:** coloque um JSON em `~/.thunderbolt/storage/blueprints/importados/` (Windows: `%LOCALAPPDATA%\\THUNDERBOLT\storage\blueprints\importados\`) ou use o carregador da interface.
 3. **Brandings:** abra a subaba **Brandings** e confirme a listagem dos ficheiros JSON.
-4. **Canais:** cadastre um canal manualmente ou importe-o depois de configurar a YouTube Data API.
+4. **Canais:** em **Importar do YouTube**, use o método **Página pública — sem API Key** ou a Data API opcional; em **Cadastro manual**, preencha os dados sem qualquer consulta externa.
 5. **Novo vídeo:** teste primeiro o modo **Canal específico** e depois os modos de lote.
-6. **Vídeos:** verifique o estado `to_do` e os botões **Iniciar** e **Parar**.
-7. **Upload:** confirme os destinos configurados e os estados de pré-requisito.
+6. **Novo vídeo > Vídeos:** verifique o estado `to_do` e os botões **Iniciar** e **Parar** dentro da subaba.
+7. **Upload:** autorize primeiro o **youtube-automation-agent** na própria aba, confirme o estado **pronto para publicar**, preencha título/descrição/tags e publique um MP4 real. O botão **Autorizar fallback OAuth** existe apenas para redundância; a Data API Key é exclusivamente para consultas públicas.
 8. **Limpador de metadado:** suba um vídeo de terceiro, preencha título, preview, links, timestamps e tags, aplique a limpeza e descarregue a cópia limpa e o manifesto JSON. O original fica preservado e vídeos da aba Novo vídeo não são aceites nesta área.
 9. **Configurações:** confirme que os caminhos e credenciais estão locais e não aparecem no Git.
 
@@ -504,6 +508,8 @@ Nunca publique ou envie por chat:
 
 Use secrets do GitHub Actions apenas para publicação do pacote. Para execução local, mantenha credenciais fora do repositório e use a área de configurações local ou variáveis de ambiente.
 
+A publicação YouTube segue primeiro a lógica adaptada do `PublishingSchedulingAgent` do [youtube-automation-agent](https://github.com/darkzOGx/youtube-automation-agent), sob licença MIT. O código corre dentro do processo Streamlit; não é necessário iniciar o agente Node separadamente. O fallback OAuth directo só é chamado quando a tentativa primária falha.
+
 ## 14. Referências
 
 [1]: https://github.com/harry0703/MoneyPrinterTurbo/blob/main/README-en.md — MoneyPrinterTurbo: requisitos, instalação, dependências, Streamlit e FFmpeg.

package/README.md

@@ -14,10 +14,9 @@ A primeira versão implementa a camada UI independente com:
 | Pipeline | Filas por etapa |
 | Blueprints | Leitura da pasta `storage/blueprints/`, upload/validação de JSON e criação a partir de link YouTube |
 | Brandings | Subaba própria dentro de Blueprints, upload/listagem de Brandings e criação conjunta com Blueprint |
-| Canais | Cadastro manual, importação via YouTube Data API quando configurada e edição de dados importados |
-| Novo vídeo | Canal específico, lote no mesmo canal e lote geral |
-| Vídeos | Filtro por estado e controlos iniciar/parar |
-| Upload | Destinos YouTube/TikTok e diagnóstico do TikTok |
+| Canais | Subabas de importação pública sem API Key, Data API opcional e cadastro manual independente |
+| Novo vídeo | Subabas Criar vídeo e Vídeos; canal específico, lote no mesmo canal, lote geral, filtro de estados e controlos iniciar/parar |
+| Upload | YouTube via `youtube-automation-agent` adaptado internamente, OAuth directo de redundância, TikTok e diagnóstico |
 | Limpador de metadado | Upload isolado de vídeos terceiros, limpeza FFmpeg, edição de título/descrição/tags e manifesto JSON |
 | Configurações | Provedores LLM, TTS/voz, materiais, Whisper, FFmpeg, YouTube, TikTok Client ID/Secret e Upload-Post |
 | Launcher | Execução via `npx`, instalação assistida, diagnóstico e preparação para distribuição |
@@ -103,9 +102,9 @@ thunderbolt
 No Windows PowerShell, se `npx` for bloqueado por `npx.ps1`, use directamente `npx.cmd`:
 
 ```powershell
-npx.cmd --yes @danhachuel/thunderbolt@0.2.16 install
-npx.cmd --yes @danhachuel/thunderbolt@0.2.16 doctor
-npx.cmd --yes @danhachuel/thunderbolt@0.2.16
+npx.cmd --yes @danhachuel/thunderbolt@0.2.18 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.18 doctor
+npx.cmd --yes @danhachuel/thunderbolt@0.2.18
 ```
 
 Como alternativa, pode permitir scripts para o seu utilizador:
@@ -162,12 +161,25 @@ A descrição segue a composição do workflow de referência: preview, secção
 
 ## Canais YouTube
 
-Sem chave, o cadastro manual continua disponível. Para importar nome, handle e estatísticas através da API oficial do YouTube Data API, configure `youtube_api_key` na aba **Configurações** ou em `YOUTUBE_API_KEY`.
+A aba **Canais** está dividida em dois fluxos independentes. Em **Importar do YouTube**, o método padrão **Página pública — sem API Key** consulta a página pública do canal e preenche nome, ID, handle, URL, descrição e thumbnail quando esses dados estão disponíveis. A opção **YouTube Data API — API Key opcional** pode ser escolhida para métricas oficiais quando `youtube_api_key` estiver configurada em **Configurações** ou em `YOUTUBE_API_KEY`.
+
+Em **Cadastro manual**, nenhum pedido ao YouTube é feito e não existe qualquer dependência de API Key. O utilizador pode preencher nome, URL, handle, descrição, métricas, thumbnail, idioma, estilo e Blueprint associado. A importação pública nunca grava automaticamente: os dados aparecem num formulário de revisão antes de guardar.
+
+## Upload YouTube
+
+O Upload usa como caminho **principal** a lógica do `PublishingSchedulingAgent` do [youtube-automation-agent](https://github.com/darkzOGx/youtube-automation-agent), adaptada para Python e executada dentro do processo Streamlit do Thunderbolt. Não é necessário instalar ou iniciar um segundo servidor Node. O fluxo valida o MP4 real, constrói `snippet/status`, faz upload resumível e tenta enviar thumbnail e legendas.
+
+Na aba **Upload**, configure primeiro o **YouTube OAuth Client ID** e o **YouTube OAuth Client Secret** em **Configurações**. Em seguida, use **Autorizar agente YouTube**. O navegador local abrirá a autorização Google e o token será guardado apenas em `storage/state/youtube_agent_tokens.json`. Se a publicação principal falhar, o Thunderbolt tenta automaticamente o **OAuth directo de redundância**, usando o token local compatível; a Data API Key nunca é usada para publicar.
+
+Use **Autorizar fallback OAuth** apenas se precisar de uma autorização separada para o caminho de redundância. Os resultados guardam no histórico local qual mecanismo foi utilizado e as tentativas realizadas, sem guardar segredos.
 
 ## TikTok
 
-A aba **Configurações** contém apenas o TikTok Client ID e o TikTok Client Secret. Redirect URI, scopes, autorização OAuth e tokens são geridos no TikTok for Developers Playground. O adaptador rejeita o upload quando faltam credenciais ou OAuth, em vez de indicar sucesso falso.
+A subaba **Vídeos**, dentro de **Novo vídeo**, mostra o backlog e permite iniciar/parar tarefas; deixou de existir como botão principal na barra lateral.
+
+A aba **Configurações** contém apenas o TikTok Client ID e o TikTok Client Secret.
+ Redirect URI, scopes, autorização OAuth e tokens são geridos no TikTok for Developers Playground. O adaptador rejeita o upload quando faltam credenciais ou OAuth, em vez de indicar sucesso falso.
 
 ## Segurança
 
-Não coloque chaves, cookies, tokens YouTube ou segredos TikTok no Git. Use a configuração local, variáveis de ambiente ou um ficheiro fora do repositório. O `.gitignore` exclui o storage de estado real, ambientes virtuais e ficheiros de segredo.
+Não coloque chaves, cookies, tokens YouTube ou segredos TikTok no Git. Use a configuração local, variáveis de ambiente ou um ficheiro fora do repositório. O `.gitignore` exclui o storage de estado real, ambientes virtuais e ficheiros de segredo. O adaptador interno foi baseado na lógica publicada sob licença MIT do [youtube-automation-agent](https://github.com/darkzOGx/youtube-automation-agent).

package/app/main.py

@@ -18,7 +18,7 @@ from hermes_ui.domain import STAGES, create_batch, create_channel, create_tasks_
 from hermes_ui.storage import BLUEPRINTS, ensure_storage, list_blueprint_files, load_blueprint_file, now, read_json, write_json
 from hermes_ui.blueprints import create_blueprint_from_link, list_branding_files, save_generated_blueprint
 from hermes_ui.metadata_cleaner import build_description, clean_video_metadata, list_edit_records, metadata_manifest, normalize_tags, save_edit_record, store_external_video
-from integrations.platforms import TikTokAdapter, YouTubeAdapter
+from integrations.platforms import IntegrationResult, TikTokAdapter, YouTubeAdapter
 from integrations.local_runtime import MoneyPrinterRuntime
 from integrations.moneyprinter_config import sync_moneyprinter_config
 
@@ -194,38 +194,107 @@ def render_blueprints():
 
 def render_channels():
     st.title("Canais")
-    st.caption("Importação do YouTube com edição manual e armazenamento local")
-    with st.expander("Criar ou importar novo canal", expanded=True):
-        source = st.text_input("Nome, URL, handle ou ID do canal", placeholder="https://youtube.com/@seucanal")
+    st.caption("Escolha entre importar dados públicos do YouTube ou preencher o canal manualmente.")
+    settings = read_json("settings.json", {})
+    youtube = YouTubeAdapter(settings=settings)
+    import_tab, manual_tab = st.tabs(["Importar do YouTube", "Cadastro manual"])
+
+    with import_tab:
+        st.caption("A pesquisa pública funciona sem API Key. A Data API é opcional e fica disponível numa opção separada para métricas oficiais.")
+        source = st.text_input("URL, handle ou ID do canal", placeholder="https://youtube.com/@seucanal", key="youtube_channel_source")
+        lookup_mode = st.radio("Método de consulta", ["Página pública — sem API Key", "YouTube Data API — API Key opcional"], horizontal=True, key="youtube_channel_lookup_mode")
         col1, col2 = st.columns([1, 1])
         with col1:
-            if st.button("Buscar no YouTube", type="primary", use_container_width=True):
-                result = YouTubeAdapter(read_json("settings.json", {}).get("youtube_api_key", "")).fetch_channel(source)
+            if st.button("Buscar no YouTube", type="primary", use_container_width=True, key="youtube_channel_lookup"):
+                if lookup_mode.startswith("Página pública"):
+                    result = youtube.fetch_channel_public(source)
+                elif not youtube.api_key:
+                    result = IntegrationResult(False, "A YouTube Data API Key não está configurada. Escolha a opção Página pública — sem API Key ou configure a chave em Configurações.", {"status": "api_key_not_configured"})
+                else:
+                    result = youtube.fetch_channel(source)
                 st.session_state["yt_import"] = result.data
                 st.session_state["yt_message"] = result.message
                 st.session_state["yt_ok"] = result.ok
         with col2:
-            if st.button("Limpar importação", use_container_width=True):
-                st.session_state.pop("yt_import", None)
+            if st.button("Limpar importação", use_container_width=True, key="youtube_channel_clear"):
+                for key in ("yt_import", "yt_message", "yt_ok"):
+                    st.session_state.pop(key, None)
+                st.rerun()
         if st.session_state.get("yt_message"):
             (st.success if st.session_state.get("yt_ok") else st.warning)(st.session_state["yt_message"])
         imported = st.session_state.get("yt_import", {})
-        with st.form("channel_form"):
-            name = st.text_input("Nome do canal", value=imported.get("name", ""))
-            url = st.text_input("URL", value=source if source.startswith("http") else imported.get("url", ""))
-            handle = st.text_input("Handle", value=imported.get("handle", ""))
-            language = st.selectbox("Idioma", ["Português", "English", "Español", "Français", "Deutsch"], index=0)
-            style = st.selectbox("Estilo wide", ["pexels", "full_ia"], index=0)
-            blueprint = st.text_input("Blueprint associado", value="")
-            submitted = st.form_submit_button("Guardar canal", type="primary")
+        if imported:
+            st.caption("Dados encontrados. Reveja ou edite os campos antes de guardar.")
+            with st.form("channel_import_form"):
+                name = st.text_input("Nome do canal", value=imported.get("name", ""), key="yt_import_name")
+                url = st.text_input("URL", value=imported.get("url", source if source.startswith("http") else ""), key="yt_import_url")
+                handle = st.text_input("Handle", value=imported.get("handle", ""), key="yt_import_handle")
+                language = st.selectbox("Idioma", ["Português", "English", "Español", "Français", "Deutsch"], index=0, key="yt_import_language")
+                style = st.selectbox("Estilo wide", ["pexels", "full_ia"], index=0, key="yt_import_style")
+                blueprint = st.text_input("Blueprint associado", value="", key="yt_import_blueprint")
+                description = st.text_area("Descrição", value=imported.get("description", ""), key="yt_import_description")
+                metrics = st.columns(3)
+                with metrics[0]: subscriber_count = st.number_input("Inscritos", min_value=0, value=int(imported.get("subscriber_count") or 0), key="yt_import_subscribers")
+                with metrics[1]: video_count = st.number_input("Vídeos", min_value=0, value=int(imported.get("video_count") or 0), key="yt_import_videos")
+                with metrics[2]: view_count = st.number_input("Visualizações", min_value=0, value=int(imported.get("view_count") or 0), key="yt_import_views")
+                submitted = st.form_submit_button("Guardar canal importado", type="primary")
+                if submitted:
+                    if not name.strip():
+                        st.error("Informe o nome do canal antes de guardar.")
+                    else:
+                        metadata = {
+                            **imported,
+                            "handle": handle.strip(),
+                            "description": description.strip(),
+                            "language": language,
+                            "style_wide": style,
+                            "blueprint_id": blueprint.strip(),
+                            "subscriber_count": int(subscriber_count) or None,
+                            "video_count": int(video_count) or None,
+                            "view_count": int(view_count) or None,
+                            "metrics_source": imported.get("metrics_source", "youtube_public_page"),
+                        }
+                        channel = create_channel(name, url, metadata)
+                        st.success(f"Canal {channel['name']} guardado.")
+                        st.rerun()
+        else:
+            st.info("Introduza um URL, handle ou ID e clique em Buscar no YouTube. Não é necessária API Key na opção pública.")
+
+    with manual_tab:
+        st.caption("Este fluxo não consulta o YouTube e não exige API Key. Preencha os dados que quiser e guarde o canal localmente.")
+        with st.form("channel_manual_form"):
+            name = st.text_input("Nome do canal", key="manual_channel_name")
+            url = st.text_input("URL do canal", placeholder="https://youtube.com/@seucanal", key="manual_channel_url")
+            handle = st.text_input("Handle", placeholder="@seucanal", key="manual_channel_handle")
+            description = st.text_area("Descrição", key="manual_channel_description")
+            language = st.selectbox("Idioma", ["Português", "English", "Español", "Français", "Deutsch"], index=0, key="manual_channel_language")
+            style = st.selectbox("Estilo wide", ["pexels", "full_ia"], index=0, key="manual_channel_style")
+            blueprint = st.text_input("Blueprint associado", key="manual_channel_blueprint")
+            thumbnail_url = st.text_input("URL da imagem do canal", key="manual_channel_thumbnail")
+            metrics = st.columns(3)
+            with metrics[0]: subscriber_count = st.number_input("Inscritos", min_value=0, value=0, key="manual_channel_subscribers")
+            with metrics[1]: video_count = st.number_input("Vídeos", min_value=0, value=0, key="manual_channel_videos")
+            with metrics[2]: view_count = st.number_input("Visualizações", min_value=0, value=0, key="manual_channel_views")
+            submitted = st.form_submit_button("Guardar canal manual", type="primary")
             if submitted:
                 if not name.strip():
                     st.error("Informe o nome do canal.")
                 else:
-                    metadata = {"handle": handle, "language": language, "style_wide": style, "blueprint_id": blueprint, **imported}
-                    channel = create_channel(name, url, metadata)
-                    st.success(f"Canal {channel['name']} guardado.")
+                    channel = create_channel(name, url, {
+                        "handle": handle.strip(),
+                        "description": description.strip(),
+                        "language": language,
+                        "style_wide": style,
+                        "blueprint_id": blueprint.strip(),
+                        "thumbnail_url": thumbnail_url.strip(),
+                        "subscriber_count": int(subscriber_count) or None,
+                        "video_count": int(video_count) or None,
+                        "view_count": int(view_count) or None,
+                        "metrics_source": "manual",
+                    })
+                    st.success(f"Canal {channel['name']} guardado manualmente.")
                     st.rerun()
+
     st.subheader("Canais cadastrados")
     channels = read_json("channels.json", [])
     if not channels:
@@ -241,7 +310,7 @@ def render_channels():
                     st.markdown("### YT")
             with cols[1]:
                 st.write(f"**{channel.get('name', 'Sem nome')}**")
-                st.caption(f"{channel.get('handle') or channel.get('url') or 'sem URL'}")
+                st.caption(f"{channel.get('handle') or channel.get('url') or 'sem URL'} · {channel.get('metrics_source', 'manual')}")
             with cols[2]: st.metric("Inscritos", channel.get("subscriber_count") if channel.get("subscriber_count") is not None else "—")
             with cols[3]: st.metric("Vídeos", channel.get("video_count") if channel.get("video_count") is not None else "—")
             with cols[4]: st.metric("Backlog", channel.get("backlog_total", 0))
@@ -253,41 +322,46 @@ def render_channels():
 
 def render_new_video():
     st.title("Novo vídeo")
-    channels = channel_options()
-    if not channels:
-        st.warning("Cadastre pelo menos um canal antes de criar vídeos.")
-        return
-    mode_label = st.radio("Modo de criação", ["Canal específico", "Lote no mesmo canal", "Lote geral"], horizontal=True)
-    mode = {"Canal específico": "single", "Lote no mesmo canal": "same_channel", "Lote geral": "general"}[mode_label]
-    if mode == "general":
-        selected = st.multiselect("Canais incluídos", [c["id"] for c in channels], default=[c["id"] for c in channels], format_func=lambda cid: next(c["name"] for c in channels if c["id"] == cid))
-    else:
-        selected_one = st.selectbox("Canal", channels, format_func=lambda c: c["name"])
-        selected = [selected_one["id"]]
-    with st.form("new_video_form"):
-        topic = st.text_area("Tópico ou briefing", placeholder="Ex.: A história pouco conhecida por trás de...")
-        quantity = st.number_input("Quantidade", min_value=1, max_value=100, value=1, disabled=mode != "same_channel")
-        language = st.selectbox("Idioma", ["Português", "English", "Español"], key="video_language")
-        fmt = st.selectbox("Formato", ["wide", "shorts", "music"])
-        style = st.selectbox("Estilo wide", ["pexels", "full_ia"])
-        submitted = st.form_submit_button("Criar tarefas", type="primary")
-    if submitted:
-        if not topic.strip() or not selected:
-            st.error("Informe um tópico e seleccione pelo menos um canal.")
+    create_tab, videos_tab = st.tabs(["Criar vídeo", "Vídeos"])
+    with create_tab:
+        channels = channel_options()
+        if not channels:
+            st.warning("Cadastre pelo menos um canal antes de criar vídeos.")
         else:
-            quantity = int(quantity if mode == "same_channel" else 1)
-            batch = create_batch(mode, selected, topic, quantity, {"language": language, "format": fmt, "style_wide": style})
-            tasks = create_tasks_for_batch(batch)
-            st.success(f"Lote {batch['id']} criado com {len(tasks)} tarefa(s).")
+            mode_label = st.radio("Modo de criação", ["Canal específico", "Lote no mesmo canal", "Lote geral"], horizontal=True, key="new_video_mode")
+            mode = {"Canal específico": "single", "Lote no mesmo canal": "same_channel", "Lote geral": "general"}[mode_label]
+            if mode == "general":
+                selected = st.multiselect("Canais incluídos", [c["id"] for c in channels], default=[c["id"] for c in channels], format_func=lambda cid: next(c["name"] for c in channels if c["id"] == cid), key="new_video_channels_general")
+            else:
+                selected_one = st.selectbox("Canal", channels, format_func=lambda c: c["name"], key="new_video_channel")
+                selected = [selected_one["id"]]
+            with st.form("new_video_form"):
+                topic = st.text_area("Tópico ou briefing", placeholder="Ex.: A história pouco conhecida por trás de...")
+                quantity = st.number_input("Quantidade", min_value=1, max_value=100, value=1, disabled=mode != "same_channel")
+                language = st.selectbox("Idioma", ["Português", "English", "Español"], key="video_language")
+                fmt = st.selectbox("Formato", ["wide", "shorts", "music"])
+                style = st.selectbox("Estilo wide", ["pexels", "full_ia"])
+                submitted = st.form_submit_button("Criar tarefas", type="primary")
+            if submitted:
+                if not topic.strip() or not selected:
+                    st.error("Informe um tópico e seleccione pelo menos um canal.")
+                else:
+                    quantity = int(quantity if mode == "same_channel" else 1)
+                    batch = create_batch(mode, selected, topic, quantity, {"language": language, "format": fmt, "style_wide": style})
+                    tasks = create_tasks_for_batch(batch)
+                    st.success(f"Lote {batch['id']} criado com {len(tasks)} tarefa(s). Abra a subaba Vídeos para acompanhar.")
+    with videos_tab:
+        render_videos()
 
 
 def render_videos():
-    st.title("Vídeos e backlog")
+    st.subheader("Vídeos e backlog")
+    st.caption("Acompanhamento dos vídeos criados, estados da pipeline e controlos de execução.")
     tasks = read_json("tasks.json", [])
     if not tasks:
         st.info("Nenhum vídeo criado.")
         return
-    state_filter = st.selectbox("Filtrar por estado", ["Todos", "to_do", "doing", "blocked", "done", "failed", "cancelled"])
+    state_filter = st.selectbox("Filtrar por estado", ["Todos", "to_do", "doing", "blocked", "done", "failed", "cancelled"], key="videos_state_filter")
     for task in tasks:
         if state_filter != "Todos" and task.get("state") != state_filter:
             continue
@@ -311,10 +385,32 @@ def render_videos():
 
 def render_upload():
     st.title("Upload")
+    settings = read_json("settings.json", {})
+    youtube = YouTubeAdapter(settings=settings)
     tasks = [t for t in read_json("tasks.json", []) if t.get("state") == "done" or t.get("artifacts", {}).get("video")]
     destination = st.multiselect("Destinos", ["YouTube", "TikTok"], default=["YouTube"])
+
+    if "YouTube" in destination:
+        st.markdown("**YouTube — youtube-automation-agent (principal)**")
+        st.caption("O Thunderbolt executa internamente a lógica do PublishingSchedulingAgent: OAuth, upload resumível, metadados, thumbnail e legendas. O OAuth directo é usado apenas como redundância se o caminho principal falhar.")
+        status = youtube.upload_status()
+        status_cols = st.columns(2)
+        with status_cols[0]:
+            (st.success if status["agent"].ok else st.warning)(f"Agente: {status['agent'].message}")
+            if st.button("Autorizar agente YouTube", key="youtube_authorize_agent", use_container_width=True):
+                result = youtube.authorize_agent()
+                (st.success if result.ok else st.error)(result.message)
+                if result.ok:
+                    st.rerun()
+        with status_cols[1]:
+            (st.info if status["fallback"].ok else st.caption)(f"Fallback OAuth: {status['fallback'].message}")
+            if st.button("Autorizar fallback OAuth", key="youtube_authorize_fallback", use_container_width=True):
+                result = youtube.authorize_fallback()
+                (st.success if result.ok else st.error)(result.message)
+                if result.ok:
+                    st.rerun()
     if "TikTok" in destination:
-        status = TikTokAdapter(read_json("settings.json", {})).status()
+        status = TikTokAdapter(settings).status()
         (st.success if status.ok else st.warning)(status.message)
     if not tasks:
         st.info("Não há vídeos prontos para upload.")
@@ -322,14 +418,53 @@ def render_upload():
     for task in tasks:
         with st.container(border=True):
             st.write(f"**{task.get('topic')}** — {task.get('channel_name')}")
-            video_path = task.get("artifacts", {}).get("video", "")
+            artifacts = task.get("artifacts", {}) or {}
+            video_path = artifacts.get("video", "")
+            thumbnail_path = artifacts.get("thumbnail") or artifacts.get("cover", "")
+            captions_path = artifacts.get("captions") or artifacts.get("subtitle", "")
             st.caption(video_path or "Sem caminho de vídeo registado")
-            if st.button("Preparar upload", key=f"upload_{task['id']}"):
-                if "TikTok" in destination:
-                    result = TikTokAdapter(read_json("settings.json", {})).upload_video(video_path, task.get("topic", ""))
-                    (st.success if result.ok else st.warning)(result.message)
-                else:
-                    st.info("Upload YouTube preparado; configure o uploader local para executar a publicação.")
+            if "YouTube" in destination:
+                title = st.text_input("Título", value=task.get("topic", "Vídeo Thunderbolt"), key=f"yt_title_{task['id']}")
+                description = st.text_area("Descrição", value=task.get("description", ""), key=f"yt_description_{task['id']}", height=100)
+                tags_raw = st.text_input("Tags separadas por vírgula", value=task.get("tags", "") if isinstance(task.get("tags", ""), str) else ", ".join(task.get("tags", [])), key=f"yt_tags_{task['id']}")
+                yt_cols = st.columns(3)
+                with yt_cols[0]:
+                    privacy_status = st.selectbox("Privacidade", ["private", "unlisted", "public"], key=f"yt_privacy_{task['id']}")
+                with yt_cols[1]:
+                    category_id = st.text_input("Category ID", value="22", key=f"yt_category_{task['id']}")
+                with yt_cols[2]:
+                    language = st.text_input("Idioma", value="pt-BR", key=f"yt_language_{task['id']}")
+                if st.button("Publicar no YouTube", type="primary", key=f"upload_youtube_{task['id']}"):
+                    tags = [tag.strip() for tag in tags_raw.split(",") if tag.strip()]
+                    result = youtube.upload_video(
+                        video_path,
+                        title=title,
+                        description=description,
+                        tags=tags,
+                        category_id=category_id,
+                        language=language,
+                        privacy_status=privacy_status,
+                        thumbnail_path=thumbnail_path,
+                        captions_path=captions_path,
+                    )
+                    record = {
+                        "task_id": task.get("id"),
+                        "destination": "YouTube",
+                        "status": "published" if result.ok else "failed",
+                        "message": result.message,
+                        "data": result.data,
+                        "created_at": now(),
+                    }
+                    uploads = read_json("uploads.json", [])
+                    uploads.append(record)
+                    write_json("uploads.json", uploads)
+                    (st.success if result.ok else st.error)(result.message)
+                    if result.data.get("attempts"):
+                        with st.expander("Detalhes dos mecanismos de upload"):
+                            st.json(result.data["attempts"])
+            if "TikTok" in destination and st.button("Enviar para TikTok", key=f"upload_tiktok_{task['id']}"):
+                result = TikTokAdapter(settings).upload_video(video_path, task.get("topic", ""))
+                (st.success if result.ok else st.warning)(result.message)
 
 
 def render_settings():
@@ -350,7 +485,15 @@ def render_settings():
         st.subheader("Execução local")
         port = st.number_input("Porta Streamlit", 1, 65535, int(settings.get("port", 3030)))
         moneyprinter_path = st.text_input("Pasta do motor de vídeo", settings.get("moneyprinter_path", ""), key="settings_moneyprinter_path")
-        youtube_api_key = st.text_input("YouTube Data API key", settings.get("youtube_api_key", ""), type="password")
+        st.markdown("**YouTube — API pública e OAuth 2.0**")
+        st.caption("A Data API Key consulta canais e estatísticas públicas. O Client ID e o Client Secret são credenciais OAuth 2.0 separadas, usadas para autorizar operações na conta, como upload.")
+        youtube_cols = st.columns(3)
+        with youtube_cols[0]:
+            youtube_api_key = text_setting("YouTube Data API Key", "youtube_api_key", secret=True, help_text="Chave criada em Google Cloud > APIs e serviços > Credenciais > Chave de API.")
+        with youtube_cols[1]:
+            youtube_client_id = text_setting("YouTube OAuth Client ID", "youtube_client_id", help_text="Client ID do OAuth 2.0 criado no Google Cloud.")
+        with youtube_cols[2]:
+            youtube_client_secret = text_setting("YouTube OAuth Client Secret", "youtube_client_secret", secret=True, help_text="Client Secret do mesmo cliente OAuth 2.0.")
 
         with st.expander("Serviço, materiais e rede"):
             cols = st.columns(2)
@@ -448,6 +591,7 @@ def render_settings():
         if st.form_submit_button("Guardar configurações do Thunderbolt", type="primary"):
             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,
                 "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,
@@ -611,12 +755,14 @@ def main():
         ("Blueprints", ":material/library_books:", "Blueprints"),
         ("Canais", ":material/ondemand_video:", "Canais"),
         ("Novo vídeo", ":material/add_circle:", "Novo vídeo"),
-        ("Vídeos", ":material/video_library:", "Vídeos"),
         ("Upload", ":material/cloud_upload:", "Upload"),
         ("Limpador de metadado", ":material/edit_note:", "Limpador de metadado"),
         ("Configurações", ":material/settings:", "Configurações"),
     ]
     current_page = st.session_state.get("page", "Dashboard")
+    if current_page == "Vídeos":
+        current_page = "Novo vídeo"
+        st.session_state["page"] = current_page
     with st.sidebar:
         version_markup = f'<span class="tb-brand-version">{APP_VERSION}</span>' if APP_VERSION else ""
         st.markdown(f'<div class="tb-brand"><span class="tb-brand-name">Thunderbolt</span>{version_markup}</div>', unsafe_allow_html=True)
@@ -630,7 +776,6 @@ def main():
         "Blueprints": render_blueprints,
         "Canais": render_channels,
         "Novo vídeo": render_new_video,
-        "Vídeos": render_videos,
         "Upload": render_upload,
         "Limpador de metadado": render_metadata_cleaner,
         "Configurações": render_settings,

package/hermes_ui/storage.py

@@ -29,6 +29,8 @@ DEFAULTS: dict[str, Any] = {
         "video_concurrency": 3,
         "upload_concurrency": 2,
         "youtube_api_key": "",
+        "youtube_client_id": "",
+        "youtube_client_secret": "",
         "llm_provider": "moonshot",
         "moonshot_api_key": "",
         "moonshot_base_url": "",

package/integrations/platforms.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 import os
 import re
 from dataclasses import dataclass
@@ -9,6 +10,102 @@ from typing import Any
 import requests
 
 
+def _extract_json_assignment(document: str, variable: str) -> dict[str, Any] | None:
+    marker = re.search(rf"(?:var\s+)?{re.escape(variable)}\s*=", document)
+    if not marker:
+        return None
+    start = document.find("{", marker.end())
+    if start < 0:
+        return None
+    depth = 0
+    in_string = False
+    escaped = False
+    for index in range(start, len(document)):
+        character = document[index]
+        if in_string:
+            if escaped:
+                escaped = False
+            elif character == "\\":
+                escaped = True
+            elif character == '"':
+                in_string = False
+            continue
+        if character == '"':
+            in_string = True
+        elif character == "{":
+            depth += 1
+        elif character == "}":
+            depth -= 1
+            if depth == 0:
+                try:
+                    parsed = json.loads(document[start:index + 1])
+                except json.JSONDecodeError:
+                    return None
+                return parsed if isinstance(parsed, dict) else None
+    return None
+
+
+def _find_first_key(value: Any, key: str) -> Any:
+    if isinstance(value, dict):
+        if key in value:
+            return value[key]
+        for child in value.values():
+            found = _find_first_key(child, key)
+            if found is not None:
+                return found
+    elif isinstance(value, list):
+        for child in value:
+            found = _find_first_key(child, key)
+            if found is not None:
+                return found
+    return None
+
+
+def _text_from_node(value: Any) -> str:
+    if isinstance(value, str):
+        return value.strip()
+    if isinstance(value, dict):
+        for key in ("simpleText", "content", "text"):
+            if isinstance(value.get(key), str):
+                return value[key].strip()
+        runs = value.get("runs")
+        if isinstance(runs, list):
+            return "".join(str(run.get("text", "")) for run in runs if isinstance(run, dict)).strip()
+    return ""
+
+
+def _parse_public_count(value: Any) -> int | None:
+    text = _text_from_node(value).lower().replace(" ", "")
+    if not text:
+        return None
+    match = re.search(r"([0-9][0-9.,]*)(mil|milhões|mi|bi|[kmb])?", text)
+    if not match:
+        return None
+    number = match.group(1)
+    suffix = match.group(2) or ""
+    if suffix == "milhões":
+        suffix = "m"
+    try:
+        if suffix in {"k", "mil"}:
+            return int(float(number.replace(",", ".")) * 1_000)
+        if suffix in {"m", "mi"}:
+            return int(float(number.replace(",", ".")) * 1_000_000)
+        if suffix == "b":
+            return int(float(number.replace(",", ".")) * 1_000_000_000)
+        return int(re.sub(r"[^0-9]", "", number))
+    except ValueError:
+        return None
+
+
+def _thumbnail_from_metadata(metadata: dict[str, Any]) -> str:
+    thumbnails = metadata.get("avatar", {}).get("thumbnails", []) if isinstance(metadata, dict) else []
+    if isinstance(thumbnails, list) and thumbnails:
+        last = thumbnails[-1]
+        if isinstance(last, dict):
+            return str(last.get("url", ""))
+    return ""
+
+
 @dataclass
 class IntegrationResult:
     ok: bool
@@ -17,8 +114,9 @@ class IntegrationResult:
 
 
 class YouTubeAdapter:
-    def __init__(self, api_key: str = ""):
-        self.api_key = api_key or os.getenv("YOUTUBE_API_KEY", "")
+    def __init__(self, api_key: str = "", settings: dict[str, Any] | None = None):
+        self.settings = settings or {}
+        self.api_key = api_key or self.settings.get("youtube_api_key", "") or os.getenv("YOUTUBE_API_KEY", "")
 
     @staticmethod
     def extract_channel_ref(value: str) -> str:
@@ -26,6 +124,72 @@ class YouTubeAdapter:
         match = re.search(r"(?:channel/|@)([A-Za-z0-9_.-]+)", value)
         return match.group(1) if match else value
 
+    def fetch_channel_public(self, value: str) -> IntegrationResult:
+        """Fetch public channel metadata from YouTube HTML without an API key."""
+        source = (value or "").strip()
+        if not source:
+            return IntegrationResult(False, "Introduza o nome, handle, URL ou ID do canal.", {})
+        try:
+            if source.startswith("http://") or source.startswith("https://"):
+                page_url = source.rstrip("/")
+            elif source.startswith("UC"):
+                page_url = f"https://www.youtube.com/channel/{source}"
+            else:
+                handle = source if source.startswith("@") else f"@{source}"
+                page_url = f"https://www.youtube.com/{handle}"
+            if not page_url.endswith("/about"):
+                page_url = f"{page_url}/about"
+            response = requests.get(
+                page_url,
+                headers={
+                    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/124 Safari/537.36",
+                    "Accept-Language": "pt-BR,pt;q=0.9,en;q=0.8",
+                },
+                timeout=20,
+            )
+            response.raise_for_status()
+            document = response.text
+            initial_data = _extract_json_assignment(document, "ytInitialData")
+            metadata = _find_first_key(initial_data or {}, "channelMetadataRenderer") or {}
+            header = _find_first_key(initial_data or {}, "pageHeaderViewModel") or {}
+            if not metadata and not header:
+                return IntegrationResult(False, "O YouTube não disponibilizou dados públicos para este canal. Confirme o link ou tente a aba Cadastro manual.", {"url": page_url})
+            owner_urls = metadata.get("ownerUrls", []) if isinstance(metadata, dict) else []
+            canonical_url = owner_urls[0] if owner_urls else page_url.removesuffix("/about")
+            canonical_url = canonical_url.replace("http://", "https://")
+            handle_match = re.search(r"/@([^/?]+)", canonical_url)
+            handle = f"@{handle_match.group(1)}" if handle_match else ""
+            title = _text_from_node(metadata.get("title")) if isinstance(metadata, dict) else ""
+            if not title and isinstance(header, dict):
+                title = _text_from_node(header.get("title"))
+                if not title:
+                    title = _text_from_node(_find_first_key(header, "dynamicTextViewModel"))
+            description = _text_from_node(metadata.get("description")) if isinstance(metadata, dict) else ""
+            youtube_id = str(metadata.get("externalId", "")) if isinstance(metadata, dict) else ""
+            if not youtube_id:
+                id_match = re.search(r"/channel/(UC[A-Za-z0-9_-]+)", canonical_url)
+                youtube_id = id_match.group(1) if id_match else ""
+            subscriber_value = _find_first_key(initial_data or {}, "subscriberCountText")
+            video_value = _find_first_key(initial_data or {}, "videoCountText")
+            data = {
+                "youtube_id": youtube_id,
+                "name": title,
+                "handle": handle,
+                "url": canonical_url,
+                "description": description,
+                "thumbnail_url": _thumbnail_from_metadata(metadata),
+                "subscriber_count": _parse_public_count(subscriber_value),
+                "video_count": _parse_public_count(video_value),
+                "view_count": None,
+                "metrics_source": "youtube_public_page",
+                "public_lookup": True,
+            }
+            return IntegrationResult(True, "Canal encontrado publicamente no YouTube, sem API Key. Reveja os dados antes de guardar.", data)
+        except requests.RequestException as exc:
+            return IntegrationResult(False, f"Não foi possível consultar a página pública do YouTube: {exc}", {"url": source})
+        except (json.JSONDecodeError, TypeError, ValueError) as exc:
+            return IntegrationResult(False, f"A página pública do YouTube mudou ou não pôde ser interpretada: {exc}", {"url": source})
+
     def fetch_channel(self, value: str) -> IntegrationResult:
         ref = self.extract_channel_ref(value)
         if not self.api_key:
@@ -59,6 +223,36 @@ class YouTubeAdapter:
         except requests.RequestException as exc:
             return IntegrationResult(False, f"Falha ao consultar o YouTube: {exc}", {})
 
+    def upload_video(self, video_path: str, **kwargs: Any) -> IntegrationResult:
+        """Publish through the adapted youtube-automation-agent, then OAuth fallback."""
+        from integrations.youtube_upload import upload_youtube_with_fallback
+        from hermes_ui.storage import STORAGE
+
+        return upload_youtube_with_fallback(
+            self.settings,
+            STORAGE,
+            video_path=video_path,
+            **kwargs,
+        )
+
+    def upload_status(self) -> dict[str, IntegrationResult]:
+        from integrations.youtube_upload import youtube_upload_status
+        from hermes_ui.storage import STORAGE
+
+        return youtube_upload_status(self.settings, STORAGE)
+
+    def authorize_agent(self) -> IntegrationResult:
+        from integrations.youtube_upload import authorize_youtube_agent
+        from hermes_ui.storage import STORAGE
+
+        return authorize_youtube_agent(self.settings, STORAGE)
+
+    def authorize_fallback(self) -> IntegrationResult:
+        from integrations.youtube_upload import authorize_youtube_fallback
+        from hermes_ui.storage import STORAGE
+
+        return authorize_youtube_fallback(self.settings, STORAGE)
+
 
 class TikTokAdapter:
     def __init__(self, settings: dict[str, Any]):

package/integrations/youtube_upload.py

@@ -0,0 +1,367 @@
+from __future__ import annotations
+
+import json
+import os
+import secrets
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+from integrations.platforms import IntegrationResult
+
+
+# Mantemos os mesmos escopos usados pelo youtube-automation-agent.
+AGENT_SCOPES = [
+    "https://www.googleapis.com/auth/youtube.upload",
+    "https://www.googleapis.com/auth/youtube",
+    "https://www.googleapis.com/auth/youtube.readonly",
+    "https://www.googleapis.com/auth/yt-analytics.readonly",
+]
+FALLBACK_SCOPES = ["https://www.googleapis.com/auth/youtube.upload"]
+
+
+@dataclass
+class UploadAttempt:
+    mechanism: str
+    result: IntegrationResult
+
+
+def _safe_text(value: Any, default: str = "") -> str:
+    return str(value if value is not None else default).strip()
+
+
+def _path_value(value: Any) -> Path | None:
+    if isinstance(value, dict):
+        value = value.get("path") or value.get("file") or value.get("filepath")
+    if not value:
+        return None
+    return Path(str(value)).expanduser()
+
+
+def validate_video_file(video_path: str | os.PathLike[str]) -> tuple[bool, str, Path]:
+    """Validate the same real-video conditions used by the agent before publishing."""
+    path = Path(video_path).expanduser()
+    if not path.exists() or not path.is_file():
+        return False, "Ficheiro de vídeo não encontrado; o upload foi recusado.", path
+    if path.suffix.lower() != ".mp4":
+        return False, "O youtube-automation-agent só publica ficheiros MP4 reais.", path
+    if path.stat().st_size <= 0:
+        return False, "O ficheiro de vídeo está vazio; o upload foi recusado.", path
+    return True, "Vídeo válido.", path
+
+
+def build_agent_video_metadata(
+    *,
+    title: str,
+    description: str = "",
+    tags: list[str] | None = None,
+    category_id: str = "22",
+    language: str = "pt-BR",
+    privacy_status: str = "private",
+    publish_at: str | None = None,
+) -> dict[str, Any]:
+    """Build the snippet/status payload used by PublishingSchedulingAgent."""
+    status: dict[str, Any] = {
+        "privacyStatus": privacy_status or "private",
+        "selfDeclaredMadeForKids": False,
+    }
+    if publish_at and status["privacyStatus"] == "private":
+        # YouTube requires a future publishAt with privacyStatus=private.
+        status["publishAt"] = publish_at
+    return {
+        "snippet": {
+            "title": _safe_text(title)[:100] or "Vídeo Thunderbolt",
+            "description": _safe_text(description),
+            "tags": [str(tag).strip() for tag in (tags or []) if str(tag).strip()],
+            "categoryId": _safe_text(category_id, "22"),
+            "defaultLanguage": _safe_text(language, "pt-BR"),
+            "defaultAudioLanguage": _safe_text(language, "pt-BR"),
+        },
+        "status": status,
+    }
+
+
+class _GoogleYouTubeBase:
+    def __init__(self, settings: dict[str, Any], token_path: Path, scopes: list[str], alternate_token_path: Path | None = None):
+        self.settings = settings
+        self.client_id = _safe_text(settings.get("youtube_client_id")) or os.getenv("YOUTUBE_CLIENT_ID", "")
+        self.client_secret = _safe_text(settings.get("youtube_client_secret")) or os.getenv("YOUTUBE_CLIENT_SECRET", "")
+        self.token_path = token_path
+        self.alternate_token_path = alternate_token_path
+        self.scopes = scopes
+
+    @property
+    def configured(self) -> bool:
+        return bool(self.client_id and self.client_secret)
+
+    @property
+    def token_exists(self) -> bool:
+        return any(path.exists() and path.stat().st_size > 0 for path in self._token_candidates())
+
+    def _token_candidates(self) -> list[Path]:
+        paths = [self.token_path]
+        if self.alternate_token_path and self.alternate_token_path not in paths:
+            paths.append(self.alternate_token_path)
+        return paths
+
+    def _client_config(self) -> dict[str, Any]:
+        return {
+            "installed": {
+                "client_id": self.client_id,
+                "client_secret": self.client_secret,
+                "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+                "token_uri": "https://oauth2.googleapis.com/token",
+                "redirect_uris": ["http://localhost"],
+            }
+        }
+
+    def _load_credentials(self) -> Any:
+        try:
+            from google.auth.transport.requests import Request
+            from google.oauth2.credentials import Credentials
+        except ImportError as exc:
+            raise RuntimeError("As dependências Google OAuth ainda não estão instaladas. Execute a instalação do Thunderbolt novamente.") from exc
+        token_source = next((path for path in self._token_candidates() if path.exists() and path.stat().st_size > 0), None)
+        if token_source is None:
+            return None
+        raw = json.loads(token_source.read_text(encoding="utf-8"))
+        if isinstance(raw, dict) and isinstance(raw.get("youtube"), dict):
+            raw = raw["youtube"]
+        credentials = Credentials.from_authorized_user_info(raw, self.scopes)
+        if credentials.expired and credentials.refresh_token:
+            credentials.refresh(Request())
+            self._save_credentials(credentials)
+        return credentials
+
+    def _save_credentials(self, credentials: Any, *, nested: bool = False) -> None:
+        self.token_path.parent.mkdir(parents=True, exist_ok=True)
+        payload = json.loads(credentials.to_json())
+        if nested:
+            payload = {"youtube": payload}
+        temporary = self.token_path.with_name(f".{self.token_path.name}.{secrets.token_hex(6)}.tmp")
+        temporary.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+        try:
+            os.chmod(temporary, 0o600)
+        except OSError:
+            pass
+        temporary.replace(self.token_path)
+        try:
+            os.chmod(self.token_path, 0o600)
+        except OSError:
+            pass
+
+    def _build_client(self, credentials: Any) -> Any:
+        try:
+            from googleapiclient.discovery import build
+        except ImportError as exc:
+            raise RuntimeError("A biblioteca Google API Client ainda não está instalada. Execute a instalação do Thunderbolt novamente.") from exc
+        return build("youtube", "v3", credentials=credentials, cache_discovery=False)
+
+    def authorize(self, *, open_browser: bool = True) -> IntegrationResult:
+        if not self.configured:
+            return IntegrationResult(False, "Preencha o YouTube OAuth Client ID e Client Secret nas Configurações.", {"status": "not_configured"})
+        try:
+            from google_auth_oauthlib.flow import InstalledAppFlow
+        except ImportError as exc:
+            return IntegrationResult(False, "As dependências Google OAuth ainda não estão instaladas. Execute a instalação do Thunderbolt novamente.", {"status": "missing_dependencies", "error": str(exc)})
+        try:
+            flow = InstalledAppFlow.from_client_config(self._client_config(), self.scopes)
+            credentials = flow.run_local_server(
+                host="localhost",
+                port=0,
+                open_browser=open_browser,
+                access_type="offline",
+                prompt="consent",
+                include_granted_scopes="true",
+            )
+            self._save_credentials(credentials, nested=self.__class__.__name__ == "YouTubeAutomationAgentUploader")
+            return IntegrationResult(True, "Conta YouTube autorizada com sucesso.", {"status": "authorized", "token_path": str(self.token_path)})
+        except Exception as exc:
+            return IntegrationResult(False, f"A autorização Google falhou: {exc}", {"status": "authorization_failed"})
+
+    def status(self) -> IntegrationResult:
+        if not self.configured:
+            return IntegrationResult(False, "YouTube OAuth ainda não configurado.", {"status": "not_configured", "authorized": False})
+        if not self.token_exists:
+            return IntegrationResult(False, "YouTube OAuth configurado, mas a conta ainda não foi autorizada.", {"status": "requires_authorization", "authorized": False})
+        try:
+            credentials = self._load_credentials()
+            if credentials and credentials.valid:
+                return IntegrationResult(True, "YouTube autorizado e pronto para publicar.", {"status": "ready", "authorized": True})
+            if credentials and credentials.refresh_token:
+                return IntegrationResult(True, "YouTube autorizado; o token será renovado no próximo uso.", {"status": "ready_refreshable", "authorized": True})
+        except Exception as exc:
+            return IntegrationResult(False, f"Token YouTube inválido ou expirado: {exc}", {"status": "invalid_token", "authorized": False})
+        return IntegrationResult(False, "Token YouTube não está pronto para publicar.", {"status": "requires_authorization", "authorized": False})
+
+    def _upload_common(
+        self,
+        *,
+        video_path: str,
+        title: str,
+        description: str,
+        tags: list[str],
+        category_id: str,
+        language: str,
+        privacy_status: str,
+        publish_at: str | None,
+        thumbnail_path: str | None,
+        captions_path: str | None,
+    ) -> IntegrationResult:
+        valid, message, path = validate_video_file(video_path)
+        if not valid:
+            return IntegrationResult(False, message, {"status": "invalid_video", "path": str(path)})
+        try:
+            credentials = self._load_credentials()
+            if credentials is None:
+                return IntegrationResult(False, "Autorize primeiro a conta YouTube.", {"status": "requires_authorization", "path": str(path)})
+            youtube = self._build_client(credentials)
+            body = build_agent_video_metadata(
+                title=title,
+                description=description,
+                tags=tags,
+                category_id=category_id,
+                language=language,
+                privacy_status=privacy_status,
+                publish_at=publish_at,
+            )
+            try:
+                from googleapiclient.http import MediaFileUpload
+            except ImportError as exc:
+                raise RuntimeError("A biblioteca de upload Google ainda não está instalada.") from exc
+            media = MediaFileUpload(str(path), mimetype="video/mp4", chunksize=8 * 1024 * 1024, resumable=True)
+            request = youtube.videos().insert(part="snippet,status", body=body, media_body=media)
+            response = None
+            while response is None:
+                _, response = request.next_chunk()
+            video_id = response.get("id") if isinstance(response, dict) else None
+            if not video_id:
+                return IntegrationResult(False, "O YouTube não devolveu um ID de vídeo após o upload.", {"status": "upload_failed", "response": response or {}})
+
+            extras: dict[str, Any] = {}
+            thumbnail = _path_value(thumbnail_path)
+            if thumbnail and thumbnail.exists() and thumbnail.is_file():
+                try:
+                    with thumbnail.open("rb") as handle:
+                        youtube.thumbnails().set(videoId=video_id, media_body=handle).execute()
+                    extras["thumbnail_uploaded"] = True
+                except Exception as exc:
+                    extras["thumbnail_warning"] = str(exc)
+            captions = _path_value(captions_path)
+            if captions and captions.exists() and captions.is_file():
+                try:
+                    with captions.open("rb") as handle:
+                        youtube.captions().insert(
+                            part="snippet",
+                            body={"snippet": {"videoId": video_id, "language": language or "pt", "name": "Thunderbolt", "isDraft": False}},
+                            media_body=handle,
+                        ).execute()
+                    extras["captions_uploaded"] = True
+                except Exception as exc:
+                    extras["captions_warning"] = str(exc)
+            return IntegrationResult(
+                True,
+                f"Vídeo publicado no YouTube: https://www.youtube.com/watch?v={video_id}",
+                {"status": "published", "video_id": video_id, "url": f"https://www.youtube.com/watch?v={video_id}", "mechanism": self.__class__.__name__, **extras},
+            )
+        except Exception as exc:
+            return IntegrationResult(False, f"Falha no upload YouTube: {exc}", {"status": "upload_failed", "error": str(exc), "mechanism": self.__class__.__name__})
+
+
+class YouTubeAutomationAgentUploader(_GoogleYouTubeBase):
+    """Adaptation of the source agent's PublishingSchedulingAgent inside Thunderbolt."""
+
+    def __init__(self, settings: dict[str, Any], storage_root: Path):
+        super().__init__(settings, storage_root / "state" / "youtube_agent_tokens.json", AGENT_SCOPES)
+
+    def upload(self, **kwargs: Any) -> IntegrationResult:
+        result = self._upload_common(**kwargs)
+        result.data.setdefault("mechanism", "youtube-automation-agent-adaptado")
+        return result
+
+
+class DirectYouTubeOAuthUploader(_GoogleYouTubeBase):
+    """Independent minimal OAuth upload path used only after the primary path fails."""
+
+    def __init__(self, settings: dict[str, Any], storage_root: Path):
+        super().__init__(
+            settings,
+            storage_root / "state" / "youtube_oauth_fallback_token.json",
+            FALLBACK_SCOPES,
+            alternate_token_path=storage_root / "state" / "youtube_agent_tokens.json",
+        )
+
+    def upload(self, **kwargs: Any) -> IntegrationResult:
+        result = self._upload_common(**kwargs)
+        result.data.setdefault("mechanism", "oauth-direct-fallback")
+        return result
+
+
+def upload_youtube_with_fallback(
+    settings: dict[str, Any],
+    storage_root: Path,
+    *,
+    video_path: str,
+    title: str,
+    description: str = "",
+    tags: list[str] | None = None,
+    category_id: str = "22",
+    language: str = "pt-BR",
+    privacy_status: str = "private",
+    publish_at: str | None = None,
+    thumbnail_path: str | None = None,
+    captions_path: str | None = None,
+    on_attempt: Callable[[UploadAttempt], None] | None = None,
+) -> IntegrationResult:
+    """Run the adapted agent path first and OAuth direct only as redundancy."""
+    kwargs = {
+        "video_path": video_path,
+        "title": title,
+        "description": description,
+        "tags": tags or [],
+        "category_id": category_id,
+        "language": language,
+        "privacy_status": privacy_status,
+        "publish_at": publish_at,
+        "thumbnail_path": thumbnail_path,
+        "captions_path": captions_path,
+    }
+    attempts: list[dict[str, Any]] = []
+    primary = YouTubeAutomationAgentUploader(settings, storage_root)
+    primary_result = primary.upload(**kwargs)
+    primary_result.data.setdefault("mechanism", "youtube-automation-agent-adaptado")
+    primary_attempt = UploadAttempt("youtube-automation-agent-adaptado", primary_result)
+    attempts.append({"mechanism": primary_attempt.mechanism, "ok": primary_result.ok, "message": primary_result.message, "data": primary_result.data})
+    if on_attempt:
+        on_attempt(primary_attempt)
+    if primary_result.ok:
+        primary_result.data["attempts"] = attempts
+        return primary_result
+
+    fallback = DirectYouTubeOAuthUploader(settings, storage_root)
+    fallback_result = fallback.upload(**kwargs)
+    fallback_result.data.setdefault("mechanism", "oauth-direct-fallback")
+    fallback_attempt = UploadAttempt("oauth-direct-fallback", fallback_result)
+    attempts.append({"mechanism": fallback_attempt.mechanism, "ok": fallback_result.ok, "message": fallback_result.message, "data": fallback_result.data})
+    if on_attempt:
+        on_attempt(fallback_attempt)
+    fallback_result.data["attempts"] = attempts
+    if fallback_result.ok:
+        fallback_result.message = f"Upload concluído pelo fallback OAuth directo após falha do agente: {fallback_result.message}"
+        return fallback_result
+    return IntegrationResult(False, f"O agente de upload falhou e o fallback OAuth também falhou. Agente: {primary_result.message} Fallback: {fallback_result.message}", {"status": "all_upload_mechanisms_failed", "attempts": attempts})
+
+
+def authorize_youtube_agent(settings: dict[str, Any], storage_root: Path, *, open_browser: bool = True) -> IntegrationResult:
+    return YouTubeAutomationAgentUploader(settings, storage_root).authorize(open_browser=open_browser)
+
+
+def authorize_youtube_fallback(settings: dict[str, Any], storage_root: Path, *, open_browser: bool = True) -> IntegrationResult:
+    return DirectYouTubeOAuthUploader(settings, storage_root).authorize(open_browser=open_browser)
+
+
+def youtube_upload_status(settings: dict[str, Any], storage_root: Path) -> dict[str, IntegrationResult]:
+    return {
+        "agent": YouTubeAutomationAgentUploader(settings, storage_root).status(),
+        "fallback": DirectYouTubeOAuthUploader(settings, storage_root).status(),
+    }

package/package.json

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

package/requirements.txt

@@ -3,3 +3,6 @@ requests>=2.31,<3
 pandas>=2.0,<3
 imageio-ffmpeg>=0.6,<1
 toml>=0.10,<1
+google-auth>=2.29,<3
+google-auth-oauthlib>=1.2,<2
+google-api-python-client>=2.120,<3

package/scripts/install.mjs

@@ -287,7 +287,7 @@ function writeSettings(moneyprinterPath) {
 
 function installThunderboltDependencies(python) {
   if (!existsSync(pythonBin)) run(python.command, [...python.args, "-m", "venv", venvPath]);
-  installRequirementIfNeeded(join(root, "requirements.txt"), "thunderbolt_requirements_sha256", ["streamlit", "requests", "pandas", "toml", "imageio_ffmpeg"], "Thunderbolt");
+  installRequirementIfNeeded(join(root, "requirements.txt"), "thunderbolt_requirements_sha256", ["streamlit", "requests", "pandas", "toml", "imageio_ffmpeg", "google.auth", "google_auth_oauthlib", "googleapiclient"], "Thunderbolt");
 }
 
 function installMoneyPrinterDependencies(moneyprinterPath) {