@danhachuel/thunderbolt 0.3.28 → 0.3.30

package/app/main.py

@@ -42,6 +42,7 @@ from hermes_ui.music import list_music_files, materialize_suno_audio, request_su
 from hermes_ui.media_downloader import AUDIO_FORMATS, VIDEO_CONTAINERS, VIDEO_QUALITY_OPTIONS, MediaDownloadError, build_download_options, clear_media_download_history, dependency_status, download_media, list_media_downloads, media_download_file
 from hermes_ui.notifications import clear_notifications, list_notifications, mark_all_notifications_read, mark_notification_read, notification_event_catalog, notification_preferences, record_notification, reconcile_persisted_notifications, save_notification_preferences, unread_notification_count
 from hermes_ui.languages import LANGUAGE_CODES, LANGUAGE_FLAG_DATA_URIS, language_code, language_label, ui_language_menu_label, ui_text, video_language_label, video_language_options
+from hermes_ui.api_key_tests import test_apify_credentials, test_kaggle_credentials, test_material_source_credentials, test_nano_banana_credentials, test_postiz_credentials, test_tiktok_credentials, test_upload_post_credentials, test_voice_provider
 
 from hermes_ui.script_documents import list_script_documents, read_script_document, save_script_document, script_storage_path
 from hermes_ui.script_generation import generate_script_document
@@ -4380,6 +4381,13 @@ def _render_material_source_card(settings: dict[str, Any], cards: list[dict[str,
                     value=active_card_id == card_id,
                     key=f"material_card_{card_id}_selected",
                 )
+            if not is_local:
+                _render_api_test_control(
+                    settings,
+                    f"material:{card_id}",
+                    lambda: test_material_source_credentials(provider, api_key),
+                    widget_key=f"api_test_material_{card_id}",
+                )
             save_card = st.form_submit_button("Salvar", type="primary", use_container_width=True, key=f"material_card_{card_id}_save")
         if save_card:
             cards[index] = {**card, "api_key": str(api_key or "").strip(), "enabled": bool(enabled)}
@@ -4438,6 +4446,61 @@ def _render_credential_status(value: Any, *, local: bool = False, required: bool
     _api_status_badge(label, kind)
 
 
+def _persist_api_test_result(settings: dict[str, Any], test_key: str, result: dict[str, Any]) -> dict[str, Any]:
+    """Persist only the safe diagnosis fields; never store credentials or endpoint details."""
+    safe_result = {
+        "status": str(result.get("status") or "error"),
+        "message": str(result.get("message") or "A chamada de diagnóstico falhou.")[:240],
+        "status_code": result.get("status_code"),
+        "checked_at": str(result.get("checked_at") or ""),
+    }
+    stored = settings.get("api_test_results")
+    if not isinstance(stored, dict):
+        stored = {}
+    stored[str(test_key)] = safe_result
+    settings["api_test_results"] = stored
+    write_json("settings.json", settings)
+    return safe_result
+
+
+def _render_api_test_feedback(settings: dict[str, Any], test_key: str, result: dict[str, Any] | None = None) -> None:
+    """Render the same compact green/red feedback for every non-LLM API card."""
+    current = result
+    if current is None:
+        stored = settings.get("api_test_results")
+        current = stored.get(test_key) if isinstance(stored, dict) else None
+    if not isinstance(current, dict):
+        return
+    status = str(current.get("status") or "error")
+    language = current_ui_language()
+    if status == "success":
+        st.success(ui_text("Último teste: API Key OK", language))
+        return
+    if status == "missing":
+        st.error(ui_text("Último teste: falta configuração", language))
+        return
+    if status == "unsupported":
+        st.warning(ui_text("Último teste: requer autorização ou endpoint seguro", language))
+        return
+    code = current.get("status_code")
+    suffix = f" (HTTP {int(code)})" if isinstance(code, int) and code > 0 else ""
+    st.error(ui_text("Último teste: chamada falhou", language) + suffix)
+
+
+def _render_api_test_control(settings: dict[str, Any], test_key: str, callback: Any, *, widget_key: str) -> None:
+    """Render a form-safe diagnostic button and persist its redacted result."""
+    if st.form_submit_button("Testar chamada API", use_container_width=True, key=widget_key):
+        with st.spinner(ui_text("A testar chamada API…", current_ui_language())):
+            try:
+                result = callback()
+            except Exception:
+                result = {"status": "error", "message": "A chamada de diagnóstico falhou."}
+        _persist_api_test_result(settings, test_key, result)
+        _render_api_test_feedback(settings, test_key, result)
+    else:
+        _render_api_test_feedback(settings, test_key)
+
+
 def _llm_card_config_status(card: dict[str, Any]) -> tuple[str, str]:
     definition = provider_definition(card.get("provider"))
     if definition.local:
@@ -4649,6 +4712,12 @@ def render_settings():
                     with kaggle_cols[2]:
                         kaggle_kernel_slug = text_setting("Slug da kernel", "kaggle_kernel_slug", help_text="Identificador da kernel remota, por exemplo thunderbolt-niche-finder.")
                     _render_credential_status(kaggle_api_key)
+                    _render_api_test_control(
+                        settings,
+                        "kaggle",
+                        lambda: test_kaggle_credentials(kaggle_username, kaggle_api_key),
+                        widget_key="api_test_kaggle",
+                    )
 
                 with st.expander("Niche Finder — Apify", expanded=False):
                     st.caption("O token fica guardado apenas no storage local. A aba Niche Finder Apify só usa este serviço depois de clicar no botão de pesquisa.")
@@ -4662,6 +4731,12 @@ 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)
                     _render_credential_status(apify_api_token)
+                    _render_api_test_control(
+                        settings,
+                        "apify",
+                        lambda: test_apify_credentials(apify_api_token),
+                        widget_key="api_test_apify",
+                    )
 
                 render_llm_provider_cards(settings, embedded=True)
 
@@ -4675,6 +4750,12 @@ def render_settings():
                         gemini_image_aspect_ratio = st.selectbox("Proporção da thumbnail", ["16:9", "9:16", "1:1", "4:5"], index=["16:9", "9:16", "1:1", "4:5"].index(str(settings.get("gemini_image_aspect_ratio") or "16:9")) if str(settings.get("gemini_image_aspect_ratio") or "16:9") in {"16:9", "9:16", "1:1", "4:5"} else 0)
                         gemini_image_size = st.selectbox("Tamanho da imagem", ["1K", "2K", "4K"], index=["1K", "2K", "4K"].index(str(settings.get("gemini_image_size") or "1K")) if str(settings.get("gemini_image_size") or "1K") in {"1K", "2K", "4K"} else 0)
                     _render_credential_status(gemini_image_api_key)
+                    _render_api_test_control(
+                        settings,
+                        "nano_banana",
+                        lambda: test_nano_banana_credentials(gemini_image_api_key, gemini_image_model),
+                        widget_key="api_test_nano_banana",
+                    )
 
 
                 with st.expander("Voz, TTS e música — Azure Speech, restantes serviços e Suno", expanded=False):
@@ -4707,11 +4788,65 @@ def render_settings():
                         suno_api_base_url = text_setting("Suno API Base URL", "suno_api_base_url", help_text="Use o endpoint compatível fornecido pelo seu acesso Suno; não é inventado pelo Thunderbolt.")
                         suno_api_endpoint = text_setting("Suno API endpoint", "suno_api_endpoint", help_text="Ex.: /api/generate")
 
+                    st.markdown(f"**{ui_text('Testar credenciais TTS e música', current_ui_language())}**")
+                    voice_test_cols = st.columns(3)
+                    with voice_test_cols[0]:
+                        _render_api_test_control(
+                            settings,
+                            "voice:azure_speech",
+                            lambda: test_voice_provider("azure_speech", {"azure_speech_key": azure_speech_key, "azure_speech_region": azure_speech_region}),
+                            widget_key="api_test_voice_azure",
+                        )
+                        _render_api_test_control(
+                            settings,
+                            "voice:siliconflow",
+                            lambda: test_voice_provider("siliconflow", {"siliconflow_tts_api_key": siliconflow_tts_api_key}),
+                            widget_key="api_test_voice_siliconflow",
+                        )
+                        _render_api_test_control(
+                            settings,
+                            "voice:minimax",
+                            lambda: test_voice_provider("minimax", {"minimax_tts_api_key": minimax_tts_api_key, "minimax_tts_base_url": minimax_tts_base_url}),
+                            widget_key="api_test_voice_minimax",
+                        )
+                    with voice_test_cols[1]:
+                        _render_api_test_control(
+                            settings,
+                            "voice:elevenlabs",
+                            lambda: test_voice_provider("elevenlabs", {"elevenlabs_api_key": elevenlabs_api_key}),
+                            widget_key="api_test_voice_elevenlabs",
+                        )
+                        _render_api_test_control(
+                            settings,
+                            "voice:chatterbox",
+                            lambda: test_voice_provider("chatterbox", {"chatterbox_api_key": chatterbox_api_key, "chatterbox_base_url": chatterbox_base_url}),
+                            widget_key="api_test_voice_chatterbox",
+                        )
+                    with voice_test_cols[2]:
+                        _render_api_test_control(
+                            settings,
+                            "voice:sonilo",
+                            lambda: test_voice_provider("sonilo", {"sonilo_api_key": sonilo_api_key, "sonilo_base_url": sonilo_base_url}),
+                            widget_key="api_test_voice_sonilo",
+                        )
+                        _render_api_test_control(
+                            settings,
+                            "voice:suno",
+                            lambda: test_voice_provider("suno", {"suno_api_key": suno_api_key, "suno_api_base_url": suno_api_base_url, "suno_api_endpoint": suno_api_endpoint}),
+                            widget_key="api_test_voice_suno",
+                        )
+
                 with st.expander("TikTok for Developers — Client ID e Client Secret", expanded=False):
                     st.caption("Apenas as credenciais da aplicação ficam nesta UI. Redirect URI, scopes, autorização e tokens são geridos no TikTok for Developers Playground.")
                     tiktok_client_key = text_setting("TikTok Client ID", "tiktok_client_key", secret=True)
                     _render_credential_status(tiktok_client_key)
                     tiktok_client_secret = text_setting("TikTok Client Secret", "tiktok_client_secret", secret=True)
+                    _render_api_test_control(
+                        settings,
+                        "tiktok",
+                        lambda: test_tiktok_credentials(tiktok_client_key, tiktok_client_secret, settings.get("tiktok_access_token", "")),
+                        widget_key="api_test_tiktok",
+                    )
 
                 with st.expander("Publicação através do Upload-Post", expanded=False):
                     upload_post_enabled = st.checkbox("Activar Upload-Post", bool(settings.get("upload_post_enabled", False)))
@@ -4720,6 +4855,12 @@ def render_settings():
                     upload_post_username = text_setting("Upload-Post username", "upload_post_username")
                     upload_post_platforms = text_setting("Plataformas Upload-Post", "upload_post_platforms")
                     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 — API key, integração e MCP", 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.")
@@ -4735,6 +4876,12 @@ def render_settings():
                         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",
+                    )
 
                 save_all_settings = st.form_submit_button("Guardar configurações do Thunderbolt", type="primary")
                 if save_all_settings:

package/hermes_ui/api_key_tests.py

@@ -0,0 +1,266 @@
+"""Safe, read-only API credential diagnostics used by the Settings UI.
+
+Every check in this module is deliberately bounded and avoids uploads, posts,
+actor runs, image generation and audio generation.  Results contain no secret,
+URL or raw exception text; callers may persist them in local settings safely.
+"""
+
+from __future__ import annotations
+
+import os
+from datetime import datetime, timezone
+from typing import Any
+from urllib.parse import quote, urlsplit, urlunsplit
+
+import requests
+
+from app.modules.niche_finder.apify import APIFY_API_BASE
+
+DEFAULT_TIMEOUT = 20
+
+
+def _result(status: str, message: str, *, status_code: int | None = None) -> dict[str, Any]:
+    """Build a small persistence-safe result object."""
+    return {
+        "ok": status == "success",
+        "status": status,
+        "message": message,
+        "status_code": status_code,
+        "checked_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+    }
+
+
+def _missing(message: str = "Introduza a credencial antes de testar.") -> dict[str, Any]:
+    return _result("missing", message)
+
+
+def _unsupported(message: str) -> dict[str, Any]:
+    return _result("unsupported", message)
+
+
+def _safe_url(value: str) -> str:
+    """Keep a configured base URL's scheme/host only; never echo credentials."""
+    try:
+        parsed = urlsplit(str(value or "").strip())
+        if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+            return ""
+        return urlunsplit((parsed.scheme, parsed.netloc, parsed.path.rstrip("/"), "", ""))
+    except ValueError:
+        return ""
+
+
+def _response_result(response: Any) -> dict[str, Any]:
+    status_code = int(getattr(response, "status_code", 0) or 0)
+    if 200 <= status_code < 300:
+        return _result("success", "API Key OK", status_code=status_code)
+    if status_code in {401, 403}:
+        return _result("error", "A API rejeitou a credencial.", status_code=status_code)
+    if status_code == 404:
+        return _result("error", "O endpoint de diagnóstico não está disponível.", status_code=status_code)
+    if status_code == 429:
+        return _result("error", "A API limitou a chamada de diagnóstico.", status_code=status_code)
+    return _result("error", "A chamada de diagnóstico falhou.", status_code=status_code or None)
+
+
+def _get(url: str, **kwargs: Any) -> dict[str, Any]:
+    try:
+        response = requests.get(url, timeout=DEFAULT_TIMEOUT, **kwargs)
+    except requests.RequestException:
+        return _result("error", "Não foi possível contactar o serviço.")
+    return _response_result(response)
+
+
+def _post(url: str, **kwargs: Any) -> dict[str, Any]:
+    try:
+        response = requests.post(url, timeout=DEFAULT_TIMEOUT, **kwargs)
+    except requests.RequestException:
+        return _result("error", "Não foi possível contactar o serviço.")
+    return _response_result(response)
+
+
+def test_kaggle_credentials(username: str, api_key: str) -> dict[str, Any]:
+    """Validate Kaggle Basic Auth with a read-only user lookup."""
+    username = str(username or "").strip()
+    api_key = str(api_key or "").strip()
+    if not username or not api_key:
+        return _missing("Introduza o username e a API key Kaggle antes de testar.")
+    return _get(f"https://www.kaggle.com/api/v1/users/list/{quote(username, safe='')}", auth=(username, api_key))
+
+
+def test_apify_credentials(api_token: str) -> dict[str, Any]:
+    """Validate an Apify token without starting an Actor or reading a dataset."""
+    api_token = str(api_token or "").strip()
+    if not api_token:
+        return _missing()
+    return _get(f"{APIFY_API_BASE}/users/me", headers={"Authorization": f"Bearer {api_token}"})
+
+
+def test_nano_banana_credentials(api_key: str, model: str) -> dict[str, Any]:
+    """Validate the configured Gemini image model metadata without generating an image."""
+    api_key = str(api_key or "").strip()
+    model = str(model or "").strip()
+    if not api_key:
+        return _missing()
+    if not model:
+        return _result("missing", "Complete a configuração do modelo antes de testar.")
+    model_path = model if model.startswith("models/") else f"models/{model}"
+    return _get(
+        f"https://generativelanguage.googleapis.com/v1beta/{model_path}",
+        headers={"x-goog-api-key": api_key},
+    )
+
+
+def test_azure_speech_credentials(api_key: str, region: str) -> dict[str, Any]:
+    """Validate Azure Speech by listing voices; this does not synthesize audio."""
+    api_key = str(api_key or "").strip()
+    region = str(region or "").strip().lower()
+    if not api_key or not region:
+        return _missing("Introduza a Azure Speech key e a região antes de testar.")
+    if not region.replace("-", "").isalnum():
+        return _result("error", "A região Azure Speech não é válida.")
+    endpoint = f"https://{region}.tts.speech.microsoft.com/tts/cognitiveservices/voices/list"
+    return _get(endpoint, headers={"Ocp-Apim-Subscription-Key": api_key})
+
+
+def test_elevenlabs_credentials(api_key: str) -> dict[str, Any]:
+    """Validate ElevenLabs with the documented read-only models endpoint."""
+    api_key = str(api_key or "").strip()
+    if not api_key:
+        return _missing()
+    return _get("https://api.elevenlabs.io/v1/models", headers={"xi-api-key": api_key})
+
+
+def _models_endpoint(base_url: str) -> str:
+    base = _safe_url(base_url)
+    if not base:
+        return ""
+    return f"{base}/models" if base.endswith("/v1") else f"{base}/v1/models"
+
+
+def test_siliconflow_credentials(api_key: str) -> dict[str, Any]:
+    """Validate SiliconFlow with its read-only model catalogue."""
+    api_key = str(api_key or "").strip()
+    if not api_key:
+        return _missing()
+    return _get("https://api.siliconflow.cn/v1/models", headers={"Authorization": f"Bearer {api_key}"})
+
+
+def test_minimax_credentials(api_key: str, base_url: str) -> dict[str, Any]:
+    """Validate a configured MiniMax endpoint without calling text-to-audio."""
+    api_key = str(api_key or "").strip()
+    endpoint = _models_endpoint(base_url)
+    if not api_key or not str(base_url or "").strip():
+        return _missing("Introduza a MiniMax TTS key e a Base URL antes de testar.")
+    if not endpoint:
+        return _result("error", "A Base URL MiniMax não é válida.")
+    return _get(endpoint, headers={"Authorization": f"Bearer {api_key}"})
+
+
+def test_openai_compatible_voice_credentials(provider: str, api_key: str, base_url: str) -> dict[str, Any]:
+    """Validate a local/custom voice service through a read-only models endpoint."""
+    provider = str(provider or "serviço").strip()
+    api_key = str(api_key or "").strip()
+    endpoint = _models_endpoint(base_url)
+    if not str(base_url or "").strip():
+        return _missing(f"Introduza a Base URL de {provider} antes de testar.")
+    if not endpoint:
+        return _result("error", f"A Base URL de {provider} não é válida.")
+    headers = {"Authorization": f"Bearer {api_key}"} if api_key else {}
+    return _get(endpoint, headers=headers)
+
+
+def test_suno_credentials(api_key: str, base_url: str, endpoint: str) -> dict[str, Any]:
+    """Avoid a Suno generation call: custom deployments have no common safe health API."""
+    if not str(api_key or "").strip() or not str(base_url or "").strip():
+        return _missing("Introduza a Suno API key e a Base URL antes de testar.")
+    return _unsupported("Suno requer um endpoint de diagnóstico fornecido pelo serviço; o Thunderbolt não inicia uma geração só para testar.")
+
+
+def test_tiktok_credentials(client_key: str, client_secret: str, access_token: str = "") -> dict[str, Any]:
+    """Validate TikTok only when an OAuth access token is available."""
+    client_key = str(client_key or "").strip()
+    client_secret = str(client_secret or "").strip()
+    token = str(access_token or os.getenv("TIKTOK_ACCESS_TOKEN", "") or "").strip()
+    if not client_key or not client_secret:
+        return _missing("Introduza o Client ID e o Client Secret TikTok antes de testar.")
+    if not token:
+        return _unsupported("TikTok só permite uma chamada autenticada depois da autorização OAuth; conclua o Playground e guarde um access token.")
+    return _get(
+        "https://open.tiktokapis.com/v2/user/info/?fields=open_id",
+        headers={"Authorization": f"Bearer {token}"},
+    )
+
+
+def test_upload_post_credentials(api_key: str, base_url: str = "https://api.upload-post.com/api") -> dict[str, Any]:
+    """Validate Upload-Post through GET /uploadposts/me, never through an upload."""
+    api_key = str(api_key or "").strip()
+    base = _safe_url(base_url or "https://api.upload-post.com/api")
+    if not api_key:
+        return _missing()
+    if not base:
+        return _result("error", "A Base URL Upload-Post não é válida.")
+    return _get(f"{base}/uploadposts/me", headers={"Authorization": f"Apikey {api_key}"})
+
+
+def test_postiz_credentials(api_key: str, base_url: str = "https://api.postiz.com/public/v1") -> dict[str, Any]:
+    """Validate Postiz with the read-only integrations endpoint."""
+    api_key = str(api_key or "").strip()
+    base = _safe_url(base_url or "https://api.postiz.com/public/v1")
+    if not api_key:
+        return _missing()
+    if not base:
+        return _result("error", "A Base URL Postiz não é válida.")
+    return _get(f"{base}/integrations", headers={"Authorization": api_key})
+
+
+def test_material_source_credentials(provider: str, api_key: str) -> dict[str, Any]:
+    """Run a read-only provider-specific check for material source cards."""
+    provider = str(provider or "").strip().lower()
+    api_key = str(api_key or "").strip()
+    if not api_key:
+        return _missing()
+    if provider == "pexels":
+        return _get("https://api.pexels.com/v1/curated", params={"per_page": 1}, headers={"Authorization": api_key})
+    if provider == "pixabay":
+        return _get("https://pixabay.com/api/", params={"key": api_key, "per_page": 3})
+    if provider == "coverr":
+        return _get("https://api.coverr.co/v1/videos", headers={"Authorization": f"Bearer {api_key}"})
+    return _unsupported("Este provider de materiais não expõe um endpoint de diagnóstico seguro no cartão actual.")
+
+
+def test_voice_provider(provider: str, settings: dict[str, Any]) -> dict[str, Any]:
+    """Dispatch a non-generating check for one provider in the voice/music group."""
+    provider = str(provider or "").strip().lower()
+    if provider == "azure_speech":
+        return test_azure_speech_credentials(settings.get("azure_speech_key", ""), settings.get("azure_speech_region", ""))
+    if provider == "elevenlabs":
+        return test_elevenlabs_credentials(settings.get("elevenlabs_api_key", ""))
+    if provider == "siliconflow":
+        return test_siliconflow_credentials(settings.get("siliconflow_tts_api_key", ""))
+    if provider == "minimax":
+        return test_minimax_credentials(settings.get("minimax_tts_api_key", ""), settings.get("minimax_tts_base_url", ""))
+    if provider == "chatterbox":
+        return test_openai_compatible_voice_credentials("Chatterbox", settings.get("chatterbox_api_key", ""), settings.get("chatterbox_base_url", ""))
+    if provider == "sonilo":
+        return test_openai_compatible_voice_credentials("Sonilo", settings.get("sonilo_api_key", ""), settings.get("sonilo_base_url", ""))
+    if provider == "suno":
+        return test_suno_credentials(settings.get("suno_api_key", ""), settings.get("suno_api_base_url", ""), settings.get("suno_api_endpoint", ""))
+    return _unsupported("Este provider de voz não tem diagnóstico remoto configurado.")
+
+
+__all__ = [
+    "test_apify_credentials",
+    "test_azure_speech_credentials",
+    "test_elevenlabs_credentials",
+    "test_kaggle_credentials",
+    "test_material_source_credentials",
+    "test_minimax_credentials",
+    "test_nano_banana_credentials",
+    "test_openai_compatible_voice_credentials",
+    "test_postiz_credentials",
+    "test_siliconflow_credentials",
+    "test_suno_credentials",
+    "test_tiktok_credentials",
+    "test_upload_post_credentials",
+    "test_voice_provider",
+]

package/hermes_ui/languages.py

@@ -1222,3 +1222,91 @@ _MATERIAL_SOURCE_TRANSLATIONS: dict[str, dict[str, str]] = {
 }
 for _language_code, _material_source_translation in _MATERIAL_SOURCE_TRANSLATIONS.items():
     UI_TRANSLATIONS[_language_code].update(_material_source_translation)
+
+
+# API credential diagnostics. Keep these keys stable because the settings
+# renderer calls ui_text() for every visible result in all supported languages.
+_API_TEST_TRANSLATIONS: dict[str, dict[str, str]] = {
+    "pt": {
+        "A testar chamada API…": "A testar chamada API…",
+        "Último teste: API Key OK": "Último teste: API Key OK",
+        "Último teste: falta configuração": "Último teste: falta configuração",
+        "Último teste: requer autorização ou endpoint seguro": "Último teste: requer autorização ou endpoint seguro",
+        "Último teste: chamada falhou": "Último teste: chamada falhou",
+        "Testar credenciais TTS e música": "Testar credenciais TTS e música",
+    },
+    "en": {
+        "A testar chamada API…": "Testing API call…",
+        "Último teste: API Key OK": "Last test: API key OK",
+        "Último teste: falta configuração": "Last test: configuration missing",
+        "Último teste: requer autorização ou endpoint seguro": "Last test: additional authorization or a safe endpoint is required",
+        "Último teste: chamada falhou": "Last test: call failed",
+        "Testar credenciais TTS e música": "Test TTS and music credentials",
+    },
+    "zh": {
+        "A testar chamada API…": "正在测试 API 调用…",
+        "Último teste: API Key OK": "上次测试：API 密钥正常",
+        "Último teste: falta configuração": "上次测试：缺少配置",
+        "Último teste: requer autorização ou endpoint seguro": "上次测试：需要额外授权或安全端点",
+        "Último teste: chamada falhou": "上次测试：调用失败",
+        "Testar credenciais TTS e música": "测试 TTS 和音乐凭证",
+    },
+    "de": {
+        "A testar chamada API…": "API-Aufruf wird getestet…",
+        "Último teste: API Key OK": "Letzter Test: API-Schlüssel OK",
+        "Último teste: falta configuração": "Letzter Test: Konfiguration fehlt",
+        "Último teste: requer autorização ou endpoint seguro": "Letzter Test: zusätzliche Autorisierung oder ein sicherer Endpunkt erforderlich",
+        "Último teste: chamada falhou": "Letzter Test: Aufruf fehlgeschlagen",
+        "Testar credenciais TTS e música": "TTS- und Musik-Anmeldedaten testen",
+    },
+    "vi": {
+        "A testar chamada API…": "Đang kiểm tra lệnh gọi API…",
+        "Último teste: API Key OK": "Lần kiểm tra cuối: Khóa API hợp lệ",
+        "Último teste: falta configuração": "Lần kiểm tra cuối: Thiếu cấu hình",
+        "Último teste: requer autorização ou endpoint seguro": "Lần kiểm tra cuối: Cần ủy quyền bổ sung hoặc endpoint an toàn",
+        "Último teste: chamada falhou": "Lần kiểm tra cuối: Lệnh gọi thất bại",
+        "Testar credenciais TTS e música": "Kiểm tra thông tin xác thực TTS và âm nhạc",
+    },
+    "tr": {
+        "A testar chamada API…": "API çağrısı test ediliyor…",
+        "Último teste: API Key OK": "Son test: API anahtarı OK",
+        "Último teste: falta configuração": "Son test: yapılandırma eksik",
+        "Último teste: requer autorização ou endpoint seguro": "Son test: ek yetkilendirme veya güvenli uç nokta gerekli",
+        "Último teste: chamada falhou": "Son test: çağrı başarısız",
+        "Testar credenciais TTS e música": "TTS ve müzik kimlik bilgilerini test et",
+    },
+    "ru": {
+        "A testar chamada API…": "Проверка вызова API…",
+        "Último teste: API Key OK": "Последняя проверка: API-ключ действителен",
+        "Último teste: falta configuração": "Последняя проверка: не хватает конфигурации",
+        "Último teste: requer autorização ou endpoint seguro": "Последняя проверка: требуется дополнительная авторизация или безопасный эндпоинт",
+        "Último teste: chamada falhou": "Последняя проверка: вызов не выполнен",
+        "Testar credenciais TTS e música": "Проверить учётные данные TTS и музыки",
+    },
+    "es": {
+        "A testar chamada API…": "Probando la llamada API…",
+        "Último teste: API Key OK": "Última prueba: clave API correcta",
+        "Último teste: falta configuração": "Última prueba: falta configuración",
+        "Último teste: requer autorização ou endpoint seguro": "Última prueba: se requiere autorización adicional o un endpoint seguro",
+        "Último teste: chamada falhou": "Última prueba: la llamada falló",
+        "Testar credenciais TTS e música": "Probar credenciales de TTS y música",
+    },
+    "id": {
+        "A testar chamada API…": "Menguji panggilan API…",
+        "Último teste: API Key OK": "Tes terakhir: Kunci API OK",
+        "Último teste: falta configuração": "Tes terakhir: konfigurasi tidak lengkap",
+        "Último teste: requer autorização ou endpoint seguro": "Tes terakhir: diperlukan otorisasi tambahan atau endpoint aman",
+        "Último teste: chamada falhou": "Tes terakhir: panggilan gagal",
+        "Testar credenciais TTS e música": "Uji kredensial TTS dan musik",
+    },
+    "it": {
+        "A testar chamada API…": "Test della chiamata API in corso…",
+        "Último teste: API Key OK": "Ultimo test: chiave API OK",
+        "Último teste: falta configuração": "Ultimo test: configurazione mancante",
+        "Último teste: requer autorização ou endpoint seguro": "Ultimo test: è necessaria un'autorizzazione aggiuntiva o un endpoint sicuro",
+        "Último teste: chamada falhou": "Ultimo test: chiamata non riuscita",
+        "Testar credenciais TTS e música": "Testa le credenziali TTS e musica",
+    },
+}
+for _language_code, _api_test_values in _API_TEST_TRANSLATIONS.items():
+    UI_TRANSLATIONS[_language_code].update(_api_test_values)

package/package.json

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