@danhachuel/thunderbolt 0.3.34 → 0.3.36

package/app/main.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import hashlib
 import html
 import json
+import mimetypes
 import re
 from contextlib import nullcontext
 from datetime import date, datetime
@@ -42,7 +43,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, VIDEO_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.api_key_tests import test_apify_credentials, test_kaggle_credentials, test_material_source_credentials, test_nano_banana_credentials, test_postiz_credentials, test_telegram_credentials, test_tiktok_credentials, test_upload_post_credentials, test_voice_provider
 from hermes_ui.tutorials import tutorial_body, tutorial_caption, tutorial_title
 
 from hermes_ui.script_documents import list_script_documents, read_script_document, save_script_document, script_storage_path
@@ -64,6 +65,7 @@ from integrations.platforms import IntegrationResult, TikTokAdapter, YouTubeAdap
 from integrations.tiktok_public import fetch_public_tiktok_profile, normalize_tiktok_reference
 from integrations.postiz import PostizAdapter
 from integrations.upload_post import UploadPostAdapter, UPLOAD_POST_PLATFORM_OPTIONS, normalize_upload_post_platforms
+from integrations.music_uploads import JewelMusicAdapter, PushtunesAdapter, YTMusicApiAdapter, MUSIC_UPLOAD_EXTENSIONS, PUSHTUNES_OPERATIONS, PUSHTUNES_SOURCES, PUSHTUNES_TARGETS, YT_MUSIC_UPLOAD_EXTENSIONS
 from integrations.upload_routing import OFFICIAL_DAILY_LIMIT, official_upload_count, upload_with_default_route
 from integrations.youtube_direct_upload import YouTubeDirectUploader
 from integrations.youtube_direct_credentials import delete_credentials_document, direct_account_status, document_status, ensure_credentials_document, load_credentials_document, merge_credentials_document, parse_credentials_document, save_credentials_document, update_credentials_document_session_info
@@ -3707,6 +3709,277 @@ def render_upload_direct():
                     (st.success if result.ok else st.error)(result.message)
 
 
+def _persist_music_upload_settings(updates: dict[str, Any]) -> dict[str, Any]:
+    settings = read_json("settings.json", {})
+    settings.update(updates)
+    write_json("settings.json", settings)
+    return settings
+
+
+def _render_music_source(prefix: str, extensions: set[str]) -> str:
+    source_mode = st.radio(
+        "Origem da música",
+        ["Ficheiro existente", "Carregar ficheiro"],
+        horizontal=True,
+        key=f"{prefix}_music_source_mode",
+    )
+    selected_path = str(st.session_state.get(f"{prefix}_music_path") or "")
+    if source_mode == "Ficheiro existente":
+        existing = [path for path in list_music_files() if path.suffix.lower() in extensions]
+        if existing:
+            selected = st.selectbox(
+                "Música local",
+                existing,
+                index=next((index for index, item in enumerate(existing) if str(item) == selected_path), 0),
+                format_func=lambda item: item.name,
+                key=f"{prefix}_music_existing",
+            )
+            selected_path = str(selected)
+            st.session_state[f"{prefix}_music_path"] = selected_path
+        else:
+            st.info("Ainda não existem ficheiros compatíveis em storage/music. Escolha Carregar ficheiro.")
+            selected_path = ""
+    else:
+        uploaded = st.file_uploader(
+            "Carregar ficheiro de música",
+            type=sorted(extension.lstrip(".") for extension in extensions),
+            key=f"{prefix}_music_file_upload",
+        )
+        if uploaded is not None and st.button("Guardar música no storage local", key=f"{prefix}_music_store", use_container_width=True):
+            try:
+                stored = store_music_file(uploaded.name, uploaded.getvalue())
+                selected_path = str(stored)
+                st.session_state[f"{prefix}_music_path"] = selected_path
+                st.success(f"Música guardada em `{stored}`.")
+            except (OSError, ValueError) as exc:
+                st.error(str(exc))
+        selected_path = str(st.session_state.get(f"{prefix}_music_path") or selected_path)
+    if selected_path and Path(selected_path).is_file():
+        st.caption(f"Ficheiro seleccionado: `{selected_path}`")
+        return selected_path
+    return ""
+
+
+def _record_music_upload(destination: str, result: IntegrationResult, *, music_path: str = "", target: dict[str, Any] | None = None) -> dict[str, Any]:
+    record = {
+        "id": uuid.uuid4().hex,
+        "destination": destination,
+        "music_path": music_path,
+        "target": target or {},
+        "status": "published" if result.ok else "failed",
+        "message": result.message,
+        "data": result.data,
+        "created_at": now(),
+    }
+    uploads = read_json("uploads.json", [])
+    uploads.append(record)
+    write_json("uploads.json", uploads)
+    reconcile_persisted_notifications()
+    return record
+
+
+def _render_music_upload_history() -> None:
+    records = [
+        record
+        for record in read_json("uploads.json", [])
+        if isinstance(record, dict)
+        and any(name in str(record.get("destination") or "").lower() for name in ("jewelmusic", "pushtunes", "youtube music", "ytmusicapi"))
+    ]
+    st.divider()
+    st.subheader("Histórico de uploads de música")
+    if not records:
+        st.caption("Ainda não existem uploads de música registados.")
+        return
+    for record in reversed(records[-20:]):
+        status = "Concluído" if record.get("status") == "published" else "Falhou"
+        path = Path(str(record.get("music_path") or ""))
+        with st.container(border=True):
+            st.write(f"**{record.get('destination', 'Upload musical')}** · {status}")
+            st.caption(f"{record.get('created_at', '—')} · {path.name if path.name else record.get('target', {})}")
+            st.write(record.get("message", ""))
+            if path.is_file():
+                st.download_button(
+                    "Descarregar cópia local",
+                    data=path.read_bytes(),
+                    file_name=path.name,
+                    mime=mimetypes.guess_type(path.name)[0] or "audio/mpeg",
+                    key=f"music_history_download_{record.get('id')}",
+                )
+
+
+def _render_jewelmusic_upload_tab() -> None:
+    st.subheader("JewelMusic")
+    st.caption("Upload de tracks para o JewelMusic através do endpoint documentado do SDK, com distribuição posterior para as plataformas disponíveis na sua conta.")
+    st.info("A API Key é guardada apenas no settings.json local. O teste consulta /v1/ping e não cria uma track.")
+    settings = read_json("settings.json", {})
+    with st.form("jewelmusic_settings_form"):
+        enabled = st.checkbox("Activar JewelMusic", value=bool(settings.get("jewelmusic_enabled", False)))
+        api_key = st.text_input("JewelMusic API Key", value=str(settings.get("jewelmusic_api_key") or ""), type="password")
+        base_url = st.text_input("Base URL", value=str(settings.get("jewelmusic_base_url") or "https://api.jewelmusic.com"))
+        proxy_url = st.text_input("Proxy opcional", value=str(settings.get("jewelmusic_proxy_url") or ""), placeholder="http://127.0.0.1:8080")
+        timeout_seconds = st.number_input("Timeout (segundos)", min_value=5, max_value=900, value=int(settings.get("jewelmusic_timeout_seconds", 120)), step=5)
+        save = st.form_submit_button("Guardar configuração JewelMusic", type="primary", use_container_width=True)
+    if save:
+        settings = _persist_music_upload_settings({
+            "jewelmusic_enabled": bool(enabled),
+            "jewelmusic_api_key": api_key.strip(),
+            "jewelmusic_base_url": base_url.strip().rstrip("/"),
+            "jewelmusic_proxy_url": proxy_url.strip(),
+            "jewelmusic_timeout_seconds": int(timeout_seconds),
+        })
+        st.success("Configuração JewelMusic guardada no storage local.")
+    adapter = JewelMusicAdapter(settings)
+    if st.button("Testar conexão JewelMusic", key="jewelmusic_test", use_container_width=True):
+        test_result = adapter.test_connection()
+        (st.success if test_result.ok else st.error)(test_result.message)
+    music_path = _render_music_source("jewelmusic", MUSIC_UPLOAD_EXTENSIONS)
+    metadata_cols = st.columns(4)
+    with metadata_cols[0]:
+        title = st.text_input("Título", value=Path(music_path).stem if music_path else "", key="jewelmusic_title")
+    with metadata_cols[1]:
+        artist = st.text_input("Artista", key="jewelmusic_artist")
+    with metadata_cols[2]:
+        album = st.text_input("Álbum", key="jewelmusic_album")
+    with metadata_cols[3]:
+        year = st.text_input("Ano", key="jewelmusic_year")
+    genre = st.text_input("Género", key="jewelmusic_genre")
+    if st.button("Enviar música para JewelMusic", type="primary", key="jewelmusic_upload", use_container_width=True, disabled=not bool(music_path)):
+        result = JewelMusicAdapter(read_json("settings.json", {})).upload_track(music_path, title=title, artist=artist, album=album, year=year, genre=genre)
+        _record_music_upload("JewelMusic", result, music_path=music_path, target={"artist": artist, "title": title})
+        (st.success if result.ok else st.error)(result.message)
+
+
+def _store_pushtunes_csv(uploaded: Any) -> str:
+    target = STORAGE / "music" / "pushtunes-source.csv"
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_bytes(uploaded.getvalue())
+    return str(target)
+
+
+def _render_pushtunes_upload_tab() -> None:
+    st.subheader("Pushtunes")
+    st.caption("Sincronização de biblioteca a partir de Subsonic, Jellyfin ou CSV para Spotify, YouTube Music ou Tidal. Pushtunes não transforma um MP3 isolado num upload; para isso use JewelMusic ou ytmusicapi.")
+    st.warning("O Pushtunes usa as credenciais próprias dos serviços. O Thunderbolt apenas inicia o comando local com parâmetros separados e mascara os segredos na saída.")
+    settings = read_json("settings.json", {})
+    with st.form("pushtunes_settings_form"):
+        enabled = st.checkbox("Activar Pushtunes", value=bool(settings.get("pushtunes_enabled", False)))
+        executable = st.text_input("Executável ou módulo", value=str(settings.get("pushtunes_executable") or "pushtunes"), help="Por padrão é usado o comando pushtunes instalado no ambiente Python do Thunderbolt.")
+        source = st.selectbox("Fonte", list(PUSHTUNES_SOURCES), index=list(PUSHTUNES_SOURCES).index(str(settings.get("pushtunes_source") or "csv")) if str(settings.get("pushtunes_source") or "csv") in PUSHTUNES_SOURCES else 0, format_func=lambda value: {"csv": "CSV local", "subsonic": "Subsonic/Navidrome", "jellyfin": "Jellyfin", "spotify": "Spotify", "ytm": "YouTube Music"}.get(value, value))
+        target = st.selectbox("Destino", list(PUSHTUNES_TARGETS), index=list(PUSHTUNES_TARGETS).index(str(settings.get("pushtunes_target") or "ytm")) if str(settings.get("pushtunes_target") or "ytm") in PUSHTUNES_TARGETS else 0, format_func=lambda value: {"spotify": "Spotify", "ytm": "YouTube Music", "tidal": "Tidal", "csv": "CSV"}.get(value, value))
+        operation = st.selectbox("Operação", list(PUSHTUNES_OPERATIONS), index=list(PUSHTUNES_OPERATIONS).index(str(settings.get("pushtunes_operation") or "tracks")) if str(settings.get("pushtunes_operation") or "tracks") in PUSHTUNES_OPERATIONS else 0, format_func=lambda value: {"tracks": "Tracks", "albums": "Álbuns", "playlist": "Playlist"}.get(value, value))
+        profile = st.text_input("Perfil Pushtunes (.toml), opcional", value=str(settings.get("pushtunes_profile") or ""))
+        csv_file = st.text_input("Caminho CSV", value=str(settings.get("pushtunes_csv_file") or ""))
+        ytm_auth_file = st.text_input("Caminho browser.json do YouTube Music", value=str(settings.get("pushtunes_ytm_auth_file") or ""))
+        tidal_session_file = st.text_input("Caminho tidal-session.json do Tidal", value=str(settings.get("pushtunes_tidal_session_file") or ""))
+        playlist_name = st.text_input("Nome da playlist", value=str(settings.get("pushtunes_playlist_name") or ""))
+        similarity = st.slider("Similaridade mínima", min_value=0.0, max_value=1.0, value=float(settings.get("pushtunes_similarity", 0.8)), step=0.05)
+        working_directory = st.text_input("Directório de trabalho", value=str(settings.get("pushtunes_working_directory") or ""))
+        spotify_client_id = st.text_input("Spotify Client ID", value=str(settings.get("pushtunes_spotify_client_id") or ""))
+        spotify_client_secret = st.text_input("Spotify Client Secret", value=str(settings.get("pushtunes_spotify_client_secret") or ""), type="password")
+        spotify_redirect_uri = st.text_input("Spotify Redirect URI", value=str(settings.get("pushtunes_spotify_redirect_uri") or ""))
+        timeout_seconds = st.number_input("Timeout Pushtunes (segundos)", min_value=30, max_value=3600, value=int(settings.get("pushtunes_timeout_seconds", 1800)), step=30)
+        save = st.form_submit_button("Guardar configuração Pushtunes", type="primary", use_container_width=True)
+    if save:
+        settings = _persist_music_upload_settings({
+            "pushtunes_enabled": bool(enabled),
+            "pushtunes_executable": executable.strip() or "pushtunes",
+            "pushtunes_source": source,
+            "pushtunes_target": target,
+            "pushtunes_operation": operation,
+            "pushtunes_profile": profile.strip(),
+            "pushtunes_csv_file": csv_file.strip(),
+            "pushtunes_ytm_auth_file": ytm_auth_file.strip(),
+            "pushtunes_tidal_session_file": tidal_session_file.strip(),
+            "pushtunes_playlist_name": playlist_name.strip(),
+            "pushtunes_similarity": float(similarity),
+            "pushtunes_working_directory": working_directory.strip(),
+            "pushtunes_spotify_client_id": spotify_client_id.strip(),
+            "pushtunes_spotify_client_secret": spotify_client_secret.strip(),
+            "pushtunes_spotify_redirect_uri": spotify_redirect_uri.strip(),
+            "pushtunes_timeout_seconds": int(timeout_seconds),
+        })
+        st.success("Configuração Pushtunes guardada no storage local.")
+    if source == "csv":
+        st.caption("Pode carregar o CSV nesta página e usar o caminho guardado como origem Pushtunes.")
+        csv_upload = st.file_uploader("Carregar CSV de origem Pushtunes", type=["csv"], key="pushtunes_csv_upload")
+        if csv_upload is not None and st.button("Guardar CSV Pushtunes no storage", key="pushtunes_csv_store", use_container_width=True):
+            stored_csv = _store_pushtunes_csv(csv_upload)
+            settings = _persist_music_upload_settings({"pushtunes_csv_file": stored_csv})
+            st.success(f"CSV guardado em `{stored_csv}`.")
+    adapter = PushtunesAdapter(read_json("settings.json", {}))
+    status = adapter.status()
+    (st.success if status.ok else st.warning)(status.message)
+    if st.button("Validar instalação e configuração Pushtunes", key="pushtunes_test", use_container_width=True):
+        check = PushtunesAdapter(read_json("settings.json", {})).status()
+        (st.success if check.ok else st.error)(check.message)
+    if st.button("Executar sincronização Pushtunes", type="primary", key="pushtunes_sync", use_container_width=True, disabled=not status.ok):
+        result = PushtunesAdapter(read_json("settings.json", {})).sync()
+        _record_music_upload(f"Pushtunes ({adapter.source} → {adapter.target})", result, target={"source": adapter.source, "target": adapter.target, "operation": adapter.operation})
+        (st.success if result.ok else st.error)(result.message)
+        if result.data.get("stdout") or result.data.get("stderr"):
+            with st.expander("Saída técnica do Pushtunes"):
+                st.text(result.data.get("stdout", ""))
+                if result.data.get("stderr"):
+                    st.text(result.data["stderr"])
+
+
+def _store_ytmusicapi_auth(uploaded: Any) -> str:
+    target = STORAGE / "ytmusicapi" / "browser.json"
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_bytes(uploaded.getvalue())
+    return str(target)
+
+
+def _render_ytmusicapi_upload_tab() -> None:
+    st.subheader("ytmusicapi")
+    st.caption("Upload de músicas para YouTube Music através da API não oficial ytmusicapi. O serviço exige autenticação de browser e aceita MP3, M4A, WMA, FLAC ou OGG até 300 MB.")
+    st.warning("Use um browser.json exportado/configurado pelo ytmusicapi. Não cole cookies ou tokens na conversa, no GitHub ou em issues; o ficheiro fica apenas no storage local.")
+    settings = read_json("settings.json", {})
+    with st.form("ytmusicapi_settings_form"):
+        enabled = st.checkbox("Activar ytmusicapi", value=bool(settings.get("ytmusicapi_enabled", False)))
+        auth_file = st.text_input("Caminho do browser.json", value=str(settings.get("ytmusicapi_auth_file") or ""))
+        proxy_url = st.text_input("Proxy opcional", value=str(settings.get("ytmusicapi_proxy_url") or ""), placeholder="http://127.0.0.1:8080")
+        timeout_seconds = st.number_input("Timeout (segundos)", min_value=30, max_value=900, value=int(settings.get("ytmusicapi_timeout_seconds", 240)), step=10)
+        save = st.form_submit_button("Guardar configuração ytmusicapi", type="primary", use_container_width=True)
+    if save:
+        settings = _persist_music_upload_settings({
+            "ytmusicapi_enabled": bool(enabled),
+            "ytmusicapi_auth_file": auth_file.strip(),
+            "ytmusicapi_proxy_url": proxy_url.strip(),
+            "ytmusicapi_timeout_seconds": int(timeout_seconds),
+        })
+        st.success("Configuração ytmusicapi guardada no storage local.")
+    auth_upload = st.file_uploader("Carregar browser.json", type=["json"], key="ytmusicapi_auth_upload")
+    if auth_upload is not None and st.button("Guardar browser.json no storage local", key="ytmusicapi_auth_store", use_container_width=True):
+        stored_auth = _store_ytmusicapi_auth(auth_upload)
+        settings = _persist_music_upload_settings({"ytmusicapi_auth_file": stored_auth, "ytmusicapi_enabled": True})
+        st.success(f"Ficheiro de autenticação guardado em `{stored_auth}`.")
+    adapter = YTMusicApiAdapter(read_json("settings.json", {}))
+    status = adapter.status()
+    (st.success if status.ok else st.warning)(status.message)
+    if st.button("Testar autenticação ytmusicapi", key="ytmusicapi_test", use_container_width=True):
+        result = YTMusicApiAdapter(read_json("settings.json", {})).test_connection()
+        (st.success if result.ok else st.error)(result.message)
+    music_path = _render_music_source("ytmusicapi", YT_MUSIC_UPLOAD_EXTENSIONS)
+    if st.button("Enviar música para YouTube Music", type="primary", key="ytmusicapi_upload", use_container_width=True, disabled=not bool(music_path) or not status.ok):
+        result = YTMusicApiAdapter(read_json("settings.json", {})).upload_song(music_path)
+        _record_music_upload("ytmusicapi / YouTube Music", result, music_path=music_path, target={"service": "youtube_music"})
+        (st.success if result.ok else st.error)(result.message)
+
+
+def render_music_upload() -> None:
+    st.title("Upload Música")
+    st.caption("Carregue e encaminhe músicas por JewelMusic, sincronize bibliotecas com Pushtunes ou envie directamente para YouTube Music com ytmusicapi. As credenciais e o histórico permanecem locais.")
+    jewel_tab, pushtunes_tab, ytmusicapi_tab = render_localized_tabs(["JewelMusic", "Pushtunes", "ytmusicapi"])
+    with jewel_tab:
+        _render_jewelmusic_upload_tab()
+    with pushtunes_tab:
+        _render_pushtunes_upload_tab()
+    with ytmusicapi_tab:
+        _render_ytmusicapi_upload_tab()
+    _render_music_upload_history()
+
+
 def render_upload():
     st.title("Upload")
     upload_tab, direct_tab, postiz_tab, upload_post_tab = render_localized_tabs(["Upload convencional", "Upload directo", "Postiz", "Upload-Post"])
@@ -4955,93 +5228,166 @@ 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_telegram_notification_settings() -> None:
+    """Render Telegram outbound notification settings and a safe diagnostics action."""
+    settings = read_json("settings.json", {})
+    if not isinstance(settings, dict):
+        settings = {}
+    st.subheader("Telegram Gateway")
+    st.caption("Envie para o Telegram as mesmas notificações que aparecem na subaba Geral. A integração usa a Bot API oficial e não recebe mensagens nem inicia polling.")
+    with st.form("telegram_notifications_form"):
+        telegram_enabled = st.checkbox(
+            "Activar notificações Telegram",
+            value=bool(settings.get("telegram_enabled", False)),
+            help="Quando activo, cada nova notificação permitida em Geral é enviada para o Chat ID configurado.",
+        )
+        telegram_cols = st.columns(2)
+        with telegram_cols[0]:
+            telegram_bot_token = st.text_input(
+                "Telegram Bot Token",
+                value=str(settings.get("telegram_bot_token") or ""),
+                type="password",
+                help="Token criado pelo BotFather. Fica guardado apenas no storage local.",
+            )
+            _render_credential_status(telegram_bot_token)
+        with telegram_cols[1]:
+            telegram_chat_id = st.text_input(
+                "Telegram Chat ID",
+                value=str(settings.get("telegram_chat_id") or ""),
+                help="ID do utilizador, grupo ou canal que receberá as notificações; também pode ser um username aceite pelo Telegram.",
+            )
+        telegram_proxy_url = st.text_input(
+            "Proxy Telegram (opcional)",
+            value=str(settings.get("telegram_proxy_url") or ""),
+            help="Proxy HTTP/HTTPS/SOCKS suportado pelo ambiente, quando o acesso directo ao Telegram não estiver disponível.",
+        )
+        telegram_timeout_seconds = st.number_input(
+            "Timeout de envio (segundos)",
+            min_value=5,
+            max_value=120,
+            value=int(settings.get("telegram_timeout_seconds", 15) or 15),
+            step=5,
+        )
+        st.caption("O teste consulta getMe para validar o Bot Token e não envia uma mensagem de teste.")
+        _render_api_test_control(
+            settings,
+            "telegram",
+            lambda: test_telegram_credentials(telegram_bot_token, telegram_chat_id),
+            widget_key="api_test_telegram",
+        )
+        if st.form_submit_button("Guardar configuração Telegram", type="primary", use_container_width=True):
+            settings.update({
+                "telegram_enabled": bool(telegram_enabled),
+                "telegram_bot_token": telegram_bot_token.strip(),
+                "telegram_chat_id": telegram_chat_id.strip(),
+                "telegram_proxy_url": telegram_proxy_url.strip(),
+                "telegram_timeout_seconds": int(telegram_timeout_seconds),
+            })
+            write_json("settings.json", settings)
+            st.success("Configuração Telegram guardada no storage local.")
+            st.rerun()
+
+    if telegram_enabled and telegram_bot_token.strip() and telegram_chat_id.strip():
+        st.success("Telegram está preparado para receber novas notificações.")
+    elif telegram_enabled:
+        st.warning("Telegram está activo, mas ainda falta configurar o Bot Token e o Chat ID.")
+    else:
+        st.info("Telegram está desactivado. As notificações continuam disponíveis na subaba Geral.")
+
+
 def render_notifications():
     st.title("Notificações")
     st.caption("Centro de notificações internas persistentes do Thunderbolt. As conclusões são guardadas no storage local e aparecem quando a aplicação é actualizada.")
-    reconcile_persisted_notifications()
-    preferences = notification_preferences()
-    catalog = notification_event_catalog()
-    notifications = list_notifications(limit=500)
-    unread_count = unread_notification_count()
-    summary_cols = st.columns(3)
-    with summary_cols[0]:
-        st.metric("Não lidas", unread_count)
-    with summary_cols[1]:
-        st.metric("Total guardado", len(notifications))
-    with summary_cols[2]:
-        st.metric("Operações mapeadas", len(catalog))
-
-    action_cols = st.columns([1.4, 1.4, 2.2])
-    with action_cols[0]:
-        if st.button("Marcar todas como lidas", use_container_width=True, disabled=unread_count == 0):
-            mark_all_notifications_read()
-            st.rerun()
-    with action_cols[1]:
-        if st.button("Actualizar notificações", use_container_width=True):
-            reconcile_persisted_notifications()
-            st.rerun()
-    with action_cols[2]:
-        confirm_clear = st.checkbox("Confirmar limpeza do histórico", key="confirm_clear_notifications")
-        if st.button("Limpar histórico", use_container_width=True, disabled=not confirm_clear):
-            clear_notifications()
-            st.session_state.pop("confirm_clear_notifications", None)
-            st.rerun()
+    general_tab, telegram_tab = render_localized_tabs(["Geral", "Telegram"])
 
-    st.divider()
-    st.subheader("Operações notificadas")
-    st.caption("Ligue ou desligue cada tipo de notificação. As preferências ficam guardadas no storage local e aplicam-se às próximas conclusões.")
-    grouped: dict[str, list[dict[str, str]]] = {}
-    for event in catalog:
-        grouped.setdefault(event["category"], []).append(event)
-    with st.form("notification_preferences_form"):
-        pending_preferences: dict[str, bool] = {}
-        for category, events in grouped.items():
-            st.markdown(f"**{category}**")
-            for event in events:
-                pending_preferences[event["code"]] = st.checkbox(
-                    event["label"],
-                    value=bool(preferences.get(event["code"], True)),
-                    help=event["description"],
-                    key=f"notification_preference_{event['code']}",
-                )
-        if st.form_submit_button("Guardar preferências", type="primary", use_container_width=True):
-            save_notification_preferences(pending_preferences)
-            st.success("Preferências de notificação guardadas.")
-            st.rerun()
+    with general_tab:
+        reconcile_persisted_notifications()
+        preferences = notification_preferences()
+        catalog = notification_event_catalog()
+        notifications = list_notifications(limit=500)
+        unread_count = unread_notification_count()
+        summary_cols = st.columns(3)
+        with summary_cols[0]:
+            st.metric("Não lidas", unread_count)
+        with summary_cols[1]:
+            st.metric("Total guardado", len(notifications))
+        with summary_cols[2]:
+            st.metric("Operações mapeadas", len(catalog))
+
+        action_cols = st.columns([1.4, 1.4, 2.2])
+        with action_cols[0]:
+            if st.button("Marcar todas como lidas", use_container_width=True, disabled=unread_count == 0):
+                mark_all_notifications_read()
+                st.rerun()
+        with action_cols[1]:
+            if st.button("Actualizar notificações", use_container_width=True):
+                reconcile_persisted_notifications()
+                st.rerun()
+        with action_cols[2]:
+            confirm_clear = st.checkbox("Confirmar limpeza do histórico", key="confirm_clear_notifications")
+            if st.button("Limpar histórico", use_container_width=True, disabled=not confirm_clear):
+                clear_notifications()
+                st.session_state.pop("confirm_clear_notifications", None)
+                st.rerun()
 
-    st.divider()
-    st.subheader("Histórico de notificações")
-    filter_cols = st.columns([1, 1.4])
-    category_options = ["Todas"] + sorted({event["category"] for event in catalog})
-    with filter_cols[0]:
-        selected_category = st.selectbox("Categoria", category_options, key="notifications_category_filter")
-    with filter_cols[1]:
-        selected_state = st.selectbox("Estado", ["Todas", "Não lidas", "Lidas"], key="notifications_state_filter")
-    category_filter = "" if selected_category == "Todas" else selected_category
-    unread_filter = selected_state == "Não lidas"
-    filtered = list_notifications(limit=500, category=category_filter, unread_only=unread_filter)
-    if selected_state == "Lidas":
-        filtered = [item for item in filtered if item.get("read")]
-    if not filtered:
-        st.info("Ainda não existem notificações para os filtros seleccionados.")
-    for item in filtered:
-        with st.container(border=True):
-            notification_cols = st.columns([3.3, 1.4, 1])
-            with notification_cols[0]:
-                st.write(f"**{item.get('title') or item.get('label') or 'Notificação'}**")
-                st.caption(item.get("message") or "")
-                metadata = item.get("metadata") if isinstance(item.get("metadata"), dict) else {}
-                if metadata:
-                    public_details = " · ".join(f"{key}: {value}" for key, value in metadata.items() if value not in (None, ""))
-                    if public_details:
-                        st.caption(public_details)
-            with notification_cols[1]:
-                st.caption(f"{item.get('category', 'Sistema')} · {item.get('created_at', '—')}")
-                st.write("Lida" if item.get("read") else "Não lida")
-            with notification_cols[2]:
-                if not item.get("read") and st.button("Marcar como lida", key=f"mark_notification_{item.get('id')}", use_container_width=True):
-                    mark_notification_read(str(item.get("id")))
-                    st.rerun()
+        st.divider()
+        st.subheader("Operações notificadas")
+        st.caption("Ligue ou desligue cada tipo de notificação. As preferências ficam guardadas no storage local e aplicam-se às próximas conclusões.")
+        grouped: dict[str, list[dict[str, str]]] = {}
+        for event in catalog:
+            grouped.setdefault(event["category"], []).append(event)
+        with st.form("notification_preferences_form"):
+            pending_preferences: dict[str, bool] = {}
+            for category, events in grouped.items():
+                st.markdown(f"**{category}**")
+                for event in events:
+                    pending_preferences[event["code"]] = st.checkbox(
+                        event["label"],
+                        value=bool(preferences.get(event["code"], True)),
+                        help=event["description"],
+                        key=f"notification_preference_{event['code']}",
+                    )
+            if st.form_submit_button("Guardar preferências", type="primary", use_container_width=True):
+                save_notification_preferences(pending_preferences)
+                st.success("Preferências de notificação guardadas.")
+                st.rerun()
+
+        st.divider()
+        st.subheader("Histórico de notificações")
+        filter_cols = st.columns([1, 1.4])
+        category_options = ["Todas"] + sorted({event["category"] for event in catalog})
+        with filter_cols[0]:
+            selected_category = st.selectbox("Categoria", category_options, key="notifications_category_filter")
+        with filter_cols[1]:
+            selected_state = st.selectbox("Estado", ["Todas", "Não lidas", "Lidas"], key="notifications_state_filter")
+        category_filter = "" if selected_category == "Todas" else selected_category
+        unread_filter = selected_state == "Não lidas"
+        filtered = list_notifications(limit=500, category=category_filter, unread_only=unread_filter)
+        if selected_state == "Lidas":
+            filtered = [item for item in filtered if item.get("read")]
+        if not filtered:
+            st.info("Ainda não existem notificações para os filtros seleccionados.")
+        for item in filtered:
+            with st.container(border=True):
+                notification_cols = st.columns([3.3, 1.4, 1])
+                with notification_cols[0]:
+                    st.write(f"**{item.get('title') or item.get('label') or 'Notificação'}**")
+                    st.caption(item.get("message") or "")
+                    metadata = item.get("metadata") if isinstance(item.get("metadata"), dict) else {}
+                    if metadata:
+                        public_details = " · ".join(f"{key}: {value}" for key, value in metadata.items() if value not in (None, ""))
+                        if public_details:
+                            st.caption(public_details)
+                with notification_cols[1]:
+                    st.caption(f"{item.get('category', 'Sistema')} · {item.get('created_at', '—')}")
+                    st.write("Lida" if item.get("read") else "Não lida")
+                with notification_cols[2]:
+                    if not item.get("read") and st.button("Marcar como lida", key=f"mark_notification_{item.get('id')}", use_container_width=True):
+                        mark_notification_read(str(item.get("id")))
+                        st.rerun()
+
+    with telegram_tab:
+        _render_telegram_notification_settings()
 
 
 def render_models_ai_tutorial():
@@ -5488,7 +5834,7 @@ def main():
         "Criação de Vídeos": render_new_video,
         "Backlog Vídeos": render_videos,
         "Criação de Músicas": render_music_creation,
-        "Upload Música": lambda: render_edit_placeholder("Upload Música", ""),
+        "Upload Música": render_music_upload,
         "Roteiros": render_scripts,
         "Thumbnails": render_thumbnails,
         "Upload": render_upload,

package/hermes_ui/api_key_tests.py

@@ -213,6 +213,18 @@ def test_postiz_credentials(api_key: str, base_url: str = "https://api.postiz.co
     return _get(f"{base}/integrations", headers={"Authorization": api_key})
 
 
+def test_telegram_credentials(bot_token: str, chat_id: str) -> dict[str, Any]:
+    """Validate the Telegram bot token with getMe without sending a message."""
+    bot_token = str(bot_token or "").strip()
+    chat_id = str(chat_id or "").strip()
+    if not bot_token or not chat_id:
+        return _missing("Introduza o Bot Token e o Chat ID Telegram antes de testar.")
+    result = _get(f"https://api.telegram.org/bot{bot_token}/getMe")
+    if result.get("ok"):
+        result["message"] = "Bot Token Telegram válido. O Chat ID foi aceite localmente; o teste não enviou mensagem."
+    return result
+
+
 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()

package/hermes_ui/languages.py

@@ -614,6 +614,27 @@ for _language_code, _tab_translation in TAB_TRANSLATIONS.items():
     UI_TRANSLATIONS[_language_code].update(_tab_translation)
 
 
+_NOTIFICATION_TAB_TRANSLATIONS: dict[str, dict[str, str]] = {
+    "pt": {"Geral": "Geral", "Telegram": "Telegram"},
+    "en": {"Geral": "General", "Telegram": "Telegram"},
+    "zh": {"Geral": "常规", "Telegram": "Telegram"},
+    "de": {"Geral": "Allgemein", "Telegram": "Telegram"},
+    "vi": {"Geral": "Chung", "Telegram": "Telegram"},
+    "tr": {"Geral": "Genel", "Telegram": "Telegram"},
+    "ru": {"Geral": "Общие", "Telegram": "Telegram"},
+    "es": {"Geral": "General", "Telegram": "Telegram"},
+    "id": {"Geral": "Umum", "Telegram": "Telegram"},
+    "it": {"Geral": "Generale", "Telegram": "Telegram"},
+    "pl": {"Geral": "Ogólne", "Telegram": "Telegram"},
+    "ga": {"Geral": "Ginearálta", "Telegram": "Telegram"},
+    "ar": {"Geral": "عام", "Telegram": "Telegram"},
+    "he": {"Geral": "כללי", "Telegram": "Telegram"},
+}
+for _language_code, _notification_tab_translation in _NOTIFICATION_TAB_TRANSLATIONS.items():
+    if _language_code in UI_TRANSLATIONS:
+        UI_TRANSLATIONS[_language_code].update(_notification_tab_translation)
+
+
 TUTORIAL_TRANSLATIONS: dict[str, dict[str, str]] = {
     "pt": {"Tutorial Supabase": "Tutorial Supabase", "Guia de configuração do Supabase para automações com n8n.": "Guia de configuração do Supabase para automações com n8n."},
     "en": {"Tutorial Supabase": "Supabase Tutorial", "Guia de configuração do Supabase para automações com n8n.": "Supabase setup guide for n8n automations."},