@danhachuel/thunderbolt 0.3.71 → 0.3.72

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.3.71
+> **Versão deste manual:** 0.3.72
 > **Pacote npm:** `@danhachuel/thunderbolt`
 > **Porta padrão da UI:** `localhost:3030`  
 > **Repositório:** [github.com/DanHachuel/thunderbolt](https://github.com/DanHachuel/thunderbolt)
@@ -132,13 +132,13 @@ Execute:
 Windows PowerShell ou MobaXterm:
 
 ```powershell
-npx.cmd --yes --prefer-online @danhachuel/thunderbolt@0.3.70 install
+npx.cmd --yes --prefer-online @danhachuel/thunderbolt@0.3.72 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes --prefer-online @danhachuel/thunderbolt@0.3.70 install
+npx --yes --prefer-online @danhachuel/thunderbolt@0.3.72 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.
@@ -146,7 +146,7 @@ A instalação normal é **segura para actualizações**: preserva `storage`, Bl
 Se quiser apagar absolutamente tudo de forma intencional, use o comando destrutivo separado:
 
 ```powershell
-npx.cmd --yes --prefer-online @danhachuel/thunderbolt@0.3.70 install --purge-data
+npx.cmd --yes --prefer-online @danhachuel/thunderbolt@0.3.72 install --purge-data
 ```
 
 O parâmetro `--purge-data` apaga Blueprints, Brandings, configurações, storage e artefactos locais. Não o use numa actualização normal.
@@ -485,7 +485,7 @@ O **Backlog Vídeos** e a lista **Automação > Automação Youtube > Vídeos ca
 
 Nos dois cards, o bloco de estado apresenta o valor técnico, o rótulo legível, a barra de progresso e a mensagem de erro quando existir. O bloco **Formato** resolve nesta ordem `format`, `style_wide`, `style` e, por fim, `wide`, mantendo a apresentação de formatos como `wide`, `shorts`, `music` ou `full_ia` mesmo em tarefas antigas. Em **Automação Youtube > Vídeos cadastrados**, o botão **Start** retoma a partir dos artefactos persistidos: reutiliza roteiro, título/keywords, vídeo, prompt e thumbnail prontos e só executa novamente uma etapa cujo resultado não exista. O botão **Apagar** remove o card da fila depois de confirmação e preserva os ficheiros de artefactos; uma tarefa em execução deve ser parada antes da remoção.
 
-### Upload Música — JewelMusic, Pushtunes e ytmusicapi
+### Upload Música — JewelMusic, Pushtunes, ytmusicapi e DistroKid
 
 A área **Pipeline Música > Upload Música** separa três métodos com contratos diferentes. Em **JewelMusic**, active a integração, introduza a API Key fornecida pelo dashboard da JewelMusic e confirme a Base URL oficial `https://api.jewelmusic.com` e, se necessário, configure proxy e timeout. Carregue ou seleccione um ficheiro de música, indique artista e título e clique em **Enviar música para JewelMusic**. O teste de ligação consulta `/v1/ping`; o upload envia `multipart/form-data` para `/v1/tracks/upload` com os metadados preenchidos.
 
@@ -574,7 +574,7 @@ Ao abrir a página, o Thunderbolt não prepara dados públicos, não descarrega
 
 Os parâmetros da UI são número de clusters entre 2 e 10, suporte mínimo entre 0,01 e 0,50, país, engagement, intervalo de datas e tags, todos dentro da área principal da aba. O núcleo normaliza os dados, calcula engagement, aplica filtros, faz transformação logarítmica e standardização, executa K-Means e calcula itemsets/regras com FP-Growth. Não são apresentados resultados até ao primeiro clique em **Analisar Nichos**; o mesmo botão aplica alterações posteriores aos filtros. Os resultados são DataFrames de clusters, itemsets frequentes, regras de associação e dados analisados; o gráfico de dispersão é criado nativamente com Plotly.
 
-As dependências adicionais — `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub` — são instaladas pelo procedimento normal de `npx`. Em instalações existentes, execute novamente `npx.cmd --yes --prefer-online @danhachuel/thunderbolt@0.3.70 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 --prefer-online @danhachuel/thunderbolt@0.3.72 install`; o instalador detecta e reutiliza o que já estiver válido.
 
 ### Niche Finder Apify
 
@@ -626,9 +626,14 @@ Em **Configurações > Contas Google**, cada conta aparece como um expander iden
 
 Em **Canais Youtube > Canais cadastrados**, a secção **Upload directo — documento da conta deste canal** mostra apenas a conta Google associada e confirma se o documento contém o ID delegado desse canal. O `DELEGATED_SESSION_ID` permanece exclusivamente no mapa do documento; o upload bloqueia a operação se faltar qualquer elemento técnico.
 
+### API Bilibili — várias contas
+A subaba **Configuração API > API Bilibili** fica entre **API Tiktok** e **AI Influencers**. Use **Adicionar nova API** para criar cards separados. Em cada card, preencha um nome, marque **Conta activa no Upload** quando a conta puder ser usada, introduza `SESSDATA`, `bili_jct` e `BUVID3`, e adicione `BUVID4`, `DedeUserID`, `ac_time_value` ou proxy apenas quando necessário. **Testar chamada API** valida a sessão sem criar upload; **Guardar card** persiste a conta e **Apagar card** remove-a. Os cookies são campos protegidos e não aparecem em mensagens, logs ou `uploads.json`.
+
+Em **Upload > Upload convencional**, seleccione **Bilibili** em **Destinos**, escolha a conta activa e preencha os campos apresentados no card do vídeo. O botão **Enviar via bilibili-api (Python)** executa o upload do MP4/MOV/MKV/WEBM, gera uma capa de primeiro frame quando a thumbnail não existe e guarda o resultado localmente. O pacote Python é opcional no import, mas é instalado pelo requirements normal; se a dependência ou a sessão estiverem indisponíveis, o erro identifica a API sem bloquear as restantes redes.
+
 ### Upload-Post
 
-A subaba **Upload-Post** usa a API oficial do [Upload-Post](https://docs.upload-post.com/) para publicar vídeos prontos em uma ou mais plataformas ligadas ao perfil configurado. Em **Configuração API > API Keys > Serviços e modelos > Publicação através do Upload-Post**, active a integração, guarde a API key, o username/perfil e as plataformas padrão. Depois abra **Upload > Upload-Post**, confirme ou altere as plataformas, escreva o título e a descrição e clique em **Enviar vídeo pelo Upload-Post**.
+A subaba **Upload-Post** usa a API oficial do [Upload-Post](https://docs.upload-post.com/) para publicar vídeos prontos em uma ou mais plataformas ligadas ao perfil configurado. Em **Configuração API > API Keys > Serviços e modelos > Publicação através do Upload-Post**, active a integração, guarde a API key, o username/perfil e as plataformas padrão. **Plataformas Upload-Post** é um campo textual; escreva os slugs separados por vírgulas, por exemplo `youtube,tiktok`, exactamente como os destinos seleccionáveis em **Upload > Upload convencional**. Depois abra **Upload > Upload-Post**, confirme ou altere as plataformas, escreva o título e a descrição e clique em **Enviar vídeo pelo Upload-Post**.
 
 A credencial não é duplicada na página de Upload. A integração envia o ficheiro local como `video` em `multipart/form-data`, usa `platform[]` repetido para cada destino e autentica com `Authorization: Apikey ...`. **Processar em segundo plano** envia `async_upload=true`; quando a API devolver `request_id`, este fica visível e é guardado em `uploads.json`. O histórico local também alimenta a notificação **Upload-Post concluído**. O Upload-Post é distinto do Postiz: não usa os endpoints nem a selecção de integrações do Postiz.
 

package/README.md

@@ -18,12 +18,12 @@ A primeira versão implementa a camada UI independente com:
 | Brandings | Subaba própria dentro de Blueprints, upload/listagem de Brandings e criação conjunta com Blueprint |
 | Canais Youtube | Subabas de importação pública sem API Key, Canais em lote gmail por conta Google/YouTube via OAuth e cadastro manual independente; cartões com botão Editar, nicho/referências visível, Prompts do Canal/Blueprint, Narrador/voz e gestão dos últimos 10 vídeos |
 | Criação de Vídeos / Criação de Músicas | Subabas Criar vídeo e Vídeos; idiomas históricos preservados e dez códigos MoneyPrinterTurbo com bandeiras; 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 |
-| Upload Música | Subabas **JewelMusic**, **Pushtunes** e **ytmusicapi** para upload de ficheiros, sincronização de bibliotecas e envio autenticado para YouTube Music; credenciais locais e histórico em `uploads.json` |
+| Upload Música | Subabas **JewelMusic**, **Pushtunes**, **ytmusicapi** e **DistroKid** para upload/sincronização musical com credenciais e histórico locais |
 | Automação | Menu expansível com a subaba **Automação Youtube**, onde ficam os 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 |
 | AI Influencers | Menu expansível com Personagens, Geração de Conteúdo IA, Motion Control, UGC Products e Redes Sociais; Personagens aceita múltiplas imagens e documentos `.md`/`.json`, e os dois workflows standalone guardam os resultados localmente sem Telegram ou publicação social |
 | Niche Finder | Menu expansível com duas alternativas independentes: Niche Finder Kaggle e Niche Finder Apify, com parâmetros, execução e resultados separados |
 | Edição | Menu expansível abaixo de Automação com Limpador de Metadados, Clip Generator local em Cortes e Editor Python inspirado no PYEdit para vídeos e scripts locais |
-| Upload | YouTube via `youtube-automation-agent` adaptado internamente, fallback ordenado API Oficial → Upload directo → Postiz, upload de MP4 para Postiz via API key/MCP configurável, TikTok, Instagram e Facebook Pages no front end |
+| Upload | YouTube via `youtube-automation-agent` adaptado internamente, fallback ordenado API Oficial → Upload directo → Postiz, Upload-Post textual e destinos locais Bilibili/TikTok/Instagram/Facebook Pages |
 | MCP | Catálogo local opcional de Short Video Maker, AutoVio, OpenMontage e OpenCut, com portas editáveis e activação |
 | Configurações | **Contas Google**, **Configuração API** e **Notificações**; Notificações contém as subabas **Geral** e **Telegram Gateway**, com envio das mesmas operações locais para um Chat ID; API Keys divididas entre **Serviços e modelos**, **API Tiktok** e **Fontes de materiais**, com várias chaves independentes por fonte, além de contas Google/YouTube por cartão, `INNERTUBE_API_KEY` global para todas as contas, providers, TTS, Nano Banana, Postiz, TikTok e Upload-Post |
 | Launcher | Execução via `npx`, instalação assistida, diagnóstico e preparação para distribuição |
@@ -54,7 +54,7 @@ Na subaba **Configuração API > API Keys > Imagem e Video**, o selector **Provi
 
 ## API Tiktok — múltiplas aplicações TikTok
 
-A subaba **Configuração API > API Tiktok** fica entre **Contas Google** e **Fontes de Materiais**. Cada aplicação TikTok é apresentada num card separado e contém apenas **TikTok Client ID** e **TikTok Client Secret**, ambos guardados no storage local. O botão **Adicionar nova API** cria cards adicionais; cada card dispõe de **Guardar card**, **Testar chamada API** e **Apagar card**. A autorização OAuth, os scopes e os tokens de publicação continuam fora desta subaba, no fluxo próprio do TikTok for Developers.
+A subaba **Configuração API > API Tiktok** fica entre **Contas Google** e **API Bilibili**. Cada aplicação TikTok é apresentada num card separado e contém apenas **TikTok Client ID** e **TikTok Client Secret**, ambos guardados no storage local. O botão **Adicionar nova API** cria cards adicionais; cada card dispõe de **Guardar card**, **Testar chamada API** e **Apagar card**. A autorização OAuth, os scopes e os tokens de publicação continuam fora desta subaba, no fluxo próprio do TikTok for Developers.
 
 As credenciais antigas dos campos únicos `tiktok_client_key` e `tiktok_client_secret` são migradas automaticamente para o primeiro card sem serem eliminadas. Para compatibilidade com integrações existentes, o adapter TikTok utiliza o primeiro card completo e mantém fallback para os campos legados; a UI não altera os campos pedidos nem mistura Client ID/Secret com tokens, redirect URI ou scopes.
 
@@ -62,19 +62,27 @@ As credenciais antigas dos campos únicos `tiktok_client_key` e `tiktok_client_s
 
 A página **Upload** contém quatro subabas: **Upload convencional**, **Upload directo**, **Postiz** e **Upload-Post**. A quarta alternativa usa a API oficial do [Upload-Post](https://docs.upload-post.com/) para enviar um vídeo local para uma ou mais plataformas ligadas ao perfil configurado. Seleccione as plataformas na própria subaba, confirme o título e a descrição e clique em **Enviar vídeo pelo Upload-Post**.
 
-A API key, o username/perfil e a lista inicial de plataformas continuam em **Configuração API > API Keys > Serviços e modelos**, no expander **Publicação através do Upload-Post**. A subaba não pede novamente a credencial. O cliente envia `multipart/form-data` para `https://api.upload-post.com/api/upload`, repete `platform[]` para cada destino e guarda a resposta, o `request_id` e o resultado no histórico local de uploads. A opção **Processar em segundo plano** usa `async_upload=true` quando a API estiver configurada para processamento assíncrono.
+A API key, o username/perfil e a lista inicial de plataformas continuam em **Configuração API > API Keys > Serviços e modelos**, no expander **Publicação através do Upload-Post**. **Plataformas Upload-Post** é um campo textual: escreva os slugs separados por vírgulas, como `youtube,tiktok`, tal como os destinos da página Upload. A subaba não pede novamente a credencial. O cliente envia `multipart/form-data` para `https://api.upload-post.com/api/upload`, repete `platform[]` para cada destino e guarda a resposta, o `request_id` e o resultado no histórico local de uploads. A opção **Processar em segundo plano** usa `async_upload=true` quando a API estiver configurada para processamento assíncrono.
 
 O Upload-Post é independente do Postiz: Postiz continua a usar o seu fluxo próprio de asset + post, enquanto Upload-Post publica directamente nas plataformas ligadas ao username configurado. Uma publicação aceite pelo Upload-Post também é reconciliada no centro de **Notificações**.
 
-## Upload Música — JewelMusic, Pushtunes e ytmusicapi
+## Bilibili — upload via bilibili-api (Python)
+A opção **Bilibili** está disponível em **Upload > Upload convencional > Destinos**. Seleccione uma conta Bilibili activa, reveja título, descrição, tags e ID da secção, e clique em **Enviar via bilibili-api (Python)**. O adapter usa `bilibili-api-python` 17.4.2, que expõe `Credential` com `SESSDATA`, `bili_jct` e `BUVID3` e executa o `VideoUploader` assíncrono a partir da UI síncrona. A capa usa a thumbnail do vídeo quando existe; caso contrário, é extraído localmente um primeiro frame com FFmpeg.
 
-A página **Upload Música** contém três subabas independentes. **JewelMusic** usa a API documentada do [JewelMusic SDK](https://github.com/jewelmusic/sdk) para enviar tracks com metadados de título, artista, álbum, ano e género; a API key, a Base URL, o proxy opcional e o timeout ficam no storage local. O teste de ligação é read-only e não cria uma track.
+A subaba **Configuração API > API Bilibili**, colocada entre **API Tiktok** e **AI Influencers**, permite criar, editar, testar e apagar vários cards. Cada card guarda label, estado activo, `SESSDATA`, `bili_jct`, `BUVID3` e campos opcionais `BUVID4`, `DedeUserID`, `ac_time_value` e proxy. Os cookies são campos protegidos, não entram no histórico de uploads nem em logs, e o teste de chamada é read-only. O repositório upstream foi arquivado e encerrado em 2026; por isso a integração é opcional e os erros de disponibilidade do SDK são apresentados sem falhar o arranque do Thunderbolt.
+
+## Upload Música — JewelMusic, Pushtunes, ytmusicapi e DistroKid
+
+A página **Upload Música** contém quatro subabas independentes. **JewelMusic** usa a API documentada do [JewelMusic SDK](https://github.com/jewelmusic/sdk) para enviar tracks com metadados de título, artista, álbum, ano e género; a API key, a Base URL, o proxy opcional e o timeout ficam no storage local. O teste de ligação é read-only e não cria uma track.
 
 **Pushtunes** usa o pacote [Pushtunes](https://pypi.org/project/pushtunes/) instalado pelo Thunderbolt para sincronizar tracks, álbuns ou playlists entre uma fonte Subsonic/Jellyfin/CSV/Spotify/YouTube Music e um destino Spotify/YouTube Music/Tidal/CSV. A UI aceita perfil `.toml`, CSV, `browser.json`, `tidal-session.json`, playlist, similaridade, directório de trabalho e credenciais Spotify; a execução chama o CLI sem shell e mascara segredos na saída. Pushtunes é uma sincronização de biblioteca, não um upload de bytes de um MP3 isolado.
 
 **ytmusicapi** adapta o [ytmusicapi](https://github.com/sigma67/ytmusicapi) para upload directo de MP3, M4A, WMA, FLAC ou OGG para YouTube Music. O método exige um `browser.json` configurado pelo utilizador, que pode ser carregado na subaba e guardado em `storage/ytmusicapi/`; o teste consulta a biblioteca de uploads sem escrever. O histórico de cada operação é guardado localmente em `uploads.json` e não inclui o conteúdo dos segredos.
 
-As credenciais destes três métodos são opcionais e independentes das credenciais de vídeo. O instalador acrescenta `ytmusicapi` e `pushtunes`; o adaptador JewelMusic usa o contrato HTTP documentado porque o SDK Python upstream não estava publicado no PyPI no momento da implementação. Consulte `THIRD-PARTY-NOTICES.md` antes de redistribuir o runtime.
+**DistroKid** adapta somente a etapa de upload do [musikai](https://github.com/igolaizola/musikai): recebe várias faixas e uma capa local, abre o formulário de novo lançamento no browser, preenche artista, título, record label, género e títulos das faixas, e carrega os ficheiros. O cookie de sessão é guardado localmente e nunca é mostrado nos resultados. A submissão final permanece manual no browser; o Thunderbolt não clica automaticamente em Submit. O browser pode usar o Chrome instalado ou um executável indicado na configuração.
+
+As credenciais destes quatro métodos são opcionais e independentes das credenciais de vídeo. O instalador acrescenta `ytmusicapi`, `pushtunes`, `bilibili-api-python` e `playwright`; o adaptador JewelMusic usa o contrato HTTP documentado porque o SDK Python upstream não estava publicado no PyPI no momento da implementação. Consulte `THIRD-PARTY-NOTICES.md` antes de redistribuir o runtime.
+
 
 ## Upload directo — credenciais por conta e por canal
 
@@ -99,7 +107,7 @@ No topo da área principal da aplicação existe o menu nativo de idioma no padr
 
 A UI suporta os temas **Dark** e **Light** através do menu nativo de três pontos do Streamlit, no local original do toolbar. Não existe um selector Theme adicional dentro da página. A configuração distribuída em `.streamlit/config.toml` disponibiliza as variantes nomeadas **Dark** e **Light**, e o menu nativo continua responsável por alternar entre os modos, seguindo o padrão do [MoneyPrinterTurbo](https://github.com/harry0703/MoneyPrinterTurbo). O CSS próprio do Thunderbolt usa cores semânticas, `currentColor` e `color-mix` para acompanhar o tema activo, sem alterar a posição nem a funcionalidade do toolbar, do botão Deploy e do menu principal.
 
-## Navegação da UI 0.3.66
+## Navegação da UI 0.3.72
 
 A barra lateral mantém os níveis principais, nesta ordem: **Início**, **Niche Finder**, **Pipeline**, **Pipeline TikTok**, **Automação**, **Edição**, **AI Influencers** e **Configurações**. **Pipeline Vídeos** é expansível e contém **Criação de Vídeos**, **Backlog Vídeos**, **Roteiros**, **Thumbnails** e **Upload**. **Pipeline Música** é expansível e contém **Criação de Músicas** e **Upload Música**. **Automação** também é expansível e contém **Automação Youtube**. **Edição** é expansível e contém **Limpador de Metadados**, **Cortes**, **Editor Python** e **Download Mídia**, nessa ordem. **AI Influencers** é expansível e contém **Personagens**, **Geração de Conteúdo IA**, **Motion Control**, **UGC Products**, **Redes Sociais**, **Tutorial Meta** e **Tutorial Supabase**, nessa ordem. A criação de Motion Control e UGC Products ocorre nas páginas standalone e guarda os artefactos localmente; não existem tabs duplicadas dentro de Geração de Conteúdo IA.
  **Niche Finder** é expansível e contém **Niche Finder Kaggle** e **Niche Finder Apify**. **Configurações** é expansível e contém **Canais Youtube**, **Blueprints Youtube**, **MCP**, **Contas Google**, **Notificações**, **Logs** e **Configuração API**, nessa ordem. O Início reúne o dashboard e as filas do Pipeline, sem botões de acções rápidas.

package/THIRD-PARTY-NOTICES.md

@@ -29,3 +29,12 @@ The JewelMusic upload adapter follows the documented HTTP contract and API examp
 ## supabase-py
 
 Thunderbolt optionally depends on [supabase-py](https://github.com/supabase/supabase-py) for the AI Influencers Supabase backend. The package is distributed under the MIT License. The SQLite backend uses Python's standard library and does not require a remote service.
+
+## bilibili-api-python
+Thunderbolt depends optionally on [bilibili-api-python](https://pypi.org/project/bilibili-api-python/) for the Bilibili video-upload adapter. The package is distributed under the GNU General Public License v3 or later and its upstream repository [Nemo2011/bilibili-api](https://github.com/Nemo2011/bilibili-api) was archived and announced as closed on 2026-07-06. This dependency is separate from Thunderbolt's MIT License; consult the complete upstream licence and use the integration only with accounts and content you are authorised to operate.
+
+## Playwright
+Thunderbolt optionally depends on [Playwright for Python](https://playwright.dev/python/) to open the DistroKid upload form and load local tracks. The adapter does not submit the final form automatically. Playwright's own licence and browser distribution terms remain applicable.
+
+## musikai
+The DistroKid workflow is conceptually adapted from [igolaizola/musikai](https://github.com/igolaizola/musikai), an MIT-licensed Go project. Thunderbolt does not bundle musikai or its Go binaries; only the documented browser-assisted upload concept and metadata flow are adapted.

package/app/main.py

@@ -70,6 +70,8 @@ from integrations.platforms import IntegrationResult, TikTokAdapter, YouTubeAdap
 from integrations.tiktok_public import fetch_public_tiktok_profile, normalize_tiktok_reference
 from integrations.postiz import PostizAdapter
 from integrations.upload_post import UploadPostAdapter, UPLOAD_POST_PLATFORM_OPTIONS, normalize_upload_post_platforms
+from integrations.bilibili_upload import BilibiliApiAdapter, BILIBILI_DEFAULT_TID, BILIBILI_VIDEO_EXTENSIONS, normalise_bilibili_api_cards
+from integrations.distrokid_upload import DistroKidAdapter, DISTROKID_AUDIO_EXTENSIONS, DISTROKID_COVER_EXTENSIONS, close_distrokid_session
 from integrations.music_uploads import JewelMusicAdapter, PushtunesAdapter, YTMusicApiAdapter, MUSIC_UPLOAD_EXTENSIONS, PUSHTUNES_OPERATIONS, PUSHTUNES_SOURCES, PUSHTUNES_TARGETS, YT_MUSIC_UPLOAD_EXTENSIONS
 from integrations.upload_routing import OFFICIAL_DAILY_LIMIT, official_upload_count, upload_with_default_route
 from integrations.youtube_direct_upload import YouTubeDirectUploader
@@ -4099,7 +4101,7 @@ def _render_music_upload_history() -> None:
         record
         for record in read_json("uploads.json", [])
         if isinstance(record, dict)
-        and any(name in str(record.get("destination") or "").lower() for name in ("jewelmusic", "pushtunes", "youtube music", "ytmusicapi"))
+        and any(name in str(record.get("destination") or "").lower() for name in ("jewelmusic", "pushtunes", "youtube music", "ytmusicapi", "distrokid"))
     ]
     st.divider()
     st.subheader("Histórico de uploads de música")
@@ -4283,16 +4285,104 @@ def _render_ytmusicapi_upload_tab() -> None:
         (st.success if result.ok else st.error)(result.message)
 
 
+def _store_distrokid_cover(uploaded: Any) -> str:
+    target_dir = STORAGE / "distrokid"
+    target_dir.mkdir(parents=True, exist_ok=True)
+    safe_name = re.sub(r"[^A-Za-z0-9_.-]+", "_", Path(uploaded.name).name).strip("._") or "cover.jpg"
+    target = target_dir / f"{uuid.uuid4().hex[:10]}_{safe_name}"
+    target.write_bytes(uploaded.getvalue())
+    return str(target)
+
+def _render_distrokid_upload_tab() -> None:
+    st.subheader("DistroKid")
+    st.caption("Upload assistido baseado no fluxo de publish do musikai. O browser preenche o novo lançamento e carrega as faixas; a submissão final fica sempre manual no DistroKid.")
+    settings = read_json("settings.json", {})
+    with st.form("distrokid_settings_form"):
+        enabled = st.checkbox("Activar DistroKid", value=bool(settings.get("distrokid_enabled", False)))
+        cookie = st.text_input("Cookie de sessão DistroKid", value=str(settings.get("distrokid_cookie") or ""), type="password", help="Cole o cabeçalho Cookie da sua sessão DistroKid. O valor é guardado apenas no storage local.")
+        account = st.text_input("Nome da conta DistroKid", value=str(settings.get("distrokid_account") or ""))
+        browser_path = st.text_input("Executável Chrome/Chromium (opcional)", value=str(settings.get("distrokid_browser_path") or ""), help="Deixe vazio para usar Google Chrome; também pode definir THUNDERBOLT_CHROME_PATH.")
+        settings_cols = st.columns(2)
+        with settings_cols[0]:
+            first_name = st.text_input("Primeiro nome", value=str(settings.get("distrokid_first_name") or ""))
+            artist = st.text_input("Artista", value=str(settings.get("distrokid_artist") or ""))
+            release_title = st.text_input("Título do lançamento", value=str(settings.get("distrokid_release_title") or ""))
+        with settings_cols[1]:
+            last_name = st.text_input("Apelido", value=str(settings.get("distrokid_last_name") or ""))
+            record_label = st.text_input("Record label", value=str(settings.get("distrokid_record_label") or ""))
+            genre = st.text_input("Género principal", value=str(settings.get("distrokid_genre") or ""), help="O género deve corresponder a uma opção aceite pelo formulário DistroKid.")
+        save = st.form_submit_button("Guardar configuração DistroKid", type="primary", use_container_width=True)
+    if save:
+        _persist_music_upload_settings({
+            "distrokid_enabled": bool(enabled), "distrokid_cookie": cookie.strip(), "distrokid_account": account.strip(),
+            "distrokid_browser_path": browser_path.strip(), "distrokid_first_name": first_name.strip(), "distrokid_last_name": last_name.strip(),
+            "distrokid_artist": artist.strip(), "distrokid_release_title": release_title.strip(), "distrokid_record_label": record_label.strip(), "distrokid_genre": genre.strip(),
+        })
+        st.success("Configuração DistroKid guardada no storage local.")
+    settings = read_json("settings.json", {})
+    adapter = DistroKidAdapter(settings)
+    status = adapter.status()
+    (st.success if status.ok else st.warning)(status.message)
+    if st.button("Testar sessão DistroKid", key="distrokid_test", use_container_width=True):
+        result = DistroKidAdapter(read_json("settings.json", {})).test_connection()
+        (st.success if result.ok else st.error)(result.message)
+    uploaded_tracks = st.file_uploader("Faixas para o lançamento", type=sorted(extension.lstrip(".") for extension in DISTROKID_AUDIO_EXTENSIONS), accept_multiple_files=True, key="distrokid_track_upload")
+    if uploaded_tracks and st.button("Guardar faixas no storage local", key="distrokid_store_tracks", use_container_width=True):
+        stored_paths: list[str] = []
+        for uploaded in uploaded_tracks:
+            try:
+                stored_paths.append(str(store_music_file(f"distrokid_{uuid.uuid4().hex[:8]}_{uploaded.name}", uploaded.getvalue())))
+            except (OSError, ValueError) as exc:
+                st.error(str(exc))
+        if stored_paths:
+            st.session_state["distrokid_track_paths"] = stored_paths
+            st.success(f"{len(stored_paths)} faixa(s) guardada(s) no storage local.")
+    selected_paths = [str(path) for path in st.session_state.get("distrokid_track_paths", []) if Path(str(path)).is_file()]
+    track_rows: list[dict[str, Any]] = []
+    if selected_paths:
+        st.markdown("**Faixas seleccionadas**")
+        for index, path in enumerate(selected_paths, start=1):
+            track_title = st.text_input(f"Título da faixa {index}", value=Path(path).stem, key=f"distrokid_track_title_{index}")
+            instrumental = st.checkbox("Instrumental", value=False, key=f"distrokid_track_instrumental_{index}")
+            track_rows.append({"path": path, "title": track_title.strip() or Path(path).stem, "instrumental": instrumental})
+    cover_upload = st.file_uploader("Capa do lançamento (opcional)", type=sorted(extension.lstrip(".") for extension in DISTROKID_COVER_EXTENSIONS), key="distrokid_cover_upload")
+    if cover_upload and st.button("Guardar capa no storage local", key="distrokid_store_cover", use_container_width=True):
+        try:
+            st.session_state["distrokid_cover_path"] = _store_distrokid_cover(cover_upload)
+            st.success("Capa guardada no storage local.")
+        except OSError as exc:
+            st.error(f"Não foi possível guardar a capa: {exc}")
+    cover_path = str(st.session_state.get("distrokid_cover_path") or "")
+    if cover_path and Path(cover_path).is_file():
+        st.caption(f"Capa seleccionada: `{cover_path}`")
+    session_id = str(st.session_state.get("distrokid_session_id") or "")
+    if session_id and st.button("Fechar browser DistroKid", key="distrokid_close_browser", use_container_width=True):
+        result = close_distrokid_session(session_id)
+        (st.success if result.ok else st.warning)(result.message)
+        st.session_state.pop("distrokid_session_id", None)
+    if st.button("Abrir formulário e carregar para DistroKid", type="primary", key="distrokid_prepare_upload", use_container_width=True, disabled=not status.ok or not track_rows):
+        current = read_json("settings.json", {})
+        result = DistroKidAdapter(current).prepare_upload(
+            track_rows, artist=str(current.get("distrokid_artist") or ""), release_title=str(current.get("distrokid_release_title") or ""),
+            record_label=str(current.get("distrokid_record_label") or ""), cover_path=cover_path or None, genre=str(current.get("distrokid_genre") or ""),
+        )
+        _record_music_upload("DistroKid", result, music_path=selected_paths[0] if selected_paths else "", target={"service": "DistroKid", "account": str(current.get("distrokid_account") or "")})
+        (st.success if result.ok else st.error)(result.message)
+        if result.ok and result.data.get("session_id"):
+            st.session_state["distrokid_session_id"] = result.data["session_id"]
+
 def render_music_upload() -> None:
     st.title("Upload Música")
-    st.caption("Carregue e encaminhe músicas por JewelMusic, sincronize bibliotecas com Pushtunes ou envie directamente para YouTube Music com ytmusicapi. As credenciais e o histórico permanecem locais.")
-    jewel_tab, pushtunes_tab, ytmusicapi_tab = render_localized_tabs(["JewelMusic", "Pushtunes", "ytmusicapi"])
+    st.caption("Carregue músicas por JewelMusic, sincronize bibliotecas com Pushtunes, envie para YouTube Music com ytmusicapi ou prepare um lançamento DistroKid. As credenciais, browser e histórico permanecem locais.")
+    jewel_tab, pushtunes_tab, ytmusicapi_tab, distrokid_tab = render_localized_tabs(["JewelMusic", "Pushtunes", "ytmusicapi", "DistroKid"])
     with jewel_tab:
         _render_jewelmusic_upload_tab()
     with pushtunes_tab:
         _render_pushtunes_upload_tab()
     with ytmusicapi_tab:
         _render_ytmusicapi_upload_tab()
+    with distrokid_tab:
+        _render_distrokid_upload_tab()
     _render_music_upload_history()
 
 
@@ -4460,6 +4550,7 @@ def render_upload_post():
 
 UPLOAD_DESTINATION_TARGET_KEYS = {
     "TikTok": "tiktok_accounts",
+    "Bilibili": "bilibili_api_cards",
     "Instagram": "instagram_profiles",
     "Facebook Pages": "facebook_pages",
 }
@@ -4491,6 +4582,8 @@ def upload_targets_for_destination(destination: str, channels: list[dict[str, An
     configured_targets = settings.get(setting_key, [])
     if destination == "TikTok" and (not isinstance(configured_targets, list) or not configured_targets):
         configured_targets = settings.get("tiktok_profiles", [])
+    if destination == "Bilibili" and isinstance(configured_targets, list):
+        configured_targets = [item for item in configured_targets if isinstance(item, dict) and bool(item.get("active", True))]
     if not isinstance(configured_targets, list):
         return []
     targets: list[Any] = []
@@ -4505,14 +4598,16 @@ def upload_targets_for_destination(destination: str, channels: list[dict[str, An
 def render_upload_destination_target(destination: str, channels: list[dict[str, Any]], settings: dict[str, Any]) -> Any | None:
     options = upload_targets_for_destination(destination, channels, settings)
     destination_key = re.sub(r"[^a-z0-9]+", "_", destination.lower()).strip("_")
-    select_label = "Canal" if destination == "YouTube" else ("Conta TikTok" if destination == "TikTok" else "Perfil / página")
-    empty_label = "Nenhum canal YouTube cadastrado" if destination == "YouTube" else ("Nenhuma conta TikTok cadastrada" if destination == "TikTok" else f"Nenhum {destination} configurado")
+    select_label = "Canal" if destination == "YouTube" else ("Conta TikTok" if destination == "TikTok" else ("Conta Bilibili" if destination == "Bilibili" else "Perfil / página"))
+    empty_label = "Nenhum canal YouTube cadastrado" if destination == "YouTube" else ("Nenhuma conta TikTok cadastrada" if destination == "TikTok" else ("Nenhuma conta Bilibili activa" if destination == "Bilibili" else f"Nenhum {destination} configurado"))
     if not options:
         st.selectbox(select_label, [empty_label], disabled=True, key=f"upload_target_{destination_key}")
         if destination == "YouTube":
             st.caption("Cadastre ou liste pelo menos um canal YouTube antes de escolher o destino de envio.")
         elif destination == "TikTok":
             st.caption("Cadastre uma conta em Pipeline TikTok > Contas TikTok antes de escolher o destino de envio.")
+        elif destination == "Bilibili":
+            st.caption("Configure e active uma conta em Configuração API > API Bilibili antes de escolher o destino de envio.")
         else:
             st.caption(f"A lista de {destination} será ligada numa etapa própria de credenciais/API.")
         return None
@@ -4533,7 +4628,7 @@ def render_upload_conventional():
     direct_accounts = {str(account.get("id")): account for account in settings.get("youtube_batch_accounts", []) if isinstance(account, dict) and account.get("id")}
     postiz = PostizAdapter(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", "Instagram", "Facebook Pages"], default=["YouTube"], key="upload_destinations", placeholder="Seleccione os destinos")
+    destination = st.multiselect("Destinos", ["YouTube", "TikTok", "Bilibili", "Instagram", "Facebook Pages"], default=["YouTube"], key="upload_destinations", placeholder="Seleccione os destinos")
     upload_targets: dict[str, Any | None] = {}
     if destination:
         st.markdown("**Onde enviar**")
@@ -4654,6 +4749,31 @@ def render_upload_conventional():
                 write_json("uploads.json", uploads)
                 reconcile_persisted_notifications()
                 (st.success if result.ok else st.warning)(result.message)
+            bilibili_target = upload_targets.get("Bilibili") if "Bilibili" in destination else None
+            if "Bilibili" in destination:
+                bilibili_title = st.text_input("Título Bilibili", value=task.get("title") or task.get("topic", "Vídeo Thunderbolt"), key=f"bilibili_title_{task['id']}")
+                bilibili_description = st.text_area("Descrição Bilibili", value=task.get("description", ""), key=f"bilibili_description_{task['id']}", height=90)
+                bilibili_tags = st.text_input("Tags Bilibili separadas por vírgulas", value=task.get("tags", "") if isinstance(task.get("tags", ""), str) else ", ".join(task.get("tags", [])), key=f"bilibili_tags_{task['id']}")
+                bilibili_tid = st.number_input("ID da secção Bilibili", min_value=1, max_value=9999, value=BILIBILI_DEFAULT_TID, step=1, key=f"bilibili_tid_{task['id']}")
+                if st.button("Enviar via bilibili-api (Python)", type="primary", key=f"upload_bilibili_{task['id']}", disabled=not bilibili_target, help="Configure e active uma conta Bilibili em Configuração API > API Bilibili." if not bilibili_target else None):
+                    result = BilibiliApiAdapter(bilibili_target, settings).upload_video(
+                        video_path, title=bilibili_title, description=bilibili_description, tags=bilibili_tags, tid=int(bilibili_tid),
+                        cover_path=thumbnail_path or None,
+                    )
+                    record = {
+                        "task_id": task.get("id"),
+                        "destination": "Bilibili",
+                        "target": upload_target_reference(bilibili_target),
+                        "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)
+                    reconcile_persisted_notifications()
+                    (st.success if result.ok else st.error)(result.message)
             if "Instagram" in destination:
                 st.button("Preparar Instagram", key=f"upload_instagram_{task['id']}", disabled=True, help="UI preparada; publicação Instagram ainda não está activa.")
             if "Facebook Pages" in destination:
@@ -4757,6 +4877,78 @@ def render_tiktok_api_cards(settings: dict[str, Any]) -> None:
         st.rerun()
 
 
+def _persist_bilibili_api_cards(settings: dict[str, Any], cards: list[dict[str, Any]]) -> None:
+    clean_cards: list[dict[str, Any]] = []
+    for item in cards:
+        normalised, _ = normalise_bilibili_api_cards({"bilibili_api_cards": [item]})
+        if normalised:
+            clean_cards.append(normalised[0])
+    settings["bilibili_api_cards"] = clean_cards
+    first = next((card for card in clean_cards if card.get("active") and card.get("sessdata") and card.get("bili_jct") and card.get("buvid3")), clean_cards[0] if clean_cards else {})
+    for field in ("sessdata", "bili_jct", "buvid3", "buvid4", "dedeuserid", "ac_time_value", "proxy"):
+        settings[f"bilibili_{field}"] = str(first.get(field) or "")
+    write_json("settings.json", settings)
+
+def render_bilibili_api_cards(settings: dict[str, Any]) -> None:
+    st.title("API Bilibili")
+    st.caption("Configure várias contas Bilibili em cards separados. O upload usa bilibili-api-python; os cookies permanecem locais e nunca são mostrados em logs, históricos ou metadados.")
+    st.warning("O pacote bilibili-api-python é uma integração opcional e depende da sessão do browser Bilibili. Use apenas contas e conteúdos que tenha autorização para operar.")
+    cards, changed = normalise_bilibili_api_cards(settings)
+    if changed and cards:
+        _persist_bilibili_api_cards(settings, cards)
+    if not cards:
+        st.info("Ainda não existe nenhuma conta Bilibili configurada. Use o botão abaixo para criar o primeiro card.")
+    for index, card in enumerate(cards):
+        card_id = str(card["id"])
+        with st.container(border=True):
+            header_cols = st.columns([3.2, 1.2])
+            with header_cols[0]:
+                st.subheader(str(card.get("label") or f"Conta Bilibili {index + 1}"))
+            with header_cols[1]:
+                configured = bool(card.get("active", True) and card.get("sessdata") and card.get("bili_jct") and card.get("buvid3"))
+                _api_status_badge("Configured" if configured else "Missing configuration", "ready" if configured else "missing")
+            with st.form(f"bilibili_api_card_form_{card_id}"):
+                label = st.text_input("Nome da conta", value=str(card.get("label") or f"Conta Bilibili {index + 1}"), key=f"bilibili_api_{card_id}_label")
+                active = st.checkbox("Conta activa no Upload", value=bool(card.get("active", True)), key=f"bilibili_api_{card_id}_active")
+                credential_cols = st.columns(2)
+                with credential_cols[0]:
+                    sessdata = st.text_input("SESSDATA", value=str(card.get("sessdata") or ""), type="password", key=f"bilibili_api_{card_id}_sessdata")
+                    bili_jct = st.text_input("bili_jct", value=str(card.get("bili_jct") or ""), type="password", key=f"bilibili_api_{card_id}_bili_jct")
+                    buvid3 = st.text_input("BUVID3", value=str(card.get("buvid3") or ""), type="password", key=f"bilibili_api_{card_id}_buvid3")
+                    buvid4 = st.text_input("BUVID4 (opcional)", value=str(card.get("buvid4") or ""), type="password", key=f"bilibili_api_{card_id}_buvid4")
+                with credential_cols[1]:
+                    dedeuserid = st.text_input("DedeUserID (opcional)", value=str(card.get("dedeuserid") or ""), type="password", key=f"bilibili_api_{card_id}_dedeuserid")
+                    ac_time_value = st.text_input("ac_time_value (opcional)", value=str(card.get("ac_time_value") or ""), type="password", key=f"bilibili_api_{card_id}_ac_time_value")
+                    proxy = st.text_input("Proxy opcional", value=str(card.get("proxy") or ""), key=f"bilibili_api_{card_id}_proxy", placeholder="http://127.0.0.1:8080")
+                action_cols = st.columns(3)
+                with action_cols[0]:
+                    test_clicked = st.form_submit_button("Testar chamada API", use_container_width=True)
+                with action_cols[1]:
+                    save_clicked = st.form_submit_button("Guardar card", type="primary", use_container_width=True)
+                with action_cols[2]:
+                    delete_clicked = st.form_submit_button("Apagar card", use_container_width=True)
+            edited = {"id": card_id, "label": label.strip() or f"Conta Bilibili {index + 1}", "active": bool(active), "sessdata": sessdata.strip(), "bili_jct": bili_jct.strip(), "buvid3": buvid3.strip(), "buvid4": buvid4.strip(), "dedeuserid": dedeuserid.strip(), "ac_time_value": ac_time_value.strip(), "proxy": proxy.strip()}
+            if test_clicked:
+                cards[index] = edited
+                _persist_bilibili_api_cards(settings, cards)
+                result = BilibiliApiAdapter(edited, settings).test_connection()
+                (st.success if result.ok else st.error)(result.message)
+            elif save_clicked:
+                cards[index] = edited
+                _persist_bilibili_api_cards(settings, cards)
+                st.success("Card Bilibili guardado.")
+                st.rerun()
+            elif delete_clicked:
+                cards = [item for item in cards if str(item.get("id")) != card_id]
+                _persist_bilibili_api_cards(settings, cards)
+                st.success("Card Bilibili apagado.")
+                st.rerun()
+    if st.button("Adicionar nova API", type="primary", use_container_width=True, key="add_bilibili_api_card"):
+        cards.append({"id": f"bilibili-api-{uuid.uuid4().hex[:10]}", "label": f"Conta Bilibili {len(cards) + 1}", "active": True, "sessdata": "", "bili_jct": "", "buvid3": "", "buvid4": "", "dedeuserid": "", "ac_time_value": "", "proxy": ""})
+        _persist_bilibili_api_cards(settings, cards)
+        st.success("Novo card Bilibili criado.")
+        st.rerun()
+
 def render_google_accounts():
     st.title("Contas Google")
     st.caption("Gestão das contas Google/YouTube, documentos de credenciais, canais em lote e credenciais globais do YouTube.")
@@ -5539,7 +5731,7 @@ def render_settings():
             key=f"settings_{key}",
         )
 
-    api_keys_tab, google_accounts_tab, tiktok_api_tab, ai_influencers_tab, voice_test_tab = render_localized_tabs(["API Keys", "Contas Google", "API Tiktok", "AI Influencers", "Teste de Voz"])
+    api_keys_tab, google_accounts_tab, tiktok_api_tab, bilibili_api_tab, ai_influencers_tab, voice_test_tab = render_localized_tabs(["API Keys", "Contas Google", "API Tiktok", "API Bilibili", "AI Influencers", "Teste de Voz"])
 
     with api_keys_tab:
         with st.container(border=True):
@@ -5697,7 +5889,7 @@ def render_settings():
                     upload_post_api_key = text_setting("Upload-Post API key", "upload_post_api_key", secret=True)
                     _render_credential_status(upload_post_api_key)
                     upload_post_username = text_setting("Upload-Post username", "upload_post_username")
-                    upload_post_platforms = text_setting("Plataformas Upload-Post", "upload_post_platforms")
+                    upload_post_platforms = text_setting("Plataformas Upload-Post", "upload_post_platforms", help_text="Escreva as plataformas separadas por vírgulas, como em Pipeline Vídeos > Upload > Destino. Ex.: youtube,tiktok")
                     upload_post_auto_upload = st.checkbox("Publicar automaticamente após gerar", bool(settings.get("upload_post_auto_upload", False)))
                     _render_api_test_control(
                         settings,
@@ -5762,6 +5954,8 @@ def render_settings():
     with tiktok_api_tab:
         render_tiktok_api_cards(settings)
 
+    with bilibili_api_tab:
+        render_bilibili_api_cards(settings)
     with ai_influencers_tab:
         st.subheader("AI Influencers")
         st.caption("Estado do backend usado por Personagens e Geração de Conteúdo IA. O selector e as credenciais são editados nesta aba, em Banco de Dados Influencers.")

package/integrations/bilibili_upload.py

@@ -0,0 +1,259 @@
+"""Upload de vídeo para Bilibili usando bilibili-api-python.
+
+A biblioteca é opcional no import para que o Thunderbolt continue a arrancar sem
+credenciais Bilibili. As operações do SDK são assíncronas; este adapter expõe uma
+interface síncrona adequada à UI Streamlit e nunca devolve os cookies nos dados.
+"""
+from __future__ import annotations
+
+import asyncio
+import subprocess
+import tempfile
+import threading
+from pathlib import Path
+from typing import Any, Awaitable
+
+from .platforms import IntegrationResult
+
+BILIBILI_VIDEO_EXTENSIONS = {".mp4", ".mov", ".mkv", ".webm"}
+BILIBILI_MAX_TITLE = 80
+BILIBILI_MAX_DESCRIPTION = 2000
+BILIBILI_MAX_TAGS = 10
+BILIBILI_DEFAULT_TID = 130
+BILIBILI_API_VERSION = "17.4.2"
+_SENSITIVE_FIELDS = {"sessdata", "bili_jct", "buvid3", "buvid4", "dedeuserid", "ac_time_value", "proxy"}
+
+
+def _safe_card(card: dict[str, Any], index: int) -> dict[str, Any]:
+    return {
+        "id": str(card.get("id") or f"bilibili-api-{index + 1}").strip(),
+        "label": str(card.get("label") or card.get("name") or f"Conta Bilibili {index + 1}").strip(),
+        "active": bool(card.get("active", True)),
+        "sessdata": str(card.get("sessdata") or "").strip(),
+        "bili_jct": str(card.get("bili_jct") or "").strip(),
+        "buvid3": str(card.get("buvid3") or "").strip(),
+        "buvid4": str(card.get("buvid4") or "").strip(),
+        "dedeuserid": str(card.get("dedeuserid") or "").strip(),
+        "ac_time_value": str(card.get("ac_time_value") or "").strip(),
+        "proxy": str(card.get("proxy") or "").strip(),
+    }
+
+
+def normalise_bilibili_api_cards(settings: dict[str, Any] | None) -> tuple[list[dict[str, Any]], bool]:
+    """Normalise multi-account cards and migrate one legacy settings record."""
+    settings = settings or {}
+    raw = settings.get("bilibili_api_cards")
+    cards: list[dict[str, Any]] = []
+    changed = not isinstance(raw, list)
+    if isinstance(raw, list):
+        for index, item in enumerate(raw):
+            if isinstance(item, dict):
+                card = _safe_card(item, index)
+                cards.append(card)
+                if any(str(item.get(key) or "").strip() != str(card.get(key) or "").strip() for key in card if key not in {"active"}):
+                    changed = True
+            else:
+                changed = True
+    legacy_keys = ("bilibili_sessdata", "bilibili_bili_jct", "bilibili_buvid3", "bilibili_buvid4", "bilibili_dedeuserid", "bilibili_ac_time_value", "bilibili_proxy")
+    legacy_values = {key.removeprefix("bilibili_"): str(settings.get(key) or "").strip() for key in legacy_keys}
+    if not cards and any(legacy_values.values()):
+        cards.append(_safe_card({"id": "bilibili-api-1", "label": "Conta Bilibili 1", **legacy_values}, 0))
+        changed = True
+    return cards, changed
+
+
+def _redacted_card(card: dict[str, Any]) -> dict[str, Any]:
+    return {key: ("***" if key in _SENSITIVE_FIELDS and value else value) for key, value in card.items() if key not in _SENSITIVE_FIELDS or not value}
+
+
+def _safe_card_payload(card: dict[str, Any]) -> dict[str, Any]:
+    return {key: value for key, value in _safe_card(card, 0).items() if key != "id"}
+
+
+def _import_sdk() -> tuple[Any, Any]:
+    try:
+        from bilibili_api import Credential, video_uploader
+    except ImportError as exc:
+        raise RuntimeError("A dependência bilibili-api-python não está instalada. Instale/actualize o Thunderbolt e tente novamente.") from exc
+    return Credential, video_uploader
+
+
+def _run_async(awaitable: Awaitable[Any]) -> Any:
+    """Run one SDK coroutine from Streamlit, including when a loop already exists."""
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(awaitable)
+    result: list[Any] = []
+    error: list[BaseException] = []
+
+    def runner() -> None:
+        try:
+            result.append(asyncio.run(awaitable))
+        except BaseException as exc:  # preserve SDK exception for UI attribution
+            error.append(exc)
+
+    thread = threading.Thread(target=runner, name="thunderbolt-bilibili-sdk", daemon=True)
+    thread.start()
+    thread.join()
+    if error:
+        raise error[0]
+    return result[0] if result else None
+
+
+def _credential(card: dict[str, Any], Credential: Any) -> Any:
+    values = _safe_card_payload(card)
+    values.pop("label", None)
+    values.pop("active", None)
+    values.pop("proxy", None)
+    return Credential(proxy=str(card.get("proxy") or "").strip() or None, **values)
+
+
+def _derive_cover(video_path: Path, directory: Path) -> Path:
+    try:
+        from imageio_ffmpeg import get_ffmpeg_exe
+        executable = get_ffmpeg_exe()
+    except Exception as exc:
+        raise RuntimeError("Não foi possível localizar FFmpeg para criar a capa automática do vídeo Bilibili.") from exc
+    target = directory / "bilibili-cover.jpg"
+    completed = subprocess.run(
+        [executable, "-y", "-hide_banner", "-loglevel", "error", "-ss", "0", "-i", str(video_path), "-frames:v", "1", "-q:v", "3", str(target)],
+        capture_output=True, text=True, timeout=90, check=False,
+    )
+    if completed.returncode != 0 or not target.is_file():
+        raise RuntimeError("FFmpeg não conseguiu criar uma capa a partir do vídeo Bilibili.")
+    return target
+
+def _normalise_tags(tags: str | list[str] | tuple[str, ...] | None) -> list[str]:
+    values = tags if isinstance(tags, (list, tuple)) else str(tags or "").replace("\n", ",").split(",")
+    output: list[str] = []
+    seen: set[str] = set()
+    for value in values:
+        clean = str(value or "").strip()
+        if clean and clean not in seen:
+            output.append(clean)
+            seen.add(clean)
+    return output
+
+
+class BilibiliApiAdapter:
+    """Synchronous wrapper around bilibili-api-python's asynchronous video uploader."""
+
+    def __init__(self, card: dict[str, Any] | None = None, settings: dict[str, Any] | None = None):
+        self.card = _safe_card(card or {}, 0)
+        self.settings = settings or {}
+
+    def status(self) -> IntegrationResult:
+        missing = [field for field in ("sessdata", "bili_jct", "buvid3") if not str(self.card.get(field) or "").strip()]
+        if missing:
+            return IntegrationResult(False, "Conta Bilibili incompleta: configure SESSDATA, bili_jct e BUVID3.", {"missing_fields": missing, "account": self.card.get("label", "Conta Bilibili")})
+        try:
+            _import_sdk()
+        except RuntimeError as exc:
+            return IntegrationResult(False, str(exc), {"account": self.card.get("label", "Conta Bilibili")})
+        return IntegrationResult(True, f"Conta Bilibili pronta: {self.card.get('label', 'Conta Bilibili')}.", {"account": self.card.get("label", "Conta Bilibili"), "sdk": BILIBILI_API_VERSION})
+
+    def test_connection(self) -> IntegrationResult:
+        status = self.status()
+        if not status.ok:
+            return status
+        try:
+            Credential, _ = _import_sdk()
+            credential = _credential(self.card, Credential)
+            valid = _run_async(credential.check_valid())
+            if not bool(valid):
+                return IntegrationResult(False, "A sessão Bilibili foi rejeitada ou expirou. Actualize SESSDATA, bili_jct e BUVID3.", {"account": self.card.get("label", "Conta Bilibili"), "valid": False})
+            return IntegrationResult(True, f"Chamada Bilibili concluída para {self.card.get('label', 'Conta Bilibili')}.", {"account": self.card.get("label", "Conta Bilibili"), "valid": True})
+        except Exception as exc:
+            return IntegrationResult(False, f"A chamada Bilibili falhou: {exc}", {"account": self.card.get("label", "Conta Bilibili"), "api": "bilibili-api-python"})
+
+    def upload_video(
+        self,
+        video_path: str | Path,
+        *,
+        title: str,
+        description: str = "",
+        tags: str | list[str] | tuple[str, ...] | None = None,
+        tid: int = BILIBILI_DEFAULT_TID,
+        cover_path: str | Path | None = None,
+        original: bool = True,
+        dynamic: str = "",
+    ) -> IntegrationResult:
+        status = self.status()
+        if not status.ok:
+            return status
+        path = Path(video_path).expanduser()
+        if not path.is_file():
+            return IntegrationResult(False, f"Vídeo Bilibili não encontrado: {path}", {"api": "bilibili-api-python"})
+        if path.suffix.lower() not in BILIBILI_VIDEO_EXTENSIONS:
+            return IntegrationResult(False, f"Formato Bilibili não suportado: {path.suffix}. Use MP4, MOV, MKV ou WEBM.", {"api": "bilibili-api-python"})
+        clean_title = str(title or "Vídeo Thunderbolt").strip()
+        clean_description = str(description or "").strip()
+        clean_tags = _normalise_tags(tags)
+        if not clean_title or len(clean_title) > BILIBILI_MAX_TITLE:
+            return IntegrationResult(False, "O título Bilibili é obrigatório e deve ter no máximo 80 caracteres.", {"api": "bilibili-api-python"})
+        if len(clean_description) > BILIBILI_MAX_DESCRIPTION:
+            return IntegrationResult(False, "A descrição Bilibili deve ter no máximo 2000 caracteres.", {"api": "bilibili-api-python"})
+        if not clean_tags or len(clean_tags) > BILIBILI_MAX_TAGS:
+            return IntegrationResult(False, "Indique entre 1 e 10 tags Bilibili, separadas por vírgulas.", {"api": "bilibili-api-python"})
+        try:
+            tid_value = int(tid)
+        except (TypeError, ValueError):
+            return IntegrationResult(False, "O ID da secção Bilibili deve ser numérico.", {"api": "bilibili-api-python"})
+        cover = Path(cover_path).expanduser() if cover_path else None
+        if cover is not None and not cover.is_file():
+            return IntegrationResult(False, f"Capa Bilibili não encontrada: {cover}", {"api": "bilibili-api-python"})
+        try:
+            Credential, video_uploader = _import_sdk()
+            credential = _credential(self.card, Credential)
+            page = video_uploader.VideoUploaderPage(str(path), clean_title, clean_description)
+            meta: dict[str, Any] = {
+                "title": clean_title,
+                "copyright": 1 if original else 2,
+                "tid": tid_value,
+                "tag": ",".join(clean_tags),
+                "desc_format_id": 9999,
+                "desc": clean_description,
+                "recreate": -1,
+                "dynamic": str(dynamic or "")[:233],
+                "interactive": 0,
+                "act_reserve_create": 0,
+                "no_disturbance": 0,
+                "no_reprint": 0,
+                "subtitle": {"open": 0, "lan": ""},
+                "dolby": 0,
+                "lossless_music": 0,
+                "web_os": 1,
+            }
+            temporary_cover: tempfile.TemporaryDirectory[str] | None = None
+            if cover is None:
+                temporary_cover = tempfile.TemporaryDirectory(prefix="thunderbolt-bilibili-")
+                cover = _derive_cover(path, Path(temporary_cover.name))
+            try:
+                uploader = video_uploader.VideoUploader([page], meta, credential, cover=str(cover))
+                result = _run_async(uploader.start())
+            finally:
+                if temporary_cover is not None:
+                    temporary_cover.cleanup()
+            payload = result if isinstance(result, dict) else {"response": result}
+            public_data = {key: payload.get(key) for key in ("bvid", "aid", "code", "message") if key in payload}
+            public_data.update({"account": self.card.get("label", "Conta Bilibili"), "api": "bilibili-api-python", "title": clean_title})
+            bvid = str(payload.get("bvid") or "").strip()
+            message = "Upload Bilibili concluído."
+            if bvid:
+                message += f" BVID: {bvid}."
+            return IntegrationResult(True, message, public_data)
+        except Exception as exc:
+            return IntegrationResult(False, f"Upload Bilibili falhou na API bilibili-api-python: {exc}", {"account": self.card.get("label", "Conta Bilibili"), "api": "bilibili-api-python"})
+
+
+__all__ = [
+    "BILIBILI_API_VERSION",
+    "BILIBILI_DEFAULT_TID",
+    "BILIBILI_MAX_DESCRIPTION",
+    "BILIBILI_MAX_TAGS",
+    "BILIBILI_MAX_TITLE",
+    "BILIBILI_VIDEO_EXTENSIONS",
+    "BilibiliApiAdapter",
+    "normalise_bilibili_api_cards",
+]

package/integrations/distrokid_upload.py

@@ -0,0 +1,227 @@
+"""Preparação de uploads DistroKid por browser, inspirada no fluxo do musikai.
+
+O adapter executa apenas a parte de upload/preenchimento do formulário. A
+submissão final fica sempre manual no browser para evitar publicação acidental.
+"""
+from __future__ import annotations
+
+import http.cookies
+import os
+import re
+import uuid
+from pathlib import Path
+from typing import Any
+
+import requests
+
+from .platforms import IntegrationResult
+
+DISTROKID_AUDIO_EXTENSIONS = {".wav", ".mp3", ".flac", ".m4a", ".ogg", ".aac"}
+DISTROKID_COVER_EXTENSIONS = {".jpg", ".jpeg", ".png"}
+DEFAULT_DISTROKID_URL = "https://distrokid.com/new/"
+_LIVE_SESSIONS: dict[str, Any] = {}
+
+
+def _cookie_header_to_context_cookies(cookie_header: str) -> list[dict[str, str]]:
+    jar = http.cookies.SimpleCookie()
+    jar.load(str(cookie_header or ""))
+    return [
+        {"name": morsel.key, "value": morsel.value, "domain": ".distrokid.com", "path": "/"}
+        for morsel in jar.values()
+        if morsel.key and morsel.value
+    ]
+
+
+def _safe_path(value: str | Path | None, allowed: set[str], label: str) -> Path | None:
+    if not value:
+        return None
+    path = Path(value).expanduser()
+    if not path.is_file():
+        raise ValueError(f"{label} não encontrado: {path}")
+    if path.suffix.lower() not in allowed:
+        raise ValueError(f"Formato de {label.lower()} não suportado: {path.suffix}")
+    return path.resolve()
+
+
+def _text(value: Any, maximum: int = 500) -> str:
+    return str(value or "").strip()[:maximum]
+
+
+class DistroKidAdapter:
+    """Preenche a página de novo lançamento DistroKid e carrega as tracks localmente."""
+
+    def __init__(self, settings: dict[str, Any] | None = None):
+        self.settings = settings or {}
+        self.enabled = bool(self.settings.get("distrokid_enabled", False))
+        self.cookie = str(self.settings.get("distrokid_cookie") or "").strip()
+        self.account = _text(self.settings.get("distrokid_account"), 160)
+        self.first_name = _text(self.settings.get("distrokid_first_name"), 120)
+        self.last_name = _text(self.settings.get("distrokid_last_name"), 120)
+        self.record_label = _text(self.settings.get("distrokid_record_label"), 160)
+        self.browser_path = str(self.settings.get("distrokid_browser_path") or os.getenv("THUNDERBOLT_CHROME_PATH") or "").strip()
+        self.base_url = str(self.settings.get("distrokid_url") or DEFAULT_DISTROKID_URL).strip() or DEFAULT_DISTROKID_URL
+
+    def status(self) -> IntegrationResult:
+        if not self.enabled:
+            return IntegrationResult(False, "DistroKid está desactivado nesta configuração.", {})
+        if not self.cookie:
+            return IntegrationResult(False, "Configure o cookie de sessão DistroKid para preencher o formulário de upload.", {"missing_fields": ["distrokid_cookie"]})
+        cookies = _cookie_header_to_context_cookies(self.cookie)
+        if not cookies:
+            return IntegrationResult(False, "O cookie DistroKid não tem um formato válido de cabeçalho Cookie.", {"missing_fields": ["distrokid_cookie"]})
+        return IntegrationResult(True, "DistroKid configurado para upload manual assistido.", {"account": self.account or "Conta DistroKid", "cookies": len(cookies), "manual_submit": True})
+
+    def test_connection(self) -> IntegrationResult:
+        status = self.status()
+        if not status.ok:
+            return status
+        cookie_header = self.cookie
+        try:
+            response = requests.get(
+                self.base_url,
+                headers={"Cookie": cookie_header, "User-Agent": "Mozilla/5.0 Thunderbolt"},
+                timeout=30,
+                allow_redirects=True,
+            )
+        except requests.RequestException as exc:
+            return IntegrationResult(False, f"Não foi possível contactar o DistroKid: {exc}", {"api": "DistroKid web", "account": self.account or "Conta DistroKid"})
+        final_url = str(getattr(response, "url", "") or "")
+        authenticated = response.status_code < 400 and "/login" not in final_url.lower() and "login" not in (response.text or "")[:2000].lower()
+        if not authenticated:
+            return IntegrationResult(False, "A sessão DistroKid foi rejeitada ou expirou. Actualize o cookie no browser e guarde-o novamente.", {"api": "DistroKid web", "status_code": response.status_code, "authenticated": False})
+        return IntegrationResult(True, "Chamada DistroKid concluída; a sessão parece válida.", {"api": "DistroKid web", "status_code": response.status_code, "authenticated": True})
+
+    def prepare_upload(
+        self,
+        tracks: list[dict[str, Any]],
+        *,
+        artist: str,
+        release_title: str,
+        record_label: str = "",
+        cover_path: str | Path | None = None,
+        genre: str = "",
+    ) -> IntegrationResult:
+        """Open DistroKid's form, fill metadata and upload tracks; never submit automatically."""
+        status = self.status()
+        if not status.ok:
+            return status
+        if not tracks:
+            return IntegrationResult(False, "Seleccione pelo menos uma faixa para o upload DistroKid.", {})
+        clean_artist = _text(artist, 160)
+        clean_release_title = _text(release_title, 160)
+        clean_label = _text(record_label or self.record_label, 160)
+        if not clean_artist or not clean_release_title:
+            return IntegrationResult(False, "Artista e título do lançamento são obrigatórios para o upload DistroKid.", {})
+        prepared_tracks: list[dict[str, Any]] = []
+        try:
+            for item in tracks:
+                path = _safe_path(item.get("path"), DISTROKID_AUDIO_EXTENSIONS, "ficheiro de áudio")
+                if path is None:
+                    raise ValueError("Cada faixa DistroKid precisa de um ficheiro de áudio local.")
+                prepared_tracks.append({
+                    "path": path,
+                    "title": _text(item.get("title") or path.stem, 160),
+                    "instrumental": bool(item.get("instrumental", False)),
+                })
+            cover = _safe_path(cover_path, DISTROKID_COVER_EXTENSIONS, "capa")
+        except ValueError as exc:
+            return IntegrationResult(False, str(exc), {"api": "DistroKid web"})
+        try:
+            from playwright.sync_api import TimeoutError as PlaywrightTimeoutError
+            from playwright.sync_api import sync_playwright
+        except ImportError as exc:
+            return IntegrationResult(False, "A dependência Playwright não está instalada; actualize o Thunderbolt para activar o browser DistroKid.", {"api": "DistroKid web"})
+        session_id = f"distrokid-{uuid.uuid4().hex[:12]}"
+        try:
+            playwright = sync_playwright().start()
+            launch_kwargs: dict[str, Any] = {"headless": False}
+            if self.browser_path:
+                launch_kwargs["executable_path"] = self.browser_path
+            else:
+                launch_kwargs["channel"] = "chrome"
+            browser = playwright.chromium.launch(**launch_kwargs)
+            context = browser.new_context(locale="en-US", accept_downloads=True)
+            context.add_cookies(_cookie_header_to_context_cookies(self.cookie))
+            page = context.new_page()
+            page.goto(self.base_url, wait_until="domcontentloaded", timeout=60000)
+            page.wait_for_selector("body", state="visible", timeout=30000)
+            if "/login" in page.url.lower():
+                raise RuntimeError("A sessão DistroKid foi redireccionada para login.")
+            self._fill_form(page, prepared_tracks, clean_artist, clean_release_title, clean_label, cover, _text(genre, 120))
+            _LIVE_SESSIONS[session_id] = {"playwright": playwright, "browser": browser, "context": context, "page": page}
+            return IntegrationResult(True, "Formulário DistroKid aberto e ficheiros carregados. Reveja todos os dados no browser e clique manualmente em Submit.", {"session_id": session_id, "account": self.account or "Conta DistroKid", "tracks": len(prepared_tracks), "manual_submit": True})
+        except Exception as exc:
+            try:
+                playwright.stop()  # type: ignore[name-defined]
+            except Exception:
+                pass
+            if exc.__class__.__name__ == "Error" or "executable" in str(exc).lower() or "browser" in str(exc).lower():
+                return IntegrationResult(False, f"Não foi possível abrir o browser DistroKid: {exc}", {"api": "DistroKid web"})
+            if "Timeout" in exc.__class__.__name__ or "timeout" in str(exc).lower():
+                return IntegrationResult(False, f"O DistroKid não carregou o formulário a tempo: {exc}", {"api": "DistroKid web"})
+            return IntegrationResult(False, f"Upload DistroKid falhou: {exc}", {"api": "DistroKid web"})
+
+    @staticmethod
+    def _fill_form(page: Any, tracks: list[dict[str, Any]], artist: str, release_title: str, record_label: str, cover: Path | None, genre: str) -> None:
+        try:
+            page.locator("#sitetran_select").select_option("en", timeout=5000)
+        except Exception:
+            pass
+        page.locator("#artistName").fill(artist)
+        if record_label:
+            try:
+                page.locator("#recordLabel").select_option(label=record_label, timeout=8000)
+            except Exception:
+                try:
+                    page.locator("#recordLabel").select_option(record_label, timeout=5000)
+                except Exception:
+                    pass
+        try:
+            page.locator("#howManySongsOnThisAlbum").select_option(str(len(tracks)), timeout=15000)
+        except Exception:
+            pass
+        page.wait_for_timeout(1000)
+        if cover is not None:
+            page.locator("#artwork").set_input_files(str(cover), timeout=15000)
+            try:
+                page.locator("img.artworkPreview").wait_for(state="visible", timeout=30000)
+            except Exception:
+                pass
+        track_nodes = page.locator("input[name^='tracknum_']")
+        count = track_nodes.count()
+        if count < len(tracks):
+            raise RuntimeError(f"O DistroKid apresentou {count} campos de faixa, mas foram seleccionadas {len(tracks)}.")
+        for index, track in enumerate(tracks, start=1):
+            track_id = track_nodes.nth(index - 1).get_attribute("id") or ""
+            track_id = re.sub(r"^tracknum_", "", track_id)
+            if not track_id:
+                raise RuntimeError(f"Não foi possível encontrar o identificador da faixa {index}.")
+            page.locator(f"#title_{track_id}").fill(track["title"])
+            page.locator(f"#js-track-upload-{index}").set_input_files(str(track["path"]), timeout=30000)
+            page.locator(f"#showFilename_{index}").wait_for(state="visible", timeout=120000)
+        if len(tracks) > 1:
+            try:
+                page.locator("#albumTitleInput").fill(release_title)
+            except Exception:
+                pass
+        if genre:
+            try:
+                page.locator("#genrePrimary").select_option(label=genre, timeout=5000)
+            except Exception:
+                pass
+
+
+def close_distrokid_session(session_id: str) -> IntegrationResult:
+    session = _LIVE_SESSIONS.pop(str(session_id), None)
+    if not session:
+        return IntegrationResult(False, "Sessão DistroKid não encontrada ou já encerrada.", {})
+    try:
+        session["context"].close()
+        session["browser"].close()
+        session["playwright"].stop()
+    except Exception as exc:
+        return IntegrationResult(False, f"A sessão DistroKid foi fechada com aviso: {exc}", {"session_id": session_id})
+    return IntegrationResult(True, "Sessão DistroKid fechada.", {"session_id": session_id})
+
+
+__all__ = ["DEFAULT_DISTROKID_URL", "DISTROKID_AUDIO_EXTENSIONS", "DISTROKID_COVER_EXTENSIONS", "DistroKidAdapter", "close_distrokid_session"]

package/package.json

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

package/requirements.txt

@@ -17,3 +17,5 @@ pushtunes>=2.15,<3
 matplotlib>=3.7,<4
 kagglehub>=0.3,<1
 supabase>=2.4,<3
+bilibili-api-python>=17.4,<18
+playwright>=1.45,<2