@danhachuel/thunderbolt 0.4.51 → 0.4.53

package/app/main.py

@@ -1907,30 +1907,26 @@ def render_tiktok_channels():
                         current_prompt = str(channel.get("default_prompt_master") or channel.get("prompt_master") or "")
                         selected_prompt = st.selectbox("Prompt Master", prompt_ids, index=prompt_ids.index(current_prompt) if current_prompt in prompt_ids else 0, format_func=lambda item: prompt_labels.get(item, item), key=f"tiktok_import_card_prompt_{channel_id}")
                     with card_cols[5]:
-                        st.caption("Formato")
-                        st.write("Portrait 9:16")
-                        if st.button("Guardar", key=f"tiktok_import_card_save_{channel_id}", use_container_width=True, type="primary"):
-                            update_channel(channel_id, {"platform": "tiktok", "default_prompt_master": selected_prompt, "prompt_master": selected_prompt, "video_aspect_ratio": "Portrait 9:16", "style_wide": "portrait"})
-                            st.success("Prompt Master do canal guardado.")
-                            st.rerun()
-                    actions = st.columns([1.0, 1.0, 1.0, 1.0])
-                    with actions[0]:
                         active = st.toggle("Activo", value=bool(channel.get("active", True)), key=f"tiktok_import_card_active_{channel_id}")
                         if active != bool(channel.get("active", True)):
                             update_channel(channel_id, {"active": active})
                             st.rerun()
-                    with actions[1]:
                         if st.button("Editar", key=f"tiktok_import_card_edit_{channel_id}"):
                             st.session_state[f"tiktok_edit_{channel_id}"] = not st.session_state.get(f"tiktok_edit_{channel_id}", False)
                             st.rerun()
-                    with actions[2]:
-                        if st.button("Editar nicho", key=f"tiktok_import_card_niche_{channel_id}"):
-                            st.session_state[f"tiktok_niche_{channel_id}"] = not st.session_state.get(f"tiktok_niche_{channel_id}", False)
-                            st.rerun()
-                    with actions[3]:
                         if st.button("Apagar card", key=f"tiktok_import_card_delete_{channel_id}"):
                             st.session_state[f"tiktok_delete_{channel_id}"] = True
                             st.rerun()
+                        st.caption("Formato: Portrait 9:16")
+                        if st.button("Guardar", key=f"tiktok_import_card_save_{channel_id}", use_container_width=True, type="primary"):
+                            update_channel(channel_id, {"platform": "tiktok", "default_prompt_master": selected_prompt, "prompt_master": selected_prompt, "video_aspect_ratio": "Portrait 9:16", "style_wide": "portrait"})
+                            st.success("Prompt Master do canal guardado.")
+                            st.rerun()
+                    niche_action = st.columns([1.0, 4.0])
+                    with niche_action[0]:
+                        if st.button("Editar nicho", key=f"tiktok_import_card_niche_{channel_id}"):
+                            st.session_state[f"tiktok_niche_{channel_id}"] = not st.session_state.get(f"tiktok_niche_{channel_id}", False)
+                            st.rerun()
                     if st.session_state.get(f"tiktok_delete_{channel_id}"):
                         st.warning("Apagar este canal TikTok e os dados locais associados?")
                         confirm_cols = st.columns(2)
@@ -6813,7 +6809,7 @@ def render_settings():
             key=f"settings_{key}",
         )
 
-    api_keys_tab, upload_api_keys_tab, google_accounts_tab, tiktok_api_tab, bilibili_api_tab, ai_influencers_tab, voice_test_tab = render_localized_tabs(["API Keys", "API Keys Upload", "Contas Google", "API Tiktok", "API Bilibili", "AI Influencers", "Teste de Voz"])
+    api_keys_tab, upload_api_keys_tab, ai_influencers_tab, voice_test_tab = render_localized_tabs(["API Keys", "API Keys Upload", "AI Influencers", "Teste de Voz"])
 
     with api_keys_tab:
         with st.container(border=True):
@@ -7002,41 +6998,18 @@ def render_settings():
                             persist_callback=save_google_lyria,
                         )
 
-                with st.expander("Upload-Post", expanded=False):
-                    upload_post_enabled = st.checkbox("Activar Upload-Post", bool(settings.get("upload_post_enabled", False)))
-                    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", 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,
-                        "upload_post",
-                        lambda: test_upload_post_credentials(upload_post_api_key, settings.get("upload_post_base_url", "https://api.upload-post.com/api")),
-                        widget_key="api_test_upload_post",
-                    )
-
-                with st.expander("Postiz", expanded=False):
-                    st.caption("O Thunderbolt é o cliente. A API key é enviada exclusivamente ao servidor Postiz configurado; não é colocada em URLs, logs ou repositório.")
-                    postiz_enabled = st.checkbox("Activar Postiz como fallback final", bool(settings.get("postiz_enabled", False)))
-                    postiz_mode = st.selectbox("Modo de ligação", ["api", "mcp"], index=0 if settings.get("postiz_mode", "api") != "mcp" else 1, help="API é o modo determinístico de upload. MCP fica disponível para uma ligação compatível com Streamable HTTP.")
-                    postiz_cols = st.columns(2)
-                    with postiz_cols[0]:
-                        postiz_api_key = text_setting("Postiz API key", "postiz_api_key", secret=True, help_text="API key criada nas definições do Postiz. A API HTTP usa o valor bruto no cabeçalho Authorization.")
-                        _render_credential_status(postiz_api_key)
-                        postiz_base_url = text_setting("Postiz Public API Base URL", "postiz_base_url", help_text="Cloud: https://api.postiz.com/public/v1 · Self-hosted: https://seu-servidor/api/public/v1")
-                        postiz_integration_id = text_setting("Postiz integração padrão", "postiz_integration_id", help_text="ID do canal/integração devolvido por GET /integrations.")
-                    with postiz_cols[1]:
-                        postiz_mcp_url = text_setting("Postiz MCP URL", "postiz_mcp_url", help_text="Cloud: https://api.postiz.com/mcp · o cliente acrescenta a API key conforme o modo escolhido.")
-                        postiz_auto_publish = st.checkbox("Permitir publicação imediata no Postiz", bool(settings.get("postiz_auto_publish", False)))
-                    st.caption("No Upload, a aba Postiz permite carregar as integrações e enviar vídeos manualmente. No fluxo recomendado, Postiz só é tentado depois da API Oficial e do Upload directo.")
-                    _render_api_test_control(
-                        settings,
-                        "postiz",
-                        lambda: test_postiz_credentials(postiz_api_key, postiz_base_url),
-                        widget_key="api_test_postiz",
-                    )
-
+                upload_post_enabled = bool(settings.get("upload_post_enabled", False))
+                upload_post_api_key = str(settings.get("upload_post_api_key") or "")
+                upload_post_username = str(settings.get("upload_post_username") or "")
+                upload_post_platforms = str(settings.get("upload_post_platforms") or "youtube,tiktok")
+                upload_post_auto_upload = bool(settings.get("upload_post_auto_upload", False))
+                postiz_enabled = bool(settings.get("postiz_enabled", False))
+                postiz_api_key = str(settings.get("postiz_api_key") or "")
+                postiz_base_url = str(settings.get("postiz_base_url") or "https://api.postiz.com/public/v1")
+                postiz_mcp_url = str(settings.get("postiz_mcp_url") or "https://api.postiz.com/mcp")
+                postiz_mode = str(settings.get("postiz_mode") or "api")
+                postiz_integration_id = str(settings.get("postiz_integration_id") or "")
+                postiz_auto_publish = bool(settings.get("postiz_auto_publish", False))
                 save_all_settings = st.form_submit_button("Guardar configurações do Thunderbolt", type="primary")
                 if save_all_settings:
                     settings.update({
@@ -7071,13 +7044,7 @@ def render_settings():
         st.subheader("API Keys Upload")
         st.caption("Credenciais e integrações utilizadas pelos fluxos de publicação. Cada grupo fica separado para evitar misturar chaves de geração com chaves de upload.")
         with st.expander("Contas Google", expanded=False):
-            google_accounts = [item for item in settings.get("youtube_batch_accounts", []) if isinstance(item, dict) and item.get("id")]
-            if google_accounts:
-                for account in google_accounts:
-                    st.markdown(f"**{account.get('label') or 'Conta Google'}** — {account.get('email') or 'sem e-mail'}")
-                st.info("Para editar documentos de cookies, OAuth e canais associados, abra a subaba Contas Google.")
-            else:
-                st.info("Ainda não existem Contas Google configuradas.")
+            render_google_accounts()
         with st.expander("API Innertube", expanded=False):
             st.caption("INNERTUBE_API_KEY global usada pelo Upload directo para todas as contas Google/YouTube.")
             upload_innertube = st.text_input("INNERTUBE_API_KEY", value=str(settings.get("direct_innertube_api_key") or settings.get("INNERTUBE_API_KEY") or ""), type="password", key="upload_api_innertube_key")
@@ -7116,16 +7083,6 @@ def render_settings():
                 write_json("settings.json", settings)
                 st.success("Postiz guardado.")
                 st.rerun()
-    with google_accounts_tab:
-        render_google_accounts()
-
-    with tiktok_api_tab:
-        st.subheader("API Tiktok")
-        st.info("A configuração desta API foi reorganizada em Configuração API > API Keys Upload > API Tiktok.")
-
-    with bilibili_api_tab:
-        st.subheader("API Bilibili")
-        st.info("A configuração desta API foi reorganizada em Configuração API > API Keys Upload > API Bilibili.")
     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/package.json

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