@danhachuel/thunderbolt 0.2.34 → 0.2.36

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.34
+> **Versão deste manual:** 0.2.36
 > **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.34 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.36 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes @danhachuel/thunderbolt@0.2.34 install
+npx --yes @danhachuel/thunderbolt@0.2.36 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,7 @@ Set-ExecutionPolicy -Scope CurrentUser RemoteSigned
 
 ## 8. Configuração inicial da UI
 
-Na primeira execução, a barra lateral apresenta **Início**, **Pipeline**, **Automação**, **Niche Finder** e **Configurações**. Abra **Configurações > Configurações Técnicas** e reveja. O menu **Pipeline** contém **Criação de Vídeos**, **Criação de Músicas**, **Upload** e **Limpador de Metadados**. O menu **Configurações** contém **Canais**, **Blueprints**, **MCP** e **Configurações Técnicas**. Para YouTube, preencha primeiro o par **OAuth Client ID + OAuth Client Secret** se pretende autorizar uploads. A **YouTube Data API Key** é uma credencial Google Cloud diferente e fica numa área opcional, apenas para o método oficial de métricas; Client ID + Client Secret não formam uma API Key.
+Na primeira execução, a barra lateral apresenta **Início**, **Pipeline**, **Automação**, **Niche Finder** e **Configurações**. O menu expansível **Niche Finder** contém **Niche Finder Kaggle** e **Niche Finder Apify**. A aba **Niche Finder Kaggle** mantém a análise do dataset Kaggle; **Niche Finder Apify** é uma segunda alternativa independente, com actor, dataset, parâmetros, credencial, execução e resultados próprios. Abra **Configurações > Configurações Técnicas** e reveja. O menu **Pipeline** contém **Criação de Vídeos**, **Criação de Músicas**, **Upload** e **Limpador de Metadados**. O menu **Configurações** contém **Canais**, **Blueprints**, **MCP** e **Configurações Técnicas**. Para YouTube, preencha primeiro o par **OAuth Client ID + OAuth Client Secret** se pretende autorizar uploads. A **YouTube Data API Key** é uma credencial Google Cloud diferente e fica numa área opcional, apenas para o método oficial de métricas; Client ID + Client Secret não formam uma API Key.
 
 | Configuração | Finalidade |
 |---|---|
@@ -360,8 +360,11 @@ Na primeira execução, a barra lateral apresenta **Início**, **Pipeline**, **A
 | Kaggle Username | Nome da conta Kaggle usada para publicar e executar a kernel remota |
 | Kaggle API Key | Chave da conta Kaggle, guardada mascarada apenas em `storage/state/settings.json` |
 | Slug da kernel Kaggle | Identificador da kernel remota, por padrão `thunderbolt-niche-finder` |
+| Apify API Token | Token pessoal da Apify, guardado mascarado no storage local e usado apenas pela alternativa Apify |
+| Apify Actor ID | Actor usado pela alternativa Apify, por padrão `streamers~youtube-scraper` |
+| Apify polling/timeout | Intervalo de consulta e limite máximo da execução do actor |
 
-As credenciais devem ser inseridas apenas na configuração local. A Kaggle API Key é usada somente pelo executor remoto para publicar a kernel, consultar o estado e obter os resultados pequenos; o dataset não é descarregado para `storage/data/niches`. A Data API Key, o OAuth Client ID e o OAuth Client Secret são valores diferentes; Client ID + Secret não geram uma API Key nem um token OAuth até a conta ser autorizada. Não coloque nenhum deles no GitHub, no `package.json`, em blueprints ou em ficheiros de estado versionados.
+As credenciais devem ser inseridas apenas na configuração local. A Kaggle API Key pertence exclusivamente à alternativa Kaggle. O Apify API Token pertence exclusivamente à alternativa Apify e não é usado para Kaggle; os resultados e histórico Apify ficam separados em `niche_apify_runs.json`. A Data API Key, o OAuth Client ID e o OAuth Client Secret são valores diferentes; Client ID + Secret não geram uma API Key nem um token OAuth até a conta ser autorizada. Não coloque nenhum deles no GitHub, no `package.json`, em blueprints ou em ficheiros de estado versionados.
 
 ## 9. Testar as áreas principais
 
@@ -371,7 +374,7 @@ Após iniciar a aplicação, valide o seguinte percurso:
 2. **Blueprints:** coloque um JSON em `~/.thunderbolt/storage/blueprints/importados/` (Windows: `%LOCALAPPDATA%\\THUNDERBOLT\storage\blueprints\importados\`) ou use o carregador da interface.
 3. **Brandings:** abra a subaba **Brandings** e confirme a listagem dos ficheiros JSON.
 4. **Canais:** em **Importar do YouTube**, use o método **Página pública — sem API Key** com um URL `/channel/UC...`, um handle ou uma subpágina `/videos`; o parser resolve o ID, consulta a página pública e tenta o RSS quando necessário. Confirme que o resultado abre o formulário de revisão sem Data API Key. Se o canal não existir ou não fornecer metadados, confirme a mensagem clara e que o formulário de uma pesquisa anterior desaparece. A Data API é opcional e fica separada; em **Cadastro manual**, preencha os dados sem qualquer consulta externa.
-5. **Niche Finder:** abra a página na sidebar, defina os parâmetros dentro do conteúdo principal e confirme que não há preparação automática. Antes do clique, não deve existir download de dataset nem análise. Clique em **Analisar Nichos** para iniciar a preparação dos dados e a análise; depois altere país, engagement, datas e tags e clique novamente para aplicar os novos parâmetros.
+5. **Niche Finder Kaggle:** abra o menu expansível **Niche Finder**, seleccione **Niche Finder Kaggle**, defina os parâmetros dentro do conteúdo principal e confirme que não há preparação automática. Antes do clique, não deve existir download de dataset nem análise. Clique em **Analisar Nichos** para iniciar a preparação dos dados e a análise; depois altere país, engagement, datas e tags e clique novamente para aplicar os novos parâmetros. Em seguida, abra a alternativa independente **Niche Finder Apify**, configure as palavras-chave e filtros na própria aba e confirme que nada é executado antes de clicar em **Pesquisar no Apify**.
 6. **Pipeline > Criação de Vídeos:** teste primeiro o modo **Canal específico** e depois os modos de lote.
 7. **Criação de Vídeos > Vídeos:** verifique o estado `to_do` e os botões **Iniciar** e **Parar** dentro da subaba. Confirme também que **Criação de Músicas** mostra o mesmo fluxo com título próprio.
 8. **Upload:** configure o OAuth Client ID e Secret, autorize primeiro o **youtube-automation-agent** na própria aba, confirme o estado **pronto para publicar**, preencha título/descrição/tags e publique um MP4 real. O botão **Autorizar fallback OAuth** existe apenas para redundância; a Data API Key, se configurada, é exclusivamente para consultas oficiais públicas e nunca substitui OAuth.
@@ -385,15 +388,19 @@ Após iniciar a aplicação, valide o seguinte percurso:
 16. **Configurações > MCP > Servidor MCP:** abra a subaba, mantenha o host `127.0.0.1`, active **Servidor MCP ON** e clique em **Guardar e iniciar Servidor MCP**. Confirme o endpoint `/mcp` e o health endpoint `/health`. Mantenha **Permitir ferramentas de escrita** desactivado até precisar que um agente crie lotes.
 17. **Configurações > MCP > Skill:** clique em **Guardar skill localmente** e confirme o ficheiro em `storage/skills/moneyprinterturbo-video.md`; opcionalmente use **Descarregar skill .md** para obter a cópia através do navegador.
 
-## Niche Finder
+## Niche Finder Kaggle e Niche Finder Apify
 
-A página **Niche Finder** integra a lógica adaptada do projecto open source [johanfortus/Niche-Finder](https://github.com/johanfortus/Niche-Finder), cujo projecto original usa K-Means e FP-Growth sobre o dataset público [Trending Youtube Video Statistics (113 Countries)](https://www.kaggle.com/datasets/asaniczka/trending-youtube-videos-113-countries). No Thunderbolt não existe Flask, rota HTTP adicional, template HTML, JavaScript D3 ou segundo processo; toda a análise é síncrona no Streamlit.
+A página **Niche Finder Kaggle** integra a lógica adaptada do projecto open source [johanfortus/Niche-Finder](https://github.com/johanfortus/Niche-Finder), cujo projecto original usa K-Means e FP-Growth sobre o dataset público [Trending Youtube Video Statistics (113 Countries)](https://www.kaggle.com/datasets/asaniczka/trending-youtube-videos-113-countries). No Thunderbolt não existe Flask, rota HTTP adicional, template HTML, JavaScript D3 ou segundo processo; toda a análise é síncrona no Streamlit.
 
 Ao abrir a página, o Thunderbolt não prepara dados públicos, não descarrega o dataset e não inicia a análise. A instalação das dependências continua automática, mas a operação é manual: os parâmetros ficam dentro da própria aba e o utilizador deve clicar em **Analisar Nichos**. Só depois desse clique o KaggleHub prepara ou reutiliza a cache local; não há upload de CSV, botão de download manual ou selector de ficheiros.
 
 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.34 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.36 install`; o instalador detecta e reutiliza o que já estiver válido.
+
+### Niche Finder Apify
+
+A alternativa Apify não usa o dataset, parâmetros, execução ou estado da alternativa Kaggle. Configure o **Apify API Token**, o **Apify Actor ID**, o intervalo de consulta e o limite da execução em **Configurações Técnicas**. Na aba, informe até três palavras-chave, período, máximo de resultados, Shorts, duração, idioma das legendas, ordenação e filtros de legendas. O botão **Pesquisar no Apify** inicia manualmente o actor `streamers~youtube-scraper`, consulta o estado do run, carrega o dataset, normaliza os vídeos, limpa SRT, calcula VSC Ratio, tenta resumir transcrições através do LLM configurado e disponibiliza resultados JSON/CSV. O histórico resumido é guardado em `storage/state/niche_apify_runs.json`; não há gravação automática no Airtable do workflow anexado.
 
 ## Pipeline: Criação de Vídeos, Criação de Músicas e Automação
 

package/README.md

@@ -17,18 +17,18 @@ A primeira versão implementa a camada UI independente com:
 | Canais | Subabas de importação pública sem API Key, Data API opcional e cadastro manual independente |
 | Criação de Vídeos / Criação de Músicas | Subabas Criar vídeo e Vídeos; lotes; 51 rótulos de idioma; Pexels/Pixabay, full IA com Estilo IA e Apenas Música com agente musical; a segunda página reutiliza o mesmo fluxo com título próprio |
 | Automação | Lista de vídeos e canais, selectores editáveis de Blueprint/voz padrão, Automação ON, horário diário HH:MM e worker local baseado no relógio do computador |
-| Niche Finder | Parâmetros dentro da própria aba, início manual após clique, K-Means, FP-Growth, regras de associação, clusters e gráfico Plotly nativo |
+| Niche Finder | Menu expansível com duas alternativas independentes: Niche Finder Kaggle e Niche Finder Apify, com parâmetros, execução e resultados separados |
 | Upload | YouTube via `youtube-automation-agent` adaptado internamente, OAuth directo de redundância, Upload directo experimental, TikTok, Instagram e Facebook Pages no front end |
 | MCP | Catálogo local opcional de Short Video Maker, AutoVio, OpenMontage e OpenCut, com portas editáveis e activação |
 | Limpador de Metadados | Upload isolado de vídeos terceiros, limpeza FFmpeg, edição de título/descrição/tags e manifesto JSON |
-| Configurações Técnicas | Provedores LLM, TTS/voz, preview de vozes, Suno, materiais, Whisper, FFmpeg, OAuth YouTube, Data API Key opcional, Kaggle Username/API Key, Upload directo, TikTok Client ID/Secret e Upload-Post |
+| Configurações Técnicas | Provedores LLM, TTS/voz, preview de vozes, Suno, materiais, Whisper, FFmpeg, OAuth YouTube, Data API Key opcional, Kaggle Username/API Key, Apify API Token/Actor ID/limites, Upload directo, TikTok Client ID/Secret e Upload-Post |
 | Launcher | Execução via `npx`, instalação assistida, diagnóstico e preparação para distribuição |
 
 Os adaptadores do MoneyPrinterTurbo e de publicação nas plataformas são ligados pelas configurações locais e pelos pontos de integração em `integrations/`. A UI não inventa dados quando um serviço externo ou credencial não está disponível.
 
-## Navegação da UI 0.2.34
+## Navegação da UI 0.2.36
 
-A barra lateral mantém apenas os cinco níveis principais, nesta ordem: **Início**, **Pipeline**, **Automação**, **Niche Finder** e **Configurações**. **Pipeline** é expansível e contém **Criação de Vídeos**, **Criação de Músicas**, **Upload** e **Limpador de Metadados**. **Configurações** é expansível e contém **Canais**, **Blueprints**, **MCP** e **Configurações Técnicas**. O Início reúne o dashboard e as filas do Pipeline, sem botões de acções rápidas.
+A barra lateral mantém os níveis principais, nesta ordem: **Início**, **Pipeline**, **Automação**, **Niche Finder** e **Configurações**. **Pipeline** é expansível e contém **Criação de Vídeos**, **Criação de Músicas**, **Upload** e **Limpador de Metadados**. **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.
 
 ## Instalação
 
@@ -115,9 +115,9 @@ thunderbolt
 No Windows PowerShell, se `npx` for bloqueado por `npx.ps1`, use directamente `npx.cmd`:
 
 ```powershell
-npx.cmd --yes @danhachuel/thunderbolt@0.2.34 install
-npx.cmd --yes @danhachuel/thunderbolt@0.2.34 doctor
-npx.cmd --yes @danhachuel/thunderbolt@0.2.34
+npx.cmd --yes @danhachuel/thunderbolt@0.2.36 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.36 doctor
+npx.cmd --yes @danhachuel/thunderbolt@0.2.36
 ```
 
 Como alternativa, pode permitir scripts para o seu utilizador:
@@ -137,11 +137,11 @@ Após `install`, o launcher usa o ambiente virtual instalado em `~/.thunderbolt/
 
 ## Niche Finder
 
-A página **Niche Finder** integra a lógica do projecto open source [johanfortus/Niche-Finder](https://github.com/johanfortus/Niche-Finder) directamente no processo Streamlit. O Thunderbolt não inicia Flask, não abre uma porta adicional e não copia templates HTML ou D3. Ao abrir a página, o Thunderbolt não descarrega dados, não prepara o dataset e não executa análises. A instalação das dependências continua automática, mas a operação é manual: o utilizador define os parâmetros dentro da própria aba e clica em **Analisar Nichos**. Só nesse momento o KaggleHub prepara ou reutiliza a cache local do dataset e a análise é executada.
+O menu expansível **Niche Finder** contém duas alternativas independentes. **Niche Finder Kaggle** é a página actual de análise e integra a lógica do projecto open source [johanfortus/Niche-Finder](https://github.com/johanfortus/Niche-Finder) directamente no processo Streamlit. O Thunderbolt não inicia Flask, não abre uma porta adicional e não copia templates HTML ou D3. Ao abrir a página, o Thunderbolt não descarrega dados, não prepara o dataset e não executa análises. A instalação das dependências continua automática, mas a operação é manual: o utilizador define os parâmetros dentro da própria aba e clica em **Analisar Nichos**. Só nesse momento o KaggleHub prepara ou reutiliza a cache local do dataset e a análise é executada.
 
 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.
 
-As dependências adicionais são instaladas pelo fluxo normal do pacote: `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub`. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.34 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.36 install`; o instalador detecta e reutiliza componentes já válidos.
 
 ## Armazenamento local
 

package/app/main.py

@@ -20,8 +20,10 @@ except (OSError, json.JSONDecodeError):
 from hermes_ui.domain import STAGES, create_batch, create_channel, create_tasks_for_batch, delete_channel, pipeline_summary, set_channel_defaults, transition_task, update_channel
 from hermes_ui.automation_worker import load_worker_status
 from hermes_ui.storage import BLUEPRINTS, ensure_storage, list_blueprint_files, load_blueprint_file, now, read_json, write_json
+from app.modules.niche_finder.apify import ApifyError, DEFAULT_ACTOR_ID, abort_actor_run, build_actor_input, get_dataset_items, normalize_video_items, start_actor_run, wait_for_actor_run
 from app.modules.niche_finder.core import NicheAnalysisError, run_niche_analysis
 from app.modules.niche_finder.data_loader import DatasetError, download_kaggle_dataset
+from app.modules.niche_finder.summarizer import summarize_items
 from hermes_ui.blueprints import create_blueprint_from_link, list_branding_files, save_generated_blueprint
 from hermes_ui.metadata_cleaner import build_description, clean_video_metadata, list_edit_records, metadata_manifest, normalize_tags, save_edit_record, store_external_video
 from hermes_ui.mcp import detect_local_service, install_skill_locally, load_integrations, load_server_config, read_packaged_skill, save_server_config, update_integration
@@ -637,7 +639,7 @@ def _cached_niche_download():
 
 
 def render_niche_finder():
-    st.title("Niche Finder")
+    st.title("Niche Finder Kaggle")
     st.caption("Busca de padrões, nichos e tags para orientar canais faceless.")
     st.info("A instalação das dependências é automática. A operação não é: defina os parâmetros abaixo e clique em **Analisar Nichos** para iniciar.")
 
@@ -743,6 +745,143 @@ def render_niche_finder():
         st.dataframe(results["raw_data"], use_container_width=True, hide_index=True)
 
 
+def render_niche_finder_apify():
+    st.title("Niche Finder Apify")
+    st.caption("Alternativa independente ao Niche Finder Kaggle: pesquisa vídeos outlier no YouTube através do actor Apify e organiza dados, legendas e estrutura dos vídeos.")
+    st.info("Esta página não usa o dataset, os filtros, a execução ou os resultados do Kaggle. A instalação das dependências é automática, mas a operação é manual: defina os parâmetros nesta aba e clique em **Pesquisar no Apify** para iniciar.")
+    settings = read_json("settings.json", {})
+
+    active_run = st.session_state.get("niche_apify_active_run")
+    if active_run:
+        st.warning(f"Existe uma execução Apify pendente: `{active_run.get('run_id', 'sem ID')}`.")
+        if st.button("Cancelar execução actual", key="niche_apify_cancel"):
+            try:
+                abort_actor_run(settings.get("apify_api_token", ""), active_run.get("run_id", ""))
+                st.session_state.pop("niche_apify_active_run", None)
+                st.success("Execução Apify cancelada.")
+                st.rerun()
+            except ApifyError as exc:
+                st.error(str(exc))
+
+    with st.container(border=True):
+        st.subheader("Parâmetros da pesquisa")
+        with st.form("niche_apify_parameters", clear_on_submit=False):
+            keyword_cols = st.columns(3)
+            with keyword_cols[0]:
+                keyword1 = st.text_input("Palavra-chave 1", key="niche_apify_keyword1", placeholder="Ex.: healthy food")
+            with keyword_cols[1]:
+                keyword2 = st.text_input("Palavra-chave 2", key="niche_apify_keyword2", placeholder="Ex.: meal prep healthy")
+            with keyword_cols[2]:
+                keyword3 = st.text_input("Palavra-chave 3", key="niche_apify_keyword3", placeholder="Ex.: high protein snack")
+            search_cols = st.columns(4)
+            with search_cols[0]:
+                date_filter = st.selectbox("Período", ["week", "month", "3months", "year", "all"], index=0, key="niche_apify_date_filter")
+            with search_cols[1]:
+                max_results = st.number_input("Máximo por pesquisa", min_value=1, max_value=100, value=3, step=1, key="niche_apify_max_results")
+            with search_cols[2]:
+                max_results_shorts = st.number_input("Máximo de Shorts", min_value=0, max_value=100, value=0, step=1, key="niche_apify_max_results_shorts")
+            with search_cols[3]:
+                length_filter = st.selectbox("Duração", ["between420", "any", "short", "long"], index=0, key="niche_apify_length_filter")
+            filter_cols = st.columns(4)
+            with filter_cols[0]:
+                subtitles_language = st.selectbox("Idioma das legendas", ["en", "pt", "es", "fr", "de"], index=0, key="niche_apify_subtitles_language")
+            with filter_cols[1]:
+                sorting_order = st.selectbox("Ordenação", ["relevance", "date", "viewCount", "rating"], index=0, key="niche_apify_sorting_order")
+            with filter_cols[2]:
+                download_subtitles = st.checkbox("Descarregar legendas", value=True, key="niche_apify_download_subtitles")
+            with filter_cols[3]:
+                has_cc = st.checkbox("Apenas vídeos com CC", value=False, key="niche_apify_has_cc")
+            analyse_apify = st.form_submit_button("Pesquisar no Apify", type="primary", use_container_width=True)
+
+    if analyse_apify:
+        try:
+            actor_input = build_actor_input(
+                [keyword1, keyword2, keyword3],
+                date_filter=date_filter,
+                max_results=int(max_results),
+                max_results_shorts=int(max_results_shorts),
+                length_filter=length_filter,
+                subtitles_language=subtitles_language,
+                download_subtitles=download_subtitles,
+                sorting_order=sorting_order,
+                has_cc=has_cc,
+            )
+            token = str(settings.get("apify_api_token", "") or "").strip()
+            actor_id = str(settings.get("apify_actor_id", DEFAULT_ACTOR_ID) or DEFAULT_ACTOR_ID).strip()
+            st.session_state["niche_apify_active_run"] = {"run_id": "a iniciar", "started_at": now()}
+            progress = st.progress(0, text="A iniciar o actor Apify…")
+            run = start_actor_run(token, actor_id, actor_input)
+            st.session_state["niche_apify_active_run"] = {"run_id": run.run_id, "started_at": now(), "status": run.status}
+            progress.progress(15, text=f"Actor iniciado: {run.run_id}. A aguardar dataset…")
+
+            def update_progress(current_run):
+                st.session_state["niche_apify_active_run"] = {"run_id": current_run.run_id, "started_at": st.session_state["niche_apify_active_run"].get("started_at", now()), "status": current_run.status}
+                progress.progress(35 if current_run.status not in {"SUCCEEDED"} else 55, text=f"Estado Apify: {current_run.status}")
+
+            finished = wait_for_actor_run(
+                token,
+                run,
+                poll_interval=int(settings.get("apify_poll_interval_seconds", 10)),
+                timeout_seconds=int(settings.get("apify_run_timeout_seconds", 900)),
+                on_status=update_progress,
+            )
+            progress.progress(60, text="Dataset recebido. A carregar vídeos…")
+            raw_items = get_dataset_items(token, finished.dataset_id, limit=int(max_results) * max(1, len([value for value in [keyword1, keyword2, keyword3] if value.strip()])))
+            items = normalize_video_items(raw_items)
+            progress.progress(70, text=f"{len(items)} vídeo(s) carregado(s). A preparar transcrições…")
+            items = summarize_items(items, settings, on_item=lambda current, total, item: progress.progress(70 + int((current / max(total, 1)) * 25), text=f"A resumir vídeo {current}/{total}…"))
+            st.session_state["niche_apify_results"] = items
+            st.session_state["niche_apify_last_run"] = {"run_id": finished.run_id, "status": finished.status, "dataset_id": finished.dataset_id, "created_at": now(), "item_count": len(items), "parameters": actor_input}
+            history = read_json("niche_apify_runs.json", [])
+            if not isinstance(history, list):
+                history = []
+            history.insert(0, st.session_state["niche_apify_last_run"])
+            write_json("niche_apify_runs.json", history[:20])
+            st.session_state.pop("niche_apify_active_run", None)
+            progress.progress(100, text="Pesquisa Apify concluída.")
+            st.success(f"Pesquisa concluída: {len(items)} vídeo(s) recebido(s).")
+        except ApifyError as exc:
+            st.error(str(exc))
+        except Exception as exc:
+            st.error(f"A pesquisa Apify terminou com um erro inesperado: {exc}")
+
+    results = st.session_state.get("niche_apify_results", [])
+    if not results:
+        st.caption("Ainda não existe uma pesquisa nesta sessão. Ajuste os parâmetros e clique em **Pesquisar no Apify**.")
+        return
+
+    st.subheader("Vídeos encontrados")
+    result_filter = st.text_input("Filtrar resultados", placeholder="Título, canal ou palavra no resumo", key="niche_apify_result_filter")
+    status_filter = st.selectbox("Estado da sumarização", ["Todos", "concluído", "sem transcrição", "não aplicável", "erro"], key="niche_apify_status_filter")
+    visible_results = results
+    if result_filter.strip():
+        term = result_filter.strip().casefold()
+        visible_results = [item for item in visible_results if term in str(item.get("title", "")).casefold() or term in str(item.get("channel_name", "")).casefold() or term in str(item.get("summary", "")).casefold()]
+    if status_filter != "Todos":
+        visible_results = [item for item in visible_results if str(item.get("summary_status", "")).startswith(status_filter)]
+    try:
+        import pandas as pd
+        result_frame = pd.DataFrame(visible_results)
+        display_columns = ["title", "channel_name", "duration", "view_count", "subscriber_count", "comments_count", "vsc_ratio", "url", "transcript_status", "summary_status", "summary"]
+        display_columns = [column for column in display_columns if column in result_frame.columns]
+        st.dataframe(result_frame[display_columns], use_container_width=True, hide_index=True)
+        export_frame = result_frame.drop(columns=["transcript"], errors="ignore")
+        export_json = export_frame.to_json(orient="records", force_ascii=False, indent=2)
+        export_csv = export_frame.to_csv(index=False).encode("utf-8")
+        export_cols = st.columns(2)
+        with export_cols[0]:
+            st.download_button("Exportar JSON", data=export_json, file_name="niche-finder-apify-results.json", mime="application/json", use_container_width=True, key="niche_apify_export_json")
+        with export_cols[1]:
+            st.download_button("Exportar CSV", data=export_csv, file_name="niche-finder-apify-results.csv", mime="text/csv", use_container_width=True, key="niche_apify_export_csv")
+    except ImportError:
+        st.dataframe(visible_results, use_container_width=True, hide_index=True)
+
+    last_run = st.session_state.get("niche_apify_last_run", {})
+    if last_run:
+        with st.expander("Detalhes da última execução"):
+            st.json({key: value for key, value in last_run.items() if key != "parameters"})
+
+
 def render_videos():
     st.subheader("Vídeos e backlog")
     st.caption("Acompanhamento dos vídeos criados, estados da pipeline e controlos de execução.")
@@ -1035,6 +1174,18 @@ def render_settings():
             with kaggle_cols[2]:
                 kaggle_kernel_slug = text_setting("Slug da kernel", "kaggle_kernel_slug", help_text="Identificador da kernel remota, por exemplo thunderbolt-niche-finder.")
 
+        with st.expander("Niche Finder — execução através da Apify", expanded=True):
+            st.caption("O token fica guardado apenas no storage local. A aba Niche Finder Apify só usa este serviço depois de clicar no botão de pesquisa.")
+            apify_cols = st.columns(4)
+            with apify_cols[0]:
+                apify_api_token = text_setting("Apify API Token", "apify_api_token", secret=True, help_text="Token pessoal da Apify. Não é incluído no workflow, logs ou GitHub.")
+            with apify_cols[1]:
+                apify_actor_id = text_setting("Apify Actor ID", "apify_actor_id", help_text="Por padrão: streamers~youtube-scraper.")
+            with apify_cols[2]:
+                apify_poll_interval = st.number_input("Intervalo de consulta (s)", min_value=1, max_value=120, value=int(settings.get("apify_poll_interval_seconds", 10)), step=1)
+            with apify_cols[3]:
+                apify_run_timeout = st.number_input("Limite da execução (s)", min_value=30, max_value=7200, value=int(settings.get("apify_run_timeout_seconds", 900)), step=30)
+
         with st.expander("Consulta oficial de métricas — opcional"):
             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.")
@@ -1156,6 +1307,7 @@ def render_settings():
                 "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,
                 "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,
@@ -1498,6 +1650,10 @@ def main():
         ("MCP", ":material/hub:", "MCP"),
         ("Configurações Técnicas", ":material/settings:", "Configurações Técnicas"),
     ]
+    niche_finder_items = [
+        ("Niche Finder Kaggle", ":material/search:", "Niche Finder Kaggle"),
+        ("Niche Finder Apify", ":material/api:", "Niche Finder Apify"),
+    ]
     top_pages = [
         ("Início", ":material/home:", "Início"),
         ("Pipeline", ":material/account_tree:", "Pipeline"),
@@ -1510,10 +1666,11 @@ def main():
         "Novo vídeo": "Criação de Vídeos",
         "Vídeos": "Criação de Vídeos",
         "Limpador de metadado": "Limpador de Metadados",
+        "Niche Finder": "Niche Finder Kaggle",
         "Configurações Técnicas": "Configurações Técnicas",
     }
     current_page = aliases.get(st.session_state.get("page", "Início"), st.session_state.get("page", "Início"))
-    if current_page not in {item[0] for item in top_pages + pipeline_items + settings_items}:
+    if current_page not in {item[0] for item in top_pages + pipeline_items + niche_finder_items + settings_items}:
         current_page = "Início"
     st.session_state["page"] = current_page
 
@@ -1533,6 +1690,10 @@ def main():
                 with st.expander("Pipeline", expanded=current_page in {item[0] for item in pipeline_items}, icon=":material/account_tree:"):
                     for child_target, child_icon, child_label in pipeline_items:
                         render_nav_button(child_target, child_icon, child_label, child=True)
+            elif target == "Niche Finder":
+                with st.expander("Niche Finder", expanded=current_page in {item[0] for item in niche_finder_items}, icon=":material/search:"):
+                    for child_target, child_icon, child_label in niche_finder_items:
+                        render_nav_button(child_target, child_icon, child_label, child=True)
             elif target == "Configurações":
                 with st.expander("Configurações", expanded=current_page in {item[0] for item in settings_items}, icon=":material/settings:"):
                     for child_target, child_icon, child_label in settings_items:
@@ -1545,7 +1706,8 @@ def main():
         "Criação de Vídeos": render_new_video,
         "Criação de Músicas": render_music_creation,
         "Automação": render_automation,
-        "Niche Finder": render_niche_finder,
+        "Niche Finder Kaggle": render_niche_finder,
+        "Niche Finder Apify": render_niche_finder_apify,
         "Upload": render_upload,
         "Limpador de Metadados": render_metadata_cleaner,
         "Canais": render_channels,

package/app/modules/niche_finder/apify.py

@@ -0,0 +1,260 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any, Callable, Iterable
+from urllib.parse import quote
+
+import requests
+
+APIFY_API_BASE = "https://api.apify.com/v2"
+DEFAULT_ACTOR_ID = "streamers~youtube-scraper"
+TERMINAL_STATUSES = {"SUCCEEDED", "FAILED", "ABORTED", "TIMED-OUT"}
+
+
+class ApifyError(RuntimeError):
+    """Raised when an Apify run cannot be started or collected."""
+
+
+@dataclass(frozen=True)
+class ApifyRun:
+    run_id: str
+    status: str
+    dataset_id: str = ""
+    actor_id: str = DEFAULT_ACTOR_ID
+
+
+def _json_response(response: requests.Response, action: str) -> Any:
+    if response.status_code >= 400:
+        detail = response.text[:400].strip()
+        raise ApifyError(f"A Apify devolveu HTTP {response.status_code} ao {action}: {detail}")
+    try:
+        return response.json()
+    except ValueError as exc:
+        raise ApifyError(f"A Apify devolveu uma resposta inválida ao {action}.") from exc
+
+
+def _headers(token: str) -> dict[str, str]:
+    token = str(token or "").strip()
+    if not token:
+        raise ApifyError("Configure o Apify API Token em Configurações Técnicas antes de iniciar.")
+    return {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
+
+
+def build_actor_input(
+    keywords: Iterable[str],
+    *,
+    date_filter: str = "week",
+    max_results: int = 3,
+    max_results_shorts: int = 0,
+    length_filter: str = "between420",
+    subtitles_language: str = "en",
+    download_subtitles: bool = True,
+    sorting_order: str = "relevance",
+    has_cc: bool = False,
+) -> dict[str, Any]:
+    values = [str(keyword or "").strip() for keyword in keywords]
+    values = [keyword for keyword in values if keyword]
+    if not values:
+        raise ApifyError("Introduza pelo menos uma palavra-chave para pesquisar no Apify.")
+    return {
+        "dateFilter": str(date_filter or "week"),
+        "downloadSubtitles": bool(download_subtitles),
+        "hasCC": bool(has_cc),
+        "hasLocation": False,
+        "hasSubtitles": False,
+        "is360": False,
+        "is3D": False,
+        "is4K": False,
+        "isBought": False,
+        "isHD": False,
+        "isHDR": False,
+        "isLive": False,
+        "isVR180": False,
+        "lengthFilter": str(length_filter or "between420"),
+        "maxResultStreams": 0,
+        "maxResults": max(1, min(int(max_results), 100)),
+        "maxResultsShorts": max(0, min(int(max_results_shorts), 100)),
+        "preferAutoGeneratedSubtitles": False,
+        "saveSubsToKVS": False,
+        "searchQueries": values,
+        "sortingOrder": str(sorting_order or "relevance"),
+        "subtitlesLanguage": str(subtitles_language or "en"),
+    }
+
+
+def start_actor_run(token: str, actor_id: str, actor_input: dict[str, Any], *, timeout: int = 60) -> ApifyRun:
+    actor_id = str(actor_id or DEFAULT_ACTOR_ID).strip() or DEFAULT_ACTOR_ID
+    url = f"{APIFY_API_BASE}/acts/{quote(actor_id, safe='~')}/runs"
+    try:
+        response = requests.post(url, headers=_headers(token), json=actor_input, timeout=timeout)
+    except requests.RequestException as exc:
+        raise ApifyError(f"Não foi possível iniciar o actor da Apify: {exc}") from exc
+    body = _json_response(response, "iniciar o actor")
+    data = body.get("data", body) if isinstance(body, dict) else {}
+    run_id = str(data.get("id") or data.get("runId") or "").strip()
+    if not run_id:
+        raise ApifyError("A Apify iniciou o pedido, mas não devolveu um run ID.")
+    status = str(data.get("status") or "RUNNING").upper()
+    dataset_id = str(data.get("defaultDatasetId") or data.get("datasetId") or "").strip()
+    return ApifyRun(run_id=run_id, status=status, dataset_id=dataset_id, actor_id=actor_id)
+
+
+def get_actor_run(token: str, run_id: str, *, timeout: int = 30) -> ApifyRun:
+    run_id = str(run_id or "").strip()
+    if not run_id:
+        raise ApifyError("A execução Apify não tem run ID.")
+    url = f"{APIFY_API_BASE}/actor-runs/{quote(run_id, safe='')}"
+    try:
+        response = requests.get(url, headers=_headers(token), timeout=timeout)
+    except requests.RequestException as exc:
+        raise ApifyError(f"Não foi possível consultar o estado da execução Apify: {exc}") from exc
+    body = _json_response(response, "consultar o estado da execução")
+    data = body.get("data", body) if isinstance(body, dict) else {}
+    status = str(data.get("status") or "UNKNOWN").upper()
+    dataset_id = str(data.get("defaultDatasetId") or data.get("datasetId") or "").strip()
+    actor_id = str(data.get("actId") or data.get("actorId") or DEFAULT_ACTOR_ID)
+    return ApifyRun(run_id=run_id, status=status, dataset_id=dataset_id, actor_id=actor_id)
+
+
+def get_dataset_items(token: str, dataset_id: str, *, limit: int = 100, timeout: int = 60) -> list[dict[str, Any]]:
+    dataset_id = str(dataset_id or "").strip()
+    if not dataset_id:
+        raise ApifyError("A execução Apify terminou sem devolver um dataset ID.")
+    url = f"{APIFY_API_BASE}/datasets/{quote(dataset_id, safe='')}/items"
+    try:
+        response = requests.get(
+            url,
+            headers=_headers(token),
+            params={"format": "json", "clean": "true", "limit": max(1, min(int(limit), 1000))},
+            timeout=timeout,
+        )
+    except requests.RequestException as exc:
+        raise ApifyError(f"Não foi possível carregar o dataset Apify: {exc}") from exc
+    body = _json_response(response, "carregar o dataset")
+    if not isinstance(body, list):
+        raise ApifyError("O dataset Apify não devolveu uma lista de vídeos.")
+    return [item for item in body if isinstance(item, dict)]
+
+
+def abort_actor_run(token: str, run_id: str, *, timeout: int = 30) -> None:
+    url = f"{APIFY_API_BASE}/actor-runs/{quote(str(run_id), safe='')}/abort"
+    try:
+        response = requests.post(url, headers=_headers(token), params={"gracefully": "0"}, timeout=timeout)
+    except requests.RequestException as exc:
+        raise ApifyError(f"Não foi possível cancelar a execução Apify: {exc}") from exc
+    _json_response(response, "cancelar a execução")
+
+
+def wait_for_actor_run(
+    token: str,
+    run: ApifyRun,
+    *,
+    poll_interval: int = 10,
+    timeout_seconds: int = 900,
+    on_status: Callable[[ApifyRun], None] | None = None,
+) -> ApifyRun:
+    import time
+
+    started = time.monotonic()
+    current = run
+    while current.status not in TERMINAL_STATUSES:
+        if time.monotonic() - started >= max(10, int(timeout_seconds)):
+            raise ApifyError(f"A execução Apify excedeu o limite de {int(timeout_seconds)} segundos.")
+        if on_status:
+            on_status(current)
+        time.sleep(max(1, int(poll_interval)))
+        current = get_actor_run(token, run.run_id)
+    if on_status:
+        on_status(current)
+    if current.status != "SUCCEEDED":
+        raise ApifyError(f"A execução Apify terminou com o estado {current.status}.")
+    return current
+
+
+def _first_value(item: dict[str, Any], *keys: str, default: Any = "") -> Any:
+    for key in keys:
+        value = item.get(key)
+        if value not in (None, ""):
+            return value
+    return default
+
+
+def _number(value: Any) -> int | float:
+    if isinstance(value, bool):
+        return 0
+    if isinstance(value, (int, float)):
+        return value
+    text = str(value or "").replace(",", "").strip()
+    try:
+        number = float(text)
+    except ValueError:
+        return 0
+    return int(number) if number.is_integer() else number
+
+
+def clean_srt(value: Any) -> str:
+    if isinstance(value, dict):
+        value = value.get("srt") or value.get("text") or value.get("content") or ""
+    if isinstance(value, list):
+        parts = [clean_srt(part) for part in value]
+        return " ".join(part for part in parts if part).strip()
+    text = str(value or "")
+    if not text.strip():
+        return ""
+    text = re.sub(r"^\s*\d+\s*$", "", text, flags=re.MULTILINE)
+    text = re.sub(r"^\s*\d{2}:\d{2}:\d{1,2},\d{1,3}\s*-->\s*\d{2}:\d{2}:\d{1,2},\d{1,3}.*$", "", text, flags=re.MULTILINE)
+    text = re.sub(r"\n{2,}", "\n", text)
+    return re.sub(r"\s+", " ", text.replace("\n", " ")).strip()
+
+
+def extract_transcript(item: dict[str, Any]) -> str:
+    subtitles = item.get("subtitles")
+    if isinstance(subtitles, list):
+        for subtitle in subtitles:
+            text = clean_srt(subtitle)
+            if text:
+                return text
+    for key in ("srt", "transcript", "subtitlesText", "captionText"):
+        text = clean_srt(item.get(key))
+        if text:
+            return text
+    return ""
+
+
+def vsc_ratio(view_count: Any, subscriber_count: Any, comments_count: Any) -> float:
+    views = float(_number(view_count) or 0)
+    subscribers = float(_number(subscriber_count) or 0)
+    comments = float(_number(comments_count) or 0)
+    subscriber_component = (views / subscribers) * 0.7 if subscribers else 0.0
+    comment_component = (comments / views) * 0.3 if views else 0.0
+    return round(subscriber_component + comment_component, 6)
+
+
+def normalize_video_item(item: dict[str, Any]) -> dict[str, Any]:
+    views = _first_value(item, "viewCount", "views", default=0)
+    subscribers = _first_value(item, "numberOfSubscribers", "subscriberCount", "subscribers", default=0)
+    comments = _first_value(item, "commentsCount", "commentCount", "comments", default=0)
+    transcript = extract_transcript(item)
+    return {
+        "video_id": str(_first_value(item, "id", "videoId", default="")),
+        "url": str(_first_value(item, "url", "videoUrl", default="")),
+        "title": str(_first_value(item, "title", default="Sem título")),
+        "channel_name": str(_first_value(item, "channelName", "channelTitle", default="Sem canal")),
+        "channel_url": str(_first_value(item, "channelUrl", default="")),
+        "thumbnail_url": str(_first_value(item, "thumbnailUrl", "thumbnail", default="")),
+        "duration": str(_first_value(item, "duration", "durationText", default="")),
+        "publish_date": str(_first_value(item, "date", "publishedAt", "uploadDate", default="")),
+        "view_count": _number(views),
+        "subscriber_count": _number(subscribers),
+        "comments_count": _number(comments),
+        "vsc_ratio": vsc_ratio(views, subscribers, comments),
+        "transcript": transcript,
+        "transcript_status": "disponível" if transcript else "sem transcrição",
+        "summary": "",
+        "summary_status": "pendente" if transcript else "não aplicável",
+    }
+
+
+def normalize_video_items(items: Iterable[dict[str, Any]]) -> list[dict[str, Any]]:
+    return [normalize_video_item(item) for item in items]

package/app/modules/niche_finder/summarizer.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from typing import Any
+
+import requests
+
+
+DEFAULT_BASE_URLS = {
+    "openai": "https://api.openai.com/v1",
+    "moonshot": "https://api.moonshot.cn/v1",
+    "deepseek": "https://api.deepseek.com/v1",
+    "groq": "https://api.groq.com/openai/v1",
+}
+
+
+class SummarizationError(RuntimeError):
+    """Raised when the configured LLM cannot summarize a transcript."""
+
+
+def _content_value(value: Any) -> str:
+    if isinstance(value, str):
+        return value.strip()
+    if isinstance(value, list):
+        parts: list[str] = []
+        for part in value:
+            if isinstance(part, str):
+                parts.append(part)
+            elif isinstance(part, dict) and isinstance(part.get("text"), str):
+                parts.append(part["text"])
+        return "".join(parts).strip()
+    return ""
+
+
+def summarize_transcript(transcript: str, settings: dict[str, Any], *, timeout: int = 90) -> str:
+    transcript = str(transcript or "").strip()
+    if not transcript:
+        raise SummarizationError("A transcrição está vazia.")
+    provider = str(settings.get("llm_provider", "") or "").strip().lower()
+    api_key = str(settings.get(f"{provider}_api_key", "") or "").strip()
+    base_url = str(settings.get(f"{provider}_base_url", "") or "").strip().rstrip("/")
+    model = str(settings.get(f"{provider}_model_name", "") or "").strip()
+    if provider == "openai":
+        api_key = api_key or str(settings.get("openai_api_key", "") or "").strip()
+        base_url = base_url or str(settings.get("openai_base_url", "") or "").strip().rstrip("/")
+        model = model or str(settings.get("openai_model_name", "") or "").strip()
+    if not base_url:
+        base_url = DEFAULT_BASE_URLS.get(provider, "")
+    if not api_key or not base_url or not model:
+        raise SummarizationError(f"Configure provider, API key, Base URL e modelo para o LLM seleccionado ({provider or 'não definido'}).")
+    endpoint = base_url if base_url.endswith("/chat/completions") else f"{base_url}/chat/completions"
+    system_prompt = (
+        "És um assistente de análise de vídeos. Resume apenas informação presente na transcrição, "
+        "sem inventar, inferir ou acrescentar factos. Responde em português do Brasil e usa exactamente "
+        "esta estrutura: INTRODUÇÃO: um parágrafo sobre como o vídeo começa. ESTRUTURA: uma lista com "
+        "os pontos principais e subpontos da progressão do vídeo."
+    )
+    payload = {
+        "model": model,
+        "temperature": 0.2,
+        "max_tokens": 1200,
+        "messages": [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": transcript[:120000]},
+        ],
+    }
+    try:
+        response = requests.post(
+            endpoint,
+            headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
+            json=payload,
+            timeout=timeout,
+        )
+    except requests.RequestException as exc:
+        raise SummarizationError(f"Não foi possível contactar o provider LLM: {exc}") from exc
+    if response.status_code >= 400:
+        raise SummarizationError(f"O provider LLM devolveu HTTP {response.status_code}: {response.text[:300]}")
+    try:
+        body = response.json()
+    except ValueError as exc:
+        raise SummarizationError("O provider LLM devolveu uma resposta JSON inválida.") from exc
+    choices = body.get("choices") if isinstance(body, dict) else None
+    if not isinstance(choices, list) or not choices:
+        raise SummarizationError("O provider LLM não devolveu escolhas de resposta.")
+    choice = choices[0] if isinstance(choices[0], dict) else {}
+    message = choice.get("message") if isinstance(choice, dict) else {}
+    content = _content_value(message.get("content") if isinstance(message, dict) else "")
+    if not content:
+        raise SummarizationError("O provider LLM devolveu uma resposta sem texto.")
+    return content
+
+
+def summarize_items(items: list[dict[str, Any]], settings: dict[str, Any], *, on_item: Any = None) -> list[dict[str, Any]]:
+    enriched: list[dict[str, Any]] = []
+    for index, item in enumerate(items, start=1):
+        current = dict(item)
+        if current.get("transcript"):
+            try:
+                current["summary"] = summarize_transcript(current["transcript"], settings)
+                current["summary_status"] = "concluído"
+            except SummarizationError as exc:
+                current["summary"] = ""
+                current["summary_status"] = f"erro: {exc}"
+        else:
+            current["summary_status"] = "não aplicável"
+        enriched.append(current)
+        if on_item:
+            on_item(index, len(items), current)
+    return enriched

package/hermes_ui/storage.py

@@ -21,6 +21,7 @@ DEFAULTS: dict[str, Any] = {
     "queues.json": {"niche": [], "blueprint": [], "brand": [], "script": [], "title": [], "thumbnail": [], "video": [], "edit": [], "upload": []},
     "batches.json": [],
     "uploads.json": [],
+    "niche_apify_runs.json": [],
     "metadata_edits.json": [],
     "mcp_server.json": {
         "enabled": False,
@@ -84,6 +85,10 @@ DEFAULTS: dict[str, Any] = {
         "kaggle_username": "",
         "kaggle_api_key": "",
         "kaggle_kernel_slug": "thunderbolt-niche-finder",
+        "apify_api_token": "",
+        "apify_actor_id": "streamers~youtube-scraper",
+        "apify_poll_interval_seconds": 10,
+        "apify_run_timeout_seconds": 900,
         "llm_provider": "moonshot",
         "moonshot_api_key": "",
         "moonshot_base_url": "",

package/package.json

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