@danhachuel/thunderbolt 0.4.48 → 0.4.50

package/app/main.py

@@ -1913,6 +1913,70 @@ def render_tiktok_channels():
                             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}", use_container_width=True):
+                            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}", use_container_width=True):
+                            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}", use_container_width=True):
+                            st.session_state[f"tiktok_delete_{channel_id}"] = True
+                            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)
+                        with confirm_cols[0]:
+                            if st.button("Confirmar apagar", type="primary", key=f"tiktok_confirm_delete_{channel_id}"):
+                                delete_channel(channel_id)
+                                st.session_state.pop(f"tiktok_delete_{channel_id}", None)
+                                st.rerun()
+                        with confirm_cols[1]:
+                            if st.button("Cancelar", key=f"tiktok_cancel_delete_{channel_id}"):
+                                st.session_state.pop(f"tiktok_delete_{channel_id}", None)
+                                st.rerun()
+                    if st.session_state.get(f"tiktok_niche_{channel_id}"):
+                        with st.form(f"tiktok_niche_form_{channel_id}"):
+                            niche_value = st.text_input("Nicho do canal", value=str(channel.get("niche") or ""))
+                            if st.form_submit_button("Guardar nicho", type="primary"):
+                                update_channel(channel_id, {"niche": niche_value.strip(), "reference_channels": [niche_value.strip()] if niche_value.strip() else []})
+                                st.session_state.pop(f"tiktok_niche_{channel_id}", None)
+                                st.rerun()
+                    if st.session_state.get(f"tiktok_edit_{channel_id}"):
+                        with st.form(f"tiktok_edit_form_{channel_id}"):
+                            edit_name = st.text_input("Nome do canal", value=str(channel.get("name") or ""))
+                            edit_url = st.text_input("URL pública", value=str(channel.get("url") or ""))
+                            edit_handle = st.text_input("Handle", value=str(channel.get("handle") or ""))
+                            edit_language = st.selectbox("Idioma do canal", list(LANGUAGE_CODES), index=list(LANGUAGE_CODES).index(language_code(channel.get("language") or "pt")), format_func=language_label)
+                            edit_description = st.text_area("Descrição", value=str(channel.get("description") or ""))
+                            if st.form_submit_button("Guardar edição", type="primary"):
+                                update_channel(channel_id, {"name": edit_name.strip(), "url": edit_url.strip(), "handle": edit_handle.strip(), "language": edit_language, "description": edit_description.strip(), "platform": "tiktok"})
+                                st.session_state.pop(f"tiktok_edit_{channel_id}", None)
+                                st.rerun()
+                    with st.expander("Últimos 10 vídeos publicados", expanded=False):
+                        recent_videos = channel_videos_for(channel, limit=10)
+                        if not recent_videos:
+                            st.info("Ainda não existem vídeos públicos sincronizados para este canal TikTok.")
+                        for recent_video in recent_videos[:10]:
+                            video_cols = st.columns([0.7, 3.5, 1.2])
+                            with video_cols[0]:
+                                if recent_video.get("thumbnail_url"):
+                                    st.image(recent_video["thumbnail_url"], width=64)
+                                else:
+                                    st.markdown("### TT")
+                            with video_cols[1]:
+                                st.write(f"**{recent_video.get('title') or 'Vídeo sem título'}**")
+                                st.caption(f"{recent_video.get('published_at') or 'Sem data'} · {recent_video.get('url') or 'Sem URL'}")
+                            with video_cols[2]:
+                                st.caption(str(recent_video.get("status") or "publicado").title())
         else:
             st.info("Ainda não existem canais TikTok cadastrados. Use o campo abaixo para pesquisar e cadastrar um perfil público.")
         st.divider()
@@ -6749,7 +6813,7 @@ def render_settings():
             key=f"settings_{key}",
         )
 
-    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"])
+    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"])
 
     with api_keys_tab:
         with st.container(border=True):
@@ -6938,7 +7002,7 @@ def render_settings():
                             persist_callback=save_google_lyria,
                         )
 
-                with st.expander("Publicação através do Upload-Post", expanded=False):
+                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)
@@ -6952,7 +7016,7 @@ def render_settings():
                         widget_key="api_test_upload_post",
                     )
 
-                with st.expander("Postiz — API key, integração e MCP", expanded=False):
+                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.")
@@ -7003,14 +7067,65 @@ def render_settings():
                             st.success("Configurações guardadas localmente. Indique uma pasta válida do motor de vídeo para sincronizar config.toml.")
                     except Exception as exc:
                         st.warning(f"Configurações locais guardadas, mas não foi possível sincronizar config.toml: {exc}")
+    with upload_api_keys_tab:
+        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.")
+        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")
+            if st.button("Guardar INNERTUBE_API_KEY", type="primary", use_container_width=True, key="upload_save_innertube"):
+                settings["direct_innertube_api_key"] = upload_innertube.strip()
+                settings.pop("INNERTUBE_API_KEY", None)
+                write_json("settings.json", settings)
+                st.success("INNERTUBE_API_KEY guardada.")
+                st.rerun()
+        with st.expander("API Tiktok", expanded=False):
+            render_tiktok_api_cards(settings)
+        with st.expander("API Bilibili", expanded=False):
+            render_bilibili_api_cards(settings)
+        with st.expander("Composio", expanded=False):
+            st.info("Secção reservada para uma futura integração Composio.")
+        with st.expander("Upload-Post", expanded=False):
+            upload_post_enabled_upload = st.checkbox("Activar Upload-Post", bool(settings.get("upload_post_enabled", False)), key="upload_tab_upload_post_enabled")
+            upload_post_key_upload = st.text_input("Upload-Post API key", value=str(settings.get("upload_post_api_key") or ""), type="password", key="upload_tab_upload_post_key")
+            upload_post_user_upload = st.text_input("Upload-Post username", value=str(settings.get("upload_post_username") or ""), key="upload_tab_upload_post_user")
+            upload_post_platforms_upload = st.text_input("Plataformas Upload-Post", value=str(settings.get("upload_post_platforms") or "youtube,tiktok"), key="upload_tab_upload_post_platforms")
+            upload_post_auto_upload = st.checkbox("Publicar automaticamente após gerar", bool(settings.get("upload_post_auto_upload", False)), key="upload_tab_upload_post_auto")
+            if st.button("Guardar Upload-Post", type="primary", use_container_width=True, key="upload_tab_save_upload_post"):
+                settings.update({"upload_post_enabled": bool(upload_post_enabled_upload), "upload_post_api_key": upload_post_key_upload.strip(), "upload_post_username": upload_post_user_upload.strip(), "upload_post_platforms": upload_post_platforms_upload.strip(), "upload_post_auto_upload": bool(upload_post_auto_upload)})
+                write_json("settings.json", settings)
+                st.success("Upload-Post guardado.")
+                st.rerun()
+        with st.expander("Postiz", expanded=False):
+            postiz_enabled_upload = st.checkbox("Activar Postiz como fallback final", bool(settings.get("postiz_enabled", False)), key="upload_tab_postiz_enabled")
+            postiz_key_upload = st.text_input("Postiz API key", value=str(settings.get("postiz_api_key") or ""), type="password", key="upload_tab_postiz_key")
+            postiz_base_upload = st.text_input("Postiz Public API Base URL", value=str(settings.get("postiz_base_url") or "https://api.postiz.com/public/v1"), key="upload_tab_postiz_base")
+            postiz_mcp_upload = st.text_input("Postiz MCP URL", value=str(settings.get("postiz_mcp_url") or "https://api.postiz.com/mcp"), key="upload_tab_postiz_mcp")
+            postiz_integration_upload = st.text_input("Postiz integração padrão", value=str(settings.get("postiz_integration_id") or ""), key="upload_tab_postiz_integration")
+            postiz_auto_upload = st.checkbox("Permitir publicação imediata no Postiz", bool(settings.get("postiz_auto_publish", False)), key="upload_tab_postiz_auto")
+            if st.button("Guardar Postiz", type="primary", use_container_width=True, key="upload_tab_save_postiz"):
+                settings.update({"postiz_enabled": bool(postiz_enabled_upload), "postiz_api_key": postiz_key_upload.strip(), "postiz_base_url": postiz_base_upload.strip(), "postiz_mcp_url": postiz_mcp_upload.strip(), "postiz_integration_id": postiz_integration_upload.strip(), "postiz_auto_publish": bool(postiz_auto_upload)})
+                write_json("settings.json", settings)
+                st.success("Postiz guardado.")
+                st.rerun()
     with google_accounts_tab:
         render_google_accounts()
 
     with tiktok_api_tab:
-        render_tiktok_api_cards(settings)
+        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:
-        render_bilibili_api_cards(settings)
+        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.48",
+  "version": "0.4.50",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "license": "MIT",
   "main": "scripts/cli.mjs",