@danhachuel/thunderbolt 0.2.66 → 0.2.68

package/app/main.py

@@ -40,6 +40,7 @@ from hermes_ui.voice_preview import DEFAULT_SAMPLE, load_preview_file, synthesiz
 from hermes_ui.thumbnail_generation import ThumbnailGenerationError, generate_thumbnail_image
 from hermes_ui.creative_generation import CreativeGenerationError, generate_creative_package, generate_topic_for_channel
 from integrations.platforms import IntegrationResult, TikTokAdapter, YouTubeAdapter, fetch_channel_videos_public
+from integrations.tiktok_public import fetch_public_tiktok_profile, normalize_tiktok_reference
 from integrations.postiz import PostizAdapter
 from integrations.upload_routing import OFFICIAL_DAILY_LIMIT, official_upload_count, upload_with_default_route
 from integrations.youtube_direct_upload import YouTubeDirectUploader
@@ -754,6 +755,159 @@ def render_blueprints():
                     st.error(str(exc))
 
 
+def _tiktok_accounts_from_settings(settings: dict[str, Any]) -> list[dict[str, Any]]:
+    raw_accounts = settings.get("tiktok_accounts")
+    if not isinstance(raw_accounts, list) or not raw_accounts:
+        raw_accounts = settings.get("tiktok_profiles", [])
+    if not isinstance(raw_accounts, list):
+        return []
+    accounts: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    for raw in raw_accounts:
+        if not isinstance(raw, dict):
+            continue
+        try:
+            reference = normalize_tiktok_reference(str(raw.get("url") or raw.get("handle") or raw.get("username") or raw.get("id") or ""))
+        except ValueError:
+            continue
+        account = {**raw, **reference}
+        account["name"] = str(raw.get("name") or raw.get("label") or reference["username"]).strip()
+        account["bio"] = str(raw.get("bio") or raw.get("description") or "").strip()
+        account["source"] = str(raw.get("source") or raw.get("origin") or "manual").strip()
+        key = account["id"]
+        if key in seen:
+            continue
+        seen.add(key)
+        accounts.append(account)
+    return accounts
+
+
+def _save_tiktok_accounts(accounts: list[dict[str, Any]]) -> None:
+    settings = read_json("settings.json", {})
+    settings["tiktok_accounts"] = accounts
+    write_json("settings.json", settings)
+
+
+def _upsert_tiktok_account(account: dict[str, Any]) -> tuple[list[dict[str, Any]], bool]:
+    settings = read_json("settings.json", {})
+    accounts = _tiktok_accounts_from_settings(settings)
+    normalized = normalize_tiktok_reference(str(account.get("url") or account.get("handle") or account.get("username") or ""))
+    merged = {**account, **normalized}
+    merged["name"] = str(account.get("name") or normalized["username"]).strip() or normalized["username"]
+    existing_index = next((index for index, item in enumerate(accounts) if item.get("id") == normalized["id"] or item.get("username") == normalized["username"]), None)
+    created = existing_index is None
+    if existing_index is None:
+        accounts.append(merged)
+    else:
+        accounts[existing_index] = {**accounts[existing_index], **merged}
+    _save_tiktok_accounts(accounts)
+    return accounts, created
+
+
+def _tiktok_account_metric(account: dict[str, Any], key: str, label: str) -> str:
+    value = account.get(key)
+    return f"{label}: {value:,}" if isinstance(value, int) else f"{label}: —"
+
+
+def render_tiktok_accounts():
+    st.title("Contas TikTok")
+    st.caption("Pesquisa pública e cadastro manual de contas TikTok para alimentar o selector de destino no Upload. Esta área não usa OAuth, API de publicação nem lote.")
+    settings = read_json("settings.json", {})
+    accounts = _tiktok_accounts_from_settings(settings)
+
+    search_tab, manual_tab, library_tab = st.tabs(["Pesquisa pública", "Cadastro manual", "Contas cadastradas"])
+    with search_tab:
+        st.subheader("Pesquisar perfil público")
+        st.info("A pesquisa consulta apenas a página pública do perfil e pode devolver dados incompletos. Se o TikTok bloquear a consulta, utilize o cadastro manual.")
+        with st.form("tiktok_public_lookup_form"):
+            lookup_source = st.text_input("URL pública ou @handle", placeholder="https://www.tiktok.com/@conta ou @conta", key="tiktok_public_lookup_source")
+            lookup_submitted = st.form_submit_button("Pesquisar perfil público", type="primary", use_container_width=True)
+        if lookup_submitted:
+            result = fetch_public_tiktok_profile(lookup_source)
+            st.session_state["tiktok_public_lookup"] = {"ok": result.ok, "message": result.message, "data": result.data}
+            (st.success if result.ok else st.warning)(result.message)
+        lookup = st.session_state.get("tiktok_public_lookup", {})
+        lookup_data = lookup.get("data") if isinstance(lookup, dict) else None
+        if isinstance(lookup_data, dict) and lookup_data.get("url"):
+            with st.container(border=True):
+                st.subheader(str(lookup_data.get("name") or lookup_data.get("handle") or "Perfil TikTok"))
+                st.caption(f"{lookup_data.get('handle', '')} · {lookup_data.get('public_url') or lookup_data.get('url')}")
+                if lookup_data.get("bio"):
+                    st.write(lookup_data["bio"])
+                metric_cols = st.columns(4)
+                with metric_cols[0]: st.metric("Seguidores", lookup_data.get("subscriber_count") if lookup_data.get("subscriber_count") is not None else "—")
+                with metric_cols[1]: st.metric("Seguindo", lookup_data.get("following_count") if lookup_data.get("following_count") is not None else "—")
+                with metric_cols[2]: st.metric("Gostos", lookup_data.get("likes_count") if lookup_data.get("likes_count") is not None else "—")
+                with metric_cols[3]: st.metric("Vídeos", lookup_data.get("video_count") if lookup_data.get("video_count") is not None else "—")
+                display_name = st.text_input("Nome da conta", value=str(lookup_data.get("name") or lookup_data.get("username") or ""), key="tiktok_lookup_display_name")
+                notes = st.text_area("Observações internas", value=str(lookup_data.get("notes") or ""), key="tiktok_lookup_notes", height=80)
+                if st.button("Cadastrar conta TikTok", type="primary", use_container_width=True, key="tiktok_register_public_account"):
+                    try:
+                        stored = {**lookup_data, "name": display_name.strip() or lookup_data.get("username", ""), "notes": notes.strip(), "source": "public_lookup"}
+                        _upsert_tiktok_account(stored)
+                        st.session_state.pop("tiktok_public_lookup", None)
+                        st.success("Conta TikTok cadastrada e disponível no selector de Upload.")
+                        st.rerun()
+                    except ValueError as exc:
+                        st.error(str(exc))
+
+    with manual_tab:
+        st.subheader("Cadastrar conta manualmente")
+        with st.form("tiktok_manual_account_form"):
+            manual_source = st.text_input("@handle ou URL pública", placeholder="@minhaconta", key="tiktok_manual_source")
+            manual_name = st.text_input("Nome da conta", placeholder="Nome de apresentação", key="tiktok_manual_name")
+            manual_notes = st.text_area("Observações internas", height=90, key="tiktok_manual_notes")
+            manual_submitted = st.form_submit_button("Guardar cadastro manual", type="primary", use_container_width=True)
+        if manual_submitted:
+            try:
+                reference = normalize_tiktok_reference(manual_source)
+                _upsert_tiktok_account({**reference, "name": manual_name.strip() or reference["username"], "notes": manual_notes.strip(), "source": "manual"})
+                st.success("Conta TikTok cadastrada manualmente.")
+                st.rerun()
+            except ValueError as exc:
+                st.error(str(exc))
+
+    with library_tab:
+        st.subheader(f"Contas TikTok cadastradas ({len(accounts)})")
+        if not accounts:
+            st.info("Ainda não existem contas TikTok. Use Pesquisa pública ou Cadastro manual para adicionar a primeira conta.")
+        for account in accounts:
+            account_id = str(account.get("id") or account.get("username"))
+            with st.container(border=True):
+                card_cols = st.columns([0.18, 2.7, 1.1, 1.1, 0.8])
+                with card_cols[0]:
+                    if account.get("avatar_url"):
+                        st.image(account["avatar_url"], width=52)
+                    else:
+                        st.markdown("### TT")
+                with card_cols[1]:
+                    st.write(f"**{account.get('name') or account.get('username')}**")
+                    st.caption(f"{account.get('handle') or '@' + str(account.get('username', ''))} · {account.get('public_url') or account.get('url')}")
+                    st.caption(str(account.get("source") or "manual").replace("_", " ").title())
+                with card_cols[2]: st.caption(_tiktok_account_metric(account, "subscriber_count", "Seguidores"))
+                with card_cols[3]: st.caption(_tiktok_account_metric(account, "video_count", "Vídeos"))
+                with card_cols[4]:
+                    if st.button("Apagar", key=f"delete_tiktok_account_{account_id}"):
+                        _save_tiktok_accounts([item for item in accounts if str(item.get("id")) != account_id])
+                        st.success("Conta TikTok removida.")
+                        st.rerun()
+                with st.expander("Editar conta", expanded=False):
+                    with st.form(f"edit_tiktok_account_{account_id}"):
+                        edited_name = st.text_input("Nome da conta", value=str(account.get("name") or account.get("username") or ""), key=f"edit_tiktok_name_{account_id}")
+                        edited_source = st.text_input("@handle ou URL pública", value=str(account.get("public_url") or account.get("url") or account.get("handle") or ""), key=f"edit_tiktok_source_{account_id}")
+                        edited_notes = st.text_area("Observações internas", value=str(account.get("notes") or ""), key=f"edit_tiktok_notes_{account_id}", height=80)
+                        edit_submitted = st.form_submit_button("Guardar conta", type="primary", use_container_width=True)
+                    if edit_submitted:
+                        try:
+                            reference = normalize_tiktok_reference(edited_source)
+                            updated = {**account, **reference, "name": edited_name.strip() or reference["username"], "notes": edited_notes.strip(), "source": account.get("source") or "manual"}
+                            _upsert_tiktok_account(updated)
+                            st.success("Conta TikTok actualizada.")
+                            st.rerun()
+                        except ValueError as exc:
+                            st.error(str(exc))
+
+
 def render_tiktok_prompt_masters():
     st.title("Prompts Master")
     st.caption(f"Biblioteca exclusiva para vídeos TikTok. Os ficheiros ficam em `{TIKTOK_PROMPT_MASTERS}` e nunca entram na pasta de Blueprints YouTube.")
@@ -856,7 +1010,7 @@ def render_channels():
                 if lookup_mode.startswith("Página pública"):
                     result = youtube.fetch_channel_public(source)
                 elif not youtube.api_key:
-                    result = IntegrationResult(False, "A YouTube Data API Key não está configurada. Escolha a opção Página pública — sem API Key ou configure a chave em Configurações.", {"status": "api_key_not_configured"})
+                    result = IntegrationResult(False, "A YouTube Data API Key não está configurada. Escolha a opção Página pública — sem API Key ou configure a chave em Configurações > Contas Google.", {"status": "api_key_not_configured"})
                 else:
                     result = youtube.fetch_channel(source)
                 st.session_state["yt_import"] = result.data
@@ -938,7 +1092,7 @@ def render_channels():
         st.caption("Esta subaba usa a conta Google/YouTube seleccionada para listar os canais que ela gere. Não lê a caixa Gmail e não usa e-mails como pesquisa pública.")
         accounts = [account for account in settings.get("youtube_batch_accounts", []) if isinstance(account, dict) and account.get("id")]
         if not accounts:
-            st.info("Configure primeiro uma conta em Configurações > Configurações Técnicas > Contas Google/YouTube para canais em lote.")
+            st.info("Configure primeiro uma conta em Configurações > Configuração API > Contas Google/YouTube para canais em lote.")
         else:
             account_ids = [str(account["id"]) for account in accounts]
             account_labels = {str(account["id"]): f"{account.get('email', 'Conta Google')} — {account.get('label', 'Canais YouTube')}" for account in accounts}
@@ -1391,7 +1545,7 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                                 payload["thumbnail_path"] = thumbnail_path
                                 payload["thumbnail_status"] = "generated"
                             else:
-                                st.caption("A imagem ainda não foi gerada. Configure a API key em Configurações Técnicas > API Keys.")
+                                st.caption("A imagem ainda não foi gerada. Configure a API key em Configuração API > API Keys.")
                         st.caption(f"Estado da thumbnail: {payload.get('thumbnail_status', 'prompt_ready')} · texto: {payload.get('thumbnail_text') or 'sem texto'}")
             else:
                 topic_for_creative = str(st.session_state.get("new_video_topic", "") or "").strip()
@@ -1445,7 +1599,7 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                             payload["thumbnail_path"] = thumbnail_path
                             payload["thumbnail_status"] = "generated"
                         else:
-                            st.info("Escolha a variante e clique em **Gerar imagem da thumbnail com Nano Banana**. A API key é configurada em Configurações Técnicas > API Keys.")
+                            st.info("Escolha a variante e clique em **Gerar imagem da thumbnail com Nano Banana**. A API key é configurada em Configuração API > API Keys.")
                     st.session_state["new_video_creative_payload"] = payload
 
             with st.form("new_video_form"):
@@ -2434,11 +2588,11 @@ def render_upload():
 
 def render_upload_postiz():
     st.subheader("Upload para Postiz")
-    st.caption("O Thunderbolt envia primeiro o MP4 para o Postiz e cria um post na integração seleccionada. A API key e o servidor são configurados em Configurações Técnicas.")
+    st.caption("O Thunderbolt envia primeiro o MP4 para o Postiz e cria um post na integração seleccionada. A API key e o servidor são configurados em Configuração API.")
     settings = read_json("settings.json", {})
     postiz = PostizAdapter(settings)
     if not settings.get("postiz_enabled"):
-        st.warning("Postiz está desactivado. Active-o em Configurações Técnicas > API Keys e guarde a API key antes de enviar.")
+        st.warning("Postiz está desactivado. Active-o em Configuração API > API Keys e guarde a API key antes de enviar.")
     if not postiz.api_key:
         st.info("Nenhuma API key Postiz configurada.")
         return
@@ -2465,7 +2619,7 @@ def render_upload_postiz():
             format_func=lambda value: integration_labels.get(value, value),
             key="postiz_upload_integration",
         )
-        st.caption("Para alterar a integração padrão, guarde o ID seleccionado em Configurações Técnicas.")
+        st.caption("Para alterar a integração padrão, guarde o ID seleccionado em Configuração API.")
     else:
         selected_integration = st.text_input("ID da integração Postiz", value=integration_default, key="postiz_upload_integration_manual", help="Carregue as integrações para seleccionar uma conta ou introduza o ID devolvido pela API do Postiz.").strip()
         st.info("Carregue as integrações para descobrir os canais Postiz ligados à sua conta.")
@@ -2509,7 +2663,7 @@ def render_upload_postiz():
 
 
 UPLOAD_DESTINATION_TARGET_KEYS = {
-    "TikTok": "tiktok_profiles",
+    "TikTok": "tiktok_accounts",
     "Instagram": "instagram_profiles",
     "Facebook Pages": "facebook_pages",
 }
@@ -2539,6 +2693,8 @@ def upload_targets_for_destination(destination: str, channels: list[dict[str, An
     if not setting_key:
         return []
     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 not isinstance(configured_targets, list):
         return []
     targets: list[Any] = []
@@ -2553,12 +2709,14 @@ 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 "Perfil / página"
-    empty_label = "Nenhum canal YouTube cadastrado" if destination == "YouTube" else f"Nenhum {destination} configurado"
+    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")
     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.")
         else:
             st.caption(f"A lista de {destination} será ligada numa etapa própria de credenciais/API.")
         return None
@@ -2600,7 +2758,7 @@ def render_upload_conventional():
             postiz_status = postiz.status()
             (st.success if postiz_status.ok else st.warning)(postiz_status.message)
         else:
-            st.caption("Postiz está desactivado; active-o em Configurações Técnicas para o usar como fallback final.")
+            st.caption("Postiz está desactivado; active-o em Configuração API para o usar como fallback final.")
         status_cols = st.columns(2)
         with status_cols[0]:
             (st.success if status["agent"].ok else st.warning)(f"Agente: {status['agent'].message}")
@@ -2703,9 +2861,239 @@ def render_upload_conventional():
                 st.button("Preparar Facebook Pages", key=f"upload_facebook_{task['id']}", disabled=True, help="UI preparada; publicação Facebook Pages ainda não está activa.")
 
 
+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.")
+    settings = read_json("settings.json", {})
+
+    st.subheader("Contas Google/YouTube — canais em lote")
+    st.caption("Abra uma conta para ver e editar os detalhes. O e-mail identifica a conta Google; esta área não lê a caixa Gmail.")
+    batch_accounts = [account for account in settings.get("youtube_batch_accounts", []) if isinstance(account, dict) and account.get("id")]
+    channel_state = read_json("channels.json", [])
+    youtube_accounts_missing_document: list[str] = []
+
+    for batch_account in batch_accounts:
+        account_id = str(batch_account["id"])
+        account_email_snapshot = str(batch_account.get("email") or "sem e-mail")
+        account_label_snapshot = str(batch_account.get("label") or "Canais YouTube")
+        ensure_credentials_document(STORAGE, batch_account, settings, channel_state)
+        direct_status = direct_account_status(STORAGE, batch_account, settings)
+        missing_document_parts = list(direct_status.get("missing_cookies", []))
+        if not direct_status.get("has_session_info"):
+            missing_document_parts.append("sessionInfo")
+        if missing_document_parts:
+            youtube_accounts_missing_document.append(account_email_snapshot)
+
+        with st.expander(f"{account_label_snapshot} — {account_email_snapshot}", expanded=False):
+            with st.form(f"batch_account_form_{account_id}"):
+                account_cols = st.columns(2)
+                with account_cols[0]:
+                    account_label = st.text_input("Nome da conta", value=account_label_snapshot, key=f"batch_label_{account_id}")
+                    account_email = st.text_input("E-mail/Gmail da conta", value=account_email_snapshot if account_email_snapshot != "sem e-mail" else "", key=f"batch_email_{account_id}")
+                    account_client_id = st.text_input("OAuth Client ID", value=str(batch_account.get("client_id", "")), key=f"batch_client_id_{account_id}")
+                with account_cols[1]:
+                    account_client_secret = st.text_input("OAuth Client Secret", value=str(batch_account.get("client_secret", "")), type="password", key=f"batch_client_secret_{account_id}")
+                    account_session_info = st.text_input(
+                        "sessionInfo token desta conta Google",
+                        value=str(batch_account.get("sessionInfo") or batch_account.get("session_info") or batch_account.get("direct_session_info", "")),
+                        type="password",
+                        key=f"batch_session_info_{account_id}",
+                        help="Token sessionInfo usado pelo Upload directo. É guardado por conta e sincronizado no credentials.json; os cookies e restantes valores continuam exclusivamente no documento.",
+                    )
+                save_account = st.form_submit_button("Guardar dados da conta Google", type="primary", use_container_width=True)
+
+            st.markdown("**Documento de cookies/credenciais desta conta Google**")
+            st.caption("O documento padrão é criado automaticamente. Suba um JSON completo ou apenas o documento de cookies; os valores preenchidos são incorporados e mantidos em credentials.json.")
+            document_upload = st.file_uploader(
+                "Subir documento de cookies/credenciais",
+                type=["json"],
+                key=f"direct_credentials_document_{account_id}",
+                help="Aceita o JSON do YouTube-Video-Upload-Frontend-Api. Um documento parcial de cookies também é incorporado sem apagar os restantes campos.",
+            )
+            if missing_document_parts:
+                st.warning(f"Documento incompleto: {', '.join(missing_document_parts)}")
+            else:
+                st.success("Documento completo para a conta Google")
+            st.caption(f"Documento guardado em: {direct_status['document_file']}")
+            document_save = st.button("Guardar documento nesta conta", key=f"save_direct_account_{account_id}", use_container_width=True)
+
+            account_status = youtube_batch_account_status(batch_account, STORAGE)
+            status_cols = st.columns(3)
+            with status_cols[0]:
+                (st.success if account_status.ok else st.warning)(account_status.message)
+            with status_cols[1]:
+                if st.button("Autorizar/Reautorizar", key=f"batch_authorize_settings_{account_id}", use_container_width=True):
+                    result = authorize_youtube_batch_account(batch_account, STORAGE)
+                    (st.success if result.ok else st.error)(result.message)
+                    if result.ok:
+                        st.rerun()
+            with status_cols[2]:
+                if st.button("Apagar conta", icon=":material/delete:", key=f"batch_remove_settings_{account_id}", use_container_width=True):
+                    delete_youtube_batch_token(batch_account, STORAGE)
+                    delete_credentials_document(STORAGE, batch_account)
+                    remaining_accounts = [account for account in batch_accounts if str(account.get("id")) != account_id]
+                    settings["youtube_batch_accounts"] = remaining_accounts
+                    if settings.get("youtube_batch_selected_account_id") == account_id:
+                        settings["youtube_batch_selected_account_id"] = str(remaining_accounts[0].get("id")) if remaining_accounts else ""
+                    for channel in channel_state:
+                        if str(channel.get("google_account_id") or "") == account_id:
+                            channel.update({"google_account_id": "", "google_account_email": ""})
+                    write_json("channels.json", channel_state)
+                    write_json("settings.json", settings)
+                    st.rerun()
+
+            if save_account:
+                if "@" not in account_email.strip():
+                    st.error("Informe um e-mail Google válido.")
+                elif not account_client_id.strip() or not account_client_secret.strip():
+                    st.error("Informe o Client ID e o Client Secret desta conta.")
+                else:
+                    for existing in batch_accounts:
+                        if str(existing.get("id")) == account_id:
+                            credentials_changed = any(existing.get(field, "") != value for field, value in (("email", account_email.strip()), ("client_id", account_client_id.strip()), ("client_secret", account_client_secret.strip())))
+                            if credentials_changed:
+                                delete_youtube_batch_token(existing, STORAGE)
+                            existing.update({"label": account_label.strip() or "Canais YouTube", "email": account_email.strip(), "client_id": account_client_id.strip(), "client_secret": account_client_secret.strip(), "sessionInfo": account_session_info.strip()})
+                            update_credentials_document_session_info(STORAGE, existing, account_session_info.strip())
+                            ensure_credentials_document(STORAGE, existing, settings, channel_state)
+                    settings["youtube_batch_accounts"] = batch_accounts
+                    write_json("settings.json", settings)
+                    st.success("Conta Google/YouTube guardada.")
+                    st.rerun()
+
+            if document_save:
+                if document_upload is None:
+                    st.error("Seleccione um documento JSON de cookies/credenciais antes de guardar.")
+                else:
+                    try:
+                        merge_credentials_document(
+                            STORAGE,
+                            batch_account,
+                            document_upload.getvalue(),
+                            document_upload.name,
+                            session_info_override=str(batch_account.get("sessionInfo") or ""),
+                            channels=channel_state,
+                        )
+                        st.success("Documento incorporado e guardado nesta conta Google.")
+                        st.rerun()
+                    except ValueError as exc:
+                        st.error(str(exc))
+
+    if youtube_accounts_missing_document:
+        st.info("Contas que ainda precisam de dados no documento: " + ", ".join(youtube_accounts_missing_document))
+
+    st.divider()
+    st.markdown("### INNERTUBE_API_KEY")
+    st.caption("Esta chave pertence à conta Google/YouTube seleccionada e fica guardada na configuração da conta. Não faz parte do documento de cookies/credenciais e não é editada no separador API Keys.")
+    account_key_options = [str(account.get("id")) for account in batch_accounts if account.get("id")]
+    account_key_labels = {str(account.get("id")): f"{account.get('label', 'Canais YouTube')} — {account.get('email', 'sem e-mail')}" for account in batch_accounts if account.get("id")}
+    if account_key_options:
+        with st.form("innertube_api_key_form"):
+            selected_key_account_id = st.selectbox("Conta Google/YouTube", account_key_options, format_func=lambda value: account_key_labels.get(value, value), key="innertube_key_account")
+            selected_key_account = next(account for account in batch_accounts if str(account.get("id")) == selected_key_account_id)
+            current_innertube_api_key = direct_account_status(STORAGE, selected_key_account, settings).get("innertube_api_key", "")
+            innertube_api_key_value = st.text_input("INNERTUBE_API_KEY", value=current_innertube_api_key, type="password", key=f"innertube_api_key_{selected_key_account_id}", help="Chave usada pelo Upload directo desta conta. Guarde-a aqui, separada do documento de cookies.")
+            save_innertube_api_key = st.form_submit_button("Guardar INNERTUBE_API_KEY", type="primary", use_container_width=True)
+        if save_innertube_api_key:
+            selected_key_account["innertube_api_key"] = innertube_api_key_value.strip()
+            selected_key_account.pop("INNERTUBE_API_KEY", None)
+            settings.pop("direct_innertube_api_key", None)
+            settings["youtube_batch_accounts"] = batch_accounts
+            write_json("settings.json", settings)
+            document = load_credentials_document(STORAGE, selected_key_account, settings, channel_state, create=True)
+            save_credentials_document(STORAGE, selected_key_account, document)
+            st.success("INNERTUBE_API_KEY guardada na configuração da conta Google/YouTube, fora do documento de cookies.")
+            st.rerun()
+    else:
+        st.info("Adicione primeiro uma conta Google/YouTube para configurar a INNERTUBE_API_KEY.")
+
+    st.divider()
+    st.markdown("### Adicionar outra conta Gmail")
+    st.caption("Este formulário fica fora dos cartões das contas existentes. A associação de canais não depende da completude deste documento; ela apenas ficará pendente para Upload directo até os campos serem preenchidos.")
+    with st.form("add_batch_account_form"):
+        add_cols = st.columns(2)
+        with add_cols[0]:
+            new_account_label = st.text_input("Nome da nova conta", value="Canais YouTube", key="new_batch_account_label")
+            new_account_email = st.text_input("E-mail/Gmail", key="new_batch_account_email")
+            new_account_client_id = st.text_input("OAuth Client ID", key="new_batch_account_client_id")
+        with add_cols[1]:
+            new_account_client_secret = st.text_input("OAuth Client Secret", type="password", key="new_batch_account_client_secret")
+            new_account_session_info = st.text_input("sessionInfo token desta conta Google", type="password", key="new_batch_account_session_info", help="Token sessionInfo desta conta. Os cookies e delegated_session_ids ficam no documento; a INNERTUBE_API_KEY é configurada no bloco próprio acima.")
+            new_account_document = st.file_uploader("Documento de cookies/credenciais opcional", type=["json"], key="new_batch_account_credentials_document", help="Pode subir agora um JSON completo ou apenas o documento de cookies. Se não subir, será criado um credentials.json padrão vazio.")
+        add_account = st.form_submit_button("Adicionar conta Google/YouTube", type="primary", use_container_width=True)
+    if add_account:
+        document_error = ""
+        if "@" not in new_account_email.strip():
+            st.error("Informe um e-mail Google válido.")
+        elif not new_account_client_id.strip() or not new_account_client_secret.strip():
+            st.error("Informe o Client ID e o Client Secret da nova conta.")
+        elif new_account_document is not None:
+            try:
+                raw_document = new_account_document.getvalue()
+                json.loads(raw_document.decode("utf-8-sig", errors="replace"))
+            except (UnicodeDecodeError, json.JSONDecodeError, AttributeError) as exc:
+                document_error = f"O documento {new_account_document.name} deve ser JSON válido."
+                st.error(document_error)
+        if "@" in new_account_email.strip() and new_account_client_id.strip() and new_account_client_secret.strip() and not document_error:
+            new_account = {"id": f"google_batch_{uuid.uuid4().hex[:12]}", "label": new_account_label.strip() or "Canais YouTube", "email": new_account_email.strip(), "client_id": new_account_client_id.strip(), "client_secret": new_account_client_secret.strip(), "sessionInfo": new_account_session_info.strip()}
+            batch_accounts.append(new_account)
+            settings["youtube_batch_accounts"] = batch_accounts
+            settings["youtube_batch_selected_account_id"] = new_account["id"]
+            write_json("settings.json", settings)
+            ensure_credentials_document(STORAGE, new_account, settings, channel_state)
+            if new_account_document is not None:
+                try:
+                    merge_credentials_document(STORAGE, new_account, new_account_document.getvalue(), new_account_document.name, session_info_override=new_account_session_info.strip(), channels=channel_state)
+                except ValueError as exc:
+                    st.error(str(exc))
+                    st.stop()
+                st.success(f"Conta {new_account['email']} adicionada e documento incorporado.")
+            else:
+                st.warning(f"Conta {new_account['email']} adicionada. Foi criado um credentials.json padrão; suba o documento de cookies nesta conta quando estiver pronto.")
+            st.rerun()
+
+    st.divider()
+    st.subheader("Configuração global do YouTube")
+    st.caption("Estas credenciais pertencem à aplicação Google/YouTube e ficam separadas das restantes APIs do Thunderbolt.")
+    with st.form("google_global_api_settings_form"):
+        google_api_cols = st.columns(2)
+        with google_api_cols[0]:
+            youtube_client_id = st.text_input(
+                "YouTube OAuth Client ID",
+                value=str(settings.get("youtube_client_id", "") or ""),
+                key="google_page_youtube_client_id",
+                help="Client ID OAuth 2.0 criado no Google Cloud para autorizar a conta YouTube.",
+            )
+        with google_api_cols[1]:
+            youtube_client_secret = st.text_input(
+                "YouTube OAuth Client Secret",
+                value=str(settings.get("youtube_client_secret", "") or ""),
+                type="password",
+                key="google_page_youtube_client_secret",
+                help="Client Secret do mesmo cliente OAuth 2.0. Não é uma API Key.",
+            )
+        st.caption(f"OAuth local: use um cliente do tipo Desktop app. Se o Google Cloud pedir uma URI autorizada, registe exactamente `{loopback_redirect_uri()}`.")
+        youtube_api_key = st.text_input(
+            "YouTube Data API Key (opcional)",
+            value=str(settings.get("youtube_api_key", "") or ""),
+            type="password",
+            key="google_page_youtube_api_key",
+            help="Credencial Google Cloud separada, usada apenas para métricas oficiais da YouTube Data API.",
+        )
+        save_google_global = st.form_submit_button("Guardar configuração global do YouTube", type="primary", use_container_width=True)
+    if save_google_global:
+        settings.update({
+            "youtube_client_id": youtube_client_id.strip(),
+            "youtube_client_secret": youtube_client_secret.strip(),
+            "youtube_api_key": youtube_api_key.strip(),
+        })
+        write_json("settings.json", settings)
+        st.success("Configuração global do YouTube guardada em Contas Google.")
+        st.rerun()
+
 def render_settings():
-    st.title("Configurações Técnicas")
-    st.caption("Configuração do motor de vídeo e dos serviços usados pelo Thunderbolt. As credenciais ficam no storage local e não são enviadas para o GitHub.")
+    st.title("Configuração API")
+    st.caption("Configuração das APIs, providers, serviços e ferramentas técnicas usados pelo Thunderbolt. As credenciais ficam no storage local e não são enviadas para o GitHub.")
     settings = read_json("settings.json", {})
 
     def text_setting(label: str, key: str, *, secret: bool = False, help_text: str | None = None) -> str:
@@ -2717,209 +3105,13 @@ def render_settings():
             key=f"settings_{key}",
         )
 
-    google_accounts_tab, api_keys_tab, voice_test_tab = st.tabs(["Contas Google/YouTube — canais em lote", "API Keys", "Teste de vozes"])
-
-    with google_accounts_tab:
-        st.subheader("Contas Google/YouTube — canais em lote")
-        st.caption("Abra uma conta para ver e editar os detalhes. O e-mail identifica a conta Google; esta área não lê a caixa Gmail.")
-        batch_accounts = [account for account in settings.get("youtube_batch_accounts", []) if isinstance(account, dict) and account.get("id")]
-        channel_state = read_json("channels.json", [])
-        youtube_accounts_missing_document: list[str] = []
-
-        for batch_account in batch_accounts:
-            account_id = str(batch_account["id"])
-            account_email_snapshot = str(batch_account.get("email") or "sem e-mail")
-            account_label_snapshot = str(batch_account.get("label") or "Canais YouTube")
-            ensure_credentials_document(STORAGE, batch_account, settings, channel_state)
-            direct_status = direct_account_status(STORAGE, batch_account, settings)
-            missing_document_parts = list(direct_status.get("missing_cookies", []))
-            if not direct_status.get("has_session_info"):
-                missing_document_parts.append("sessionInfo")
-            if missing_document_parts:
-                youtube_accounts_missing_document.append(account_email_snapshot)
-
-            with st.expander(f"{account_label_snapshot} — {account_email_snapshot}", expanded=False):
-                with st.form(f"batch_account_form_{account_id}"):
-                    account_cols = st.columns(2)
-                    with account_cols[0]:
-                        account_label = st.text_input("Nome da conta", value=account_label_snapshot, key=f"batch_label_{account_id}")
-                        account_email = st.text_input("E-mail/Gmail da conta", value=account_email_snapshot if account_email_snapshot != "sem e-mail" else "", key=f"batch_email_{account_id}")
-                        account_client_id = st.text_input("OAuth Client ID", value=str(batch_account.get("client_id", "")), key=f"batch_client_id_{account_id}")
-                    with account_cols[1]:
-                        account_client_secret = st.text_input("OAuth Client Secret", value=str(batch_account.get("client_secret", "")), type="password", key=f"batch_client_secret_{account_id}")
-                        account_session_info = st.text_input(
-                            "sessionInfo token desta conta Google",
-                            value=str(batch_account.get("sessionInfo") or batch_account.get("session_info") or batch_account.get("direct_session_info", "")),
-                            type="password",
-                            key=f"batch_session_info_{account_id}",
-                            help="Token sessionInfo usado pelo Upload directo. É guardado por conta e sincronizado no credentials.json; os cookies e restantes valores continuam exclusivamente no documento.",
-                        )
-                    save_account = st.form_submit_button("Guardar dados da conta Google", type="primary", use_container_width=True)
-
-                st.markdown("**Documento de cookies/credenciais desta conta Google**")
-                st.caption("O documento padrão é criado automaticamente. Suba um JSON completo ou apenas o documento de cookies; os valores preenchidos são incorporados e mantidos em credentials.json.")
-                document_upload = st.file_uploader(
-                    "Subir documento de cookies/credenciais",
-                    type=["json"],
-                    key=f"direct_credentials_document_{account_id}",
-                    help="Aceita o JSON do YouTube-Video-Upload-Frontend-Api. Um documento parcial de cookies também é incorporado sem apagar os restantes campos.",
-                )
-                if missing_document_parts:
-                    st.warning(f"Documento incompleto: {', '.join(missing_document_parts)}")
-                else:
-                    st.success("Documento completo para a conta Google")
-                st.caption(f"Documento guardado em: {direct_status['document_file']}")
-                document_save = st.button("Guardar documento nesta conta", key=f"save_direct_account_{account_id}", use_container_width=True)
-
-                account_status = youtube_batch_account_status(batch_account, STORAGE)
-                status_cols = st.columns(3)
-                with status_cols[0]:
-                    (st.success if account_status.ok else st.warning)(account_status.message)
-                with status_cols[1]:
-                    if st.button("Autorizar/Reautorizar", key=f"batch_authorize_settings_{account_id}", use_container_width=True):
-                        result = authorize_youtube_batch_account(batch_account, STORAGE)
-                        (st.success if result.ok else st.error)(result.message)
-                        if result.ok:
-                            st.rerun()
-                with status_cols[2]:
-                    if st.button("Apagar conta", icon=":material/delete:", key=f"batch_remove_settings_{account_id}", use_container_width=True):
-                        delete_youtube_batch_token(batch_account, STORAGE)
-                        delete_credentials_document(STORAGE, batch_account)
-                        remaining_accounts = [account for account in batch_accounts if str(account.get("id")) != account_id]
-                        settings["youtube_batch_accounts"] = remaining_accounts
-                        if settings.get("youtube_batch_selected_account_id") == account_id:
-                            settings["youtube_batch_selected_account_id"] = str(remaining_accounts[0].get("id")) if remaining_accounts else ""
-                        for channel in channel_state:
-                            if str(channel.get("google_account_id") or "") == account_id:
-                                channel.update({"google_account_id": "", "google_account_email": ""})
-                        write_json("channels.json", channel_state)
-                        write_json("settings.json", settings)
-                        st.rerun()
-
-                if save_account:
-                    if "@" not in account_email.strip():
-                        st.error("Informe um e-mail Google válido.")
-                    elif not account_client_id.strip() or not account_client_secret.strip():
-                        st.error("Informe o Client ID e o Client Secret desta conta.")
-                    else:
-                        for existing in batch_accounts:
-                            if str(existing.get("id")) == account_id:
-                                credentials_changed = any(existing.get(field, "") != value for field, value in (("email", account_email.strip()), ("client_id", account_client_id.strip()), ("client_secret", account_client_secret.strip())))
-                                if credentials_changed:
-                                    delete_youtube_batch_token(existing, STORAGE)
-                                existing.update({"label": account_label.strip() or "Canais YouTube", "email": account_email.strip(), "client_id": account_client_id.strip(), "client_secret": account_client_secret.strip(), "sessionInfo": account_session_info.strip()})
-                                update_credentials_document_session_info(STORAGE, existing, account_session_info.strip())
-                                ensure_credentials_document(STORAGE, existing, settings, channel_state)
-                        settings["youtube_batch_accounts"] = batch_accounts
-                        write_json("settings.json", settings)
-                        st.success("Conta Google/YouTube guardada.")
-                        st.rerun()
-
-                if document_save:
-                    if document_upload is None:
-                        st.error("Seleccione um documento JSON de cookies/credenciais antes de guardar.")
-                    else:
-                        try:
-                            merge_credentials_document(
-                                STORAGE,
-                                batch_account,
-                                document_upload.getvalue(),
-                                document_upload.name,
-                                session_info_override=str(batch_account.get("sessionInfo") or ""),
-                                channels=channel_state,
-                            )
-                            st.success("Documento incorporado e guardado nesta conta Google.")
-                            st.rerun()
-                        except ValueError as exc:
-                            st.error(str(exc))
-
-        if youtube_accounts_missing_document:
-            st.info("Contas que ainda precisam de dados no documento: " + ", ".join(youtube_accounts_missing_document))
-
-        st.divider()
-        st.markdown("### INNERTUBE_API_KEY")
-        st.caption("Esta chave pertence à conta Google/YouTube seleccionada e fica guardada na configuração da conta. Não faz parte do documento de cookies/credenciais e não é editada no separador API Keys.")
-        account_key_options = [str(account.get("id")) for account in batch_accounts if account.get("id")]
-        account_key_labels = {str(account.get("id")): f"{account.get('label', 'Canais YouTube')} — {account.get('email', 'sem e-mail')}" for account in batch_accounts if account.get("id")}
-        if account_key_options:
-            with st.form("innertube_api_key_form"):
-                selected_key_account_id = st.selectbox("Conta Google/YouTube", account_key_options, format_func=lambda value: account_key_labels.get(value, value), key="innertube_key_account")
-                selected_key_account = next(account for account in batch_accounts if str(account.get("id")) == selected_key_account_id)
-                current_innertube_api_key = direct_account_status(STORAGE, selected_key_account, settings).get("innertube_api_key", "")
-                innertube_api_key_value = st.text_input("INNERTUBE_API_KEY", value=current_innertube_api_key, type="password", key=f"innertube_api_key_{selected_key_account_id}", help="Chave usada pelo Upload directo desta conta. Guarde-a aqui, separada do documento de cookies.")
-                save_innertube_api_key = st.form_submit_button("Guardar INNERTUBE_API_KEY", type="primary", use_container_width=True)
-            if save_innertube_api_key:
-                selected_key_account["innertube_api_key"] = innertube_api_key_value.strip()
-                selected_key_account.pop("INNERTUBE_API_KEY", None)
-                settings.pop("direct_innertube_api_key", None)
-                settings["youtube_batch_accounts"] = batch_accounts
-                write_json("settings.json", settings)
-                document = load_credentials_document(STORAGE, selected_key_account, settings, channel_state, create=True)
-                save_credentials_document(STORAGE, selected_key_account, document)
-                st.success("INNERTUBE_API_KEY guardada na configuração da conta Google/YouTube, fora do documento de cookies.")
-                st.rerun()
-        else:
-            st.info("Adicione primeiro uma conta Google/YouTube para configurar a INNERTUBE_API_KEY.")
-
-        st.divider()
-        st.markdown("### Adicionar outra conta Gmail")
-        st.caption("Este formulário fica fora dos cartões das contas existentes. A associação de canais não depende da completude deste documento; ela apenas ficará pendente para Upload directo até os campos serem preenchidos.")
-        with st.form("add_batch_account_form"):
-            add_cols = st.columns(2)
-            with add_cols[0]:
-                new_account_label = st.text_input("Nome da nova conta", value="Canais YouTube", key="new_batch_account_label")
-                new_account_email = st.text_input("E-mail/Gmail", key="new_batch_account_email")
-                new_account_client_id = st.text_input("OAuth Client ID", key="new_batch_account_client_id")
-            with add_cols[1]:
-                new_account_client_secret = st.text_input("OAuth Client Secret", type="password", key="new_batch_account_client_secret")
-                new_account_session_info = st.text_input("sessionInfo token desta conta Google", type="password", key="new_batch_account_session_info", help="Token sessionInfo desta conta. Os cookies e delegated_session_ids ficam no documento; a INNERTUBE_API_KEY é configurada no bloco próprio acima.")
-                new_account_document = st.file_uploader("Documento de cookies/credenciais opcional", type=["json"], key="new_batch_account_credentials_document", help="Pode subir agora um JSON completo ou apenas o documento de cookies. Se não subir, será criado um credentials.json padrão vazio.")
-            add_account = st.form_submit_button("Adicionar conta Google/YouTube", type="primary", use_container_width=True)
-        if add_account:
-            document_error = ""
-            if "@" not in new_account_email.strip():
-                st.error("Informe um e-mail Google válido.")
-            elif not new_account_client_id.strip() or not new_account_client_secret.strip():
-                st.error("Informe o Client ID e o Client Secret da nova conta.")
-            elif new_account_document is not None:
-                try:
-                    raw_document = new_account_document.getvalue()
-                    json.loads(raw_document.decode("utf-8-sig", errors="replace"))
-                except (UnicodeDecodeError, json.JSONDecodeError, AttributeError) as exc:
-                    document_error = f"O documento {new_account_document.name} deve ser JSON válido."
-                    st.error(document_error)
-            if "@" in new_account_email.strip() and new_account_client_id.strip() and new_account_client_secret.strip() and not document_error:
-                new_account = {"id": f"google_batch_{uuid.uuid4().hex[:12]}", "label": new_account_label.strip() or "Canais YouTube", "email": new_account_email.strip(), "client_id": new_account_client_id.strip(), "client_secret": new_account_client_secret.strip(), "sessionInfo": new_account_session_info.strip()}
-                batch_accounts.append(new_account)
-                settings["youtube_batch_accounts"] = batch_accounts
-                settings["youtube_batch_selected_account_id"] = new_account["id"]
-                write_json("settings.json", settings)
-                ensure_credentials_document(STORAGE, new_account, settings, channel_state)
-                if new_account_document is not None:
-                    try:
-                        merge_credentials_document(STORAGE, new_account, new_account_document.getvalue(), new_account_document.name, session_info_override=new_account_session_info.strip(), channels=channel_state)
-                    except ValueError as exc:
-                        st.error(str(exc))
-                        st.stop()
-                    st.success(f"Conta {new_account['email']} adicionada e documento incorporado.")
-                else:
-                    st.warning(f"Conta {new_account['email']} adicionada. Foi criado um credentials.json padrão; suba o documento de cookies nesta conta quando estiver pronto.")
-                st.rerun()
+    api_keys_tab, voice_test_tab = st.tabs(["API Keys", "Teste de vozes"])
 
     with api_keys_tab:
         with st.form("settings_form"):
             st.subheader("API Keys")
             port = st.number_input("Porta Streamlit", 1, 65535, int(settings.get("port", 3030)))
             moneyprinter_path = st.text_input("Pasta do motor de vídeo", settings.get("moneyprinter_path", ""), key="settings_moneyprinter_path")
-            st.markdown("**YouTube — OAuth 2.0 e consulta pública**")
-            st.caption("Para autorizar uploads, preencha apenas o YouTube OAuth Client ID e o YouTube OAuth Client Secret. Depois, autorize o agente na aba Upload. Estes dados identificam a aplicação OAuth; não são uma Data API Key nem um token de acesso.")
-            st.info(f"OAuth local: use um cliente do tipo Desktop app. Se o Google Cloud pedir uma URI autorizada, registe exactamente `{loopback_redirect_uri()}`.")
-            youtube_cols = st.columns(2)
-            with youtube_cols[0]:
-                youtube_client_id = text_setting("YouTube OAuth Client ID", "youtube_client_id", help_text="Client ID do OAuth 2.0 criado no Google Cloud. É usado para iniciar a autorização da conta YouTube.")
-            with youtube_cols[1]:
-                youtube_client_secret = text_setting("YouTube OAuth Client Secret", "youtube_client_secret", secret=True, help_text="Client Secret do mesmo cliente OAuth 2.0. Não é uma API Key.")
-
             with st.expander("Niche Finder — execução remota no Kaggle", expanded=True):
                 st.caption("O dataset permanece no Kaggle. O Thunderbolt usa estas credenciais apenas para publicar/executar a kernel e obter os resultados pequenos da análise.")
                 kaggle_cols = st.columns(3)
@@ -2942,10 +3134,6 @@ def render_settings():
                 with apify_cols[3]:
                     apify_run_timeout = st.number_input("Limite da execução (s)", min_value=30, max_value=7200, value=int(settings.get("apify_run_timeout_seconds", 900)), step=30)
 
-            with st.expander("Consulta oficial de métricas — opcional"):
-                st.caption("A YouTube Data API Key é uma credencial Google Cloud separada do OAuth. Só é necessária se escolher o método YouTube Data API para consultar métricas oficiais. Não é necessária para Página pública — sem API Key, para autorizar OAuth ou para fazer upload.")
-                youtube_api_key = text_setting("YouTube Data API Key (opcional)", "youtube_api_key", secret=True, help_text="Credencial separada, criada em Google Cloud > APIs e serviços > Credenciais > Chave de API. Não cole aqui o Client ID nem o Client Secret.")
-
             with st.expander("Serviço, materiais e rede"):
                 cols = st.columns(2)
                 with cols[0]:
@@ -3102,8 +3290,7 @@ def render_settings():
             save_all_settings = st.form_submit_button("Guardar configurações do Thunderbolt", type="primary")
             if save_all_settings:
                 settings.update({
-                    "port": port, "moneyprinter_path": moneyprinter_path, "youtube_api_key": youtube_api_key,
-                    "youtube_client_id": youtube_client_id, "youtube_client_secret": youtube_client_secret,
+                    "port": port, "moneyprinter_path": moneyprinter_path,
                     "kaggle_username": kaggle_username.strip(), "kaggle_api_key": kaggle_api_key.strip(), "kaggle_kernel_slug": kaggle_kernel_slug.strip() or "thunderbolt-niche-finder",
                     "apify_api_token": apify_api_token.strip(), "apify_actor_id": apify_actor_id.strip() or DEFAULT_ACTOR_ID, "apify_poll_interval_seconds": int(apify_poll_interval), "apify_run_timeout_seconds": int(apify_run_timeout),
                     "log_level": log_level, "listen_host": listen_host, "listen_port": listen_port, "video_source": video_source,
@@ -3171,6 +3358,32 @@ def render_settings():
             st.warning("A amostra de voz anterior não é um ficheiro de áudio legível e foi removida do estado local. Teste a voz novamente.")
 
 
+def render_notifications():
+    st.title("Notificações")
+    st.caption("Centro de notificações locais do Thunderbolt.")
+    st.info("Ainda não existem notificações registadas. Os eventos de processamento, publicação e integração serão ligados aqui numa etapa posterior.")
+    st.divider()
+    st.subheader("Preferências de notificação")
+    st.caption("Os canais de e-mail, push e webhook ainda não estão activos nesta versão.")
+    st.checkbox("Notificações no painel", value=True, disabled=True, key="notifications_panel_preview")
+    st.checkbox("Notificações por e-mail", value=False, disabled=True, key="notifications_email_preview")
+
+
+def render_models_ai_tutorial():
+    tutorial_url = "https://github.com/gyoridavid/ai_agents_az/blob/main/episode_8/guide-instagram.md"
+    tutorial_path = ROOT / "seed" / "references" / "guide-instagram.md"
+    st.title("Tutorial Meta")
+    st.caption("Guia de configuração de uma conta Instagram profissional e das credenciais Meta para automações com n8n.")
+    st.markdown(f"[Abrir fonte original no GitHub]({tutorial_url})")
+    try:
+        tutorial_content = tutorial_path.read_text(encoding="utf-8").strip()
+    except OSError:
+        tutorial_content = ""
+    if not tutorial_content:
+        st.error("O conteúdo local do tutorial não está disponível. Consulte a fonte original no GitHub.")
+        return
+    st.markdown(tutorial_content, unsafe_allow_html=True)
+
 def render_mcp():
     st.title("MCP")
     st.caption("Clientes externos, servidor MCP do Thunderbolt e a skill local ficam separados para evitar confundir funções diferentes.")
@@ -3447,6 +3660,7 @@ def main():
     ]
     pipeline_tiktok_items = [
         ("Prompts Master", ":material/auto_awesome:", "Prompts Master"),
+        ("Contas TikTok", ":material/account_circle:", "Contas TikTok"),
     ]
     edition_items = [
         ("Limpador de Metadados", ":material/edit_note:", "Limpador de Metadados"),
@@ -3456,12 +3670,15 @@ def main():
     models_ai_items = [
         ("Personagens", ":material/person:", "Personagens"),
         ("Redes Sociais", ":material/share:", "Redes Sociais"),
+        ("Tutorial Meta", ":material/menu_book:", "Tutorial Meta"),
     ]
     settings_items = [
         ("Canais Youtube", ":material/ondemand_video:", "Canais Youtube"),
         ("Blueprints Youtube", ":material/library_books:", "Blueprints Youtube"),
         ("MCP", ":material/hub:", "MCP"),
-        ("Configurações Técnicas", ":material/settings:", "Configurações Técnicas"),
+        ("Contas Google", ":material/account_circle:", "Contas Google"),
+        ("Configuração API", ":material/settings:", "Configuração API"),
+        ("Notificações", ":material/notifications:", "Notificações"),
     ]
     niche_finder_items = [
         ("Niche Finder Kaggle", ":material/search:", "Niche Finder Kaggle"),
@@ -3489,7 +3706,8 @@ def main():
         "Automação": "Automação Youtube",
         "Canais": "Canais Youtube",
         "Blueprints": "Blueprints Youtube",
-        "Configurações Técnicas": "Configurações Técnicas",
+        "Configurações Técnicas": "Configuração API",
+        "Contas Google/YouTube — canais em lote": "Contas Google",
     }
     current_page = aliases.get(st.session_state.get("page", "Início"), st.session_state.get("page", "Início"))
     if current_page not in {item[0] for item in top_pages + pipeline_items + pipeline_tiktok_items + automation_items + edition_items + models_ai_items + niche_finder_items + settings_items}:
@@ -3545,6 +3763,7 @@ def main():
         "Criação de Músicas": render_music_creation,
         "Roteiros": render_scripts,
         "Prompts Master": render_tiktok_prompt_masters,
+        "Contas TikTok": render_tiktok_accounts,
         "Automação Youtube": render_automation,
         "Niche Finder Kaggle": render_niche_finder,
         "Niche Finder Apify": render_niche_finder_apify,
@@ -3553,13 +3772,16 @@ def main():
         "Cortes": render_cuts,
         "Editor Python": render_python_editor,
         "Models AI": lambda: render_edit_placeholder("Models AI", "Seleccione uma das abas Models AI no menu expansível."),
+        "Tutorial Meta": render_models_ai_tutorial,
         "Personagens": lambda: render_edit_placeholder("Personagens", "Área reservada para a futura funcionalidade de personagens."),
         "Redes Sociais": lambda: render_edit_placeholder("Redes Sociais", "Área reservada para a futura funcionalidade de redes sociais."),
         "Upload": render_upload,
         "Canais Youtube": render_channels,
         "Blueprints Youtube": render_blueprints,
         "MCP": render_mcp,
-        "Configurações Técnicas": render_settings,
+        "Contas Google": render_google_accounts,
+        "Configuração API": render_settings,
+        "Notificações": render_notifications,
     }
     renderers.get(current_page, render_dashboard)()