@danhachuel/thunderbolt 0.3.28 → 0.3.29

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.29",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "license": "MIT",
   "main": "scripts/cli.mjs",