@danhachuel/thunderbolt 0.3.19 → 0.3.21

package/app/main.py

@@ -34,7 +34,7 @@ from hermes_ui.python_editor import AUDIO_EXTENSIONS, VIDEO_EXTENSIONS, PythonEd
 from hermes_ui.cuts import CutsError, download_direct_video_url, generate_clips, list_generated_videos as list_cut_generated_videos, list_runs as list_cut_runs, list_video_files as list_cut_video_files, manifest_bytes as cut_manifest_bytes, store_uploaded_video, zip_run as zip_cut_run
 from hermes_ui.mcp import detect_local_service, install_skill_locally, load_integrations, load_server_config, read_packaged_skill, save_server_config, update_integration
 from hermes_ui.mcp_server import server_status, start_server, stop_server
-from hermes_ui.material_sources import material_api_keys, material_source_catalog, selected_material_source, update_material_api_keys
+from hermes_ui.material_sources import apply_material_source_cards_to_settings, ensure_material_source_cards, material_source_catalog, material_source_definition, new_material_card, normalize_material_card, selected_material_source
 from hermes_ui.llm_providers import LLM_CARDS_KEY, LLM_ACTIVE_CARD_KEY, LLM_PROVIDER_CATALOG, apply_llm_cards_to_settings, ensure_llm_provider_cards, new_llm_card, normalize_llm_card, provider_definition, test_llm_provider_card, stamp_test_result
 from hermes_ui.music import list_music_files, materialize_suno_audio, request_suno_generation, store_music_file
 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
@@ -3437,103 +3437,116 @@ def render_google_accounts():
         missing_document_parts = list(direct_status.get("missing_cookies", []))
         if not direct_status.get("has_session_info"):
             missing_document_parts.append("sessionInfo")
+        account_ready = bool(
+            account_email_snapshot != "sem e-mail"
+            and str(batch_account.get("client_id") or "").strip()
+            and str(batch_account.get("client_secret") or "").strip()
+            and bool(direct_status.get("document_exists"))
+            and not missing_document_parts
+        )
         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.")
+        with st.container(border=True):
+            account_header_cols = st.columns([3.2, 1.2])
+            with account_header_cols[0]:
+                st.subheader(f"{account_label_snapshot} — {account_email_snapshot}")
+            with account_header_cols[1]:
+                _api_status_badge("Configured" if account_ready else "Missing configuration", "ready" if account_ready else "missing")
+            with st.expander("Detalhes da conta Google", 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:
-                    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()
+                    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 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.")
+                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()
-                    except ValueError as exc:
-                        st.error(str(exc))
+
+                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))
@@ -3559,6 +3572,11 @@ def render_google_accounts():
                 legacy_account.pop("INNERTUBE_API_KEY", None)
             settings["youtube_batch_accounts"] = batch_accounts
             write_json("settings.json", settings)
+    innertube_status_cols = st.columns([3.2, 1.2])
+    with innertube_status_cols[0]:
+        st.caption("Estado da chave global")
+    with innertube_status_cols[1]:
+        _render_credential_status(current_innertube_api_key)
     with st.form("innertube_api_key_form"):
         innertube_api_key_value = st.text_input(
             "INNERTUBE_API_KEY",
@@ -3663,51 +3681,86 @@ def render_google_accounts():
         st.success("Configuração global do YouTube guardada em Contas Google.")
         st.rerun()
 
-def render_material_source_api_keys(settings: dict[str, Any]) -> None:
-    st.subheader("Fontes de materiais")
-    st.caption("Seleccione a fonte que será usada na pipeline e guarde uma ou mais API keys. Qualidade, endpoints e parâmetros internos são definidos pelo Thunderbolt.")
-    source_catalog = material_source_catalog()
-    source_codes = [item["code"] for item in source_catalog] + ["local"]
-    source_labels = {item["code"]: item["label"] for item in source_catalog} | {"local": "Ficheiros locais"}
-    source_help = {item["code"]: item["description"] for item in source_catalog} | {"local": "Usar materiais já existentes no storage local; não requer API key."}
-    selected_source = st.selectbox(
-        "Fonte de materiais",
-        source_codes,
-        index=source_codes.index(selected_material_source(settings)) if selected_material_source(settings) in source_codes else 0,
-        format_func=lambda value: source_labels.get(value, value),
-        key="material_source_selector",
-    )
-    st.caption(source_help.get(selected_source, ""))
-    current_keys = material_api_keys(settings, selected_source)
-    row_key = f"material_source_key_rows_{selected_source}"
-    row_count = max(len(current_keys), int(st.session_state.get(row_key, len(current_keys) or 1)))
-    if selected_source == "local":
-        _render_credential_status("", local=True, required=False)
-        st.info("A fonte local não usa API key. Os materiais devem existir na pasta configurada do storage.")
-        if st.button("Guardar fonte local", type="primary", key="save_local_material_source"):
-            settings["video_source"] = selected_source
-            write_json("settings.json", settings)
-            st.success("Fonte de materiais guardada: ficheiros locais.")
+def _persist_material_source_cards(settings: dict[str, Any], cards: list[dict[str, Any]], active_card_id: str = "") -> dict[str, Any]:
+    updated = apply_material_source_cards_to_settings(settings, cards, active_card_id)
+    write_json("settings.json", updated)
+    return updated
+
+
+def _material_source_card_definition(provider: str) -> dict[str, str]:
+    definition = material_source_definition(provider)
+    if definition is not None:
+        return definition
+    return {
+        "code": "local",
+        "label": "Ficheiros locais",
+        "description": "Usar materiais já existentes no storage local; não requer API key.",
+        "legacy_key": "",
+    }
+
+
+def _render_material_source_card(settings: dict[str, Any], cards: list[dict[str, Any]], index: int) -> None:
+    card = normalize_material_card(cards[index], index)
+    cards[index] = card
+    card_id = str(card["id"])
+    provider = str(card.get("provider") or "pexels")
+    definition = _material_source_card_definition(provider)
+    is_local = provider == "local"
+    active_card_id = str(settings.get("material_active_card_id") or "")
+    with st.container(border=True):
+        header_cols = st.columns([3.2, 1.2])
+        with header_cols[0]:
+            st.subheader(definition["label"])
+            st.caption(definition["description"])
+        with header_cols[1]:
+            _render_credential_status("" if is_local else card.get("api_key"), local=is_local, required=not is_local)
+        with st.form(f"material_source_card_form_{card_id}"):
+            content_cols = st.columns(2)
+            with content_cols[0]:
+                if is_local:
+                    st.caption("Esta fonte não usa API key.")
+                    api_key = ""
+                else:
+                    api_key = st.text_input("API Key", value=str(card.get("api_key") or ""), type="password", key=f"material_card_{card_id}_api_key")
+            with content_cols[1]:
+                enabled = st.checkbox("Fonte activa", value=bool(card.get("enabled", True)), key=f"material_card_{card_id}_enabled")
+                selected = st.checkbox(
+                    "Usar esta fonte na pipeline",
+                    value=active_card_id == card_id,
+                    key=f"material_card_{card_id}_selected",
+                )
+            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)}
+            selected_id = card_id if selected and enabled else active_card_id
+            _persist_material_source_cards(settings, cards, selected_id)
+            st.success(f"Fonte {definition['label']} guardada.")
             st.rerun()
-        return
-    _render_credential_status(any(str(item or "").strip() for item in current_keys))
-    with st.form(f"material_api_keys_form_{selected_source}"):
-        key_values: list[str] = []
-        for index in range(row_count):
-            key_values.append(st.text_input(f"API Key {index + 1}", value=current_keys[index] if index < len(current_keys) else "", type="password", key=f"material_api_key_{selected_source}_{index}"))
-        save_keys = st.form_submit_button("Guardar fonte e chaves", type="primary", use_container_width=True)
-        add_key = st.form_submit_button("Adicionar outra chave", use_container_width=True)
-    if add_key:
-        st.session_state[row_key] = row_count + 1
-        st.rerun()
-    if save_keys:
-        update_material_api_keys(settings, selected_source, key_values)
-        settings["video_source"] = selected_source
+
+
+def render_material_source_api_keys(settings: dict[str, Any]) -> None:
+    st.subheader("Fontes de Materiais")
+    st.caption("Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.")
+    migrated, changed = ensure_material_source_cards(settings)
+    cards = [dict(item) for item in migrated.get("material_source_cards", [])]
+    if changed:
         write_json("settings.json", settings)
-        st.session_state[row_key] = max(1, len(material_api_keys(settings, selected_source)))
-        st.success(f"Fonte {source_labels.get(selected_source, selected_source)} guardada com {len(material_api_keys(settings, selected_source))} chave(s).")
+    for index in range(len(cards)):
+        _render_material_source_card(settings, cards, index)
+
+    st.divider()
+    st.markdown("**Adicionar fonte de materiais**")
+    provider_codes = [item["code"] for item in material_source_catalog()] + ["local"]
+    provider_to_add = st.selectbox(
+        "Provedor de materiais",
+        provider_codes,
+        format_func=lambda value: _material_source_card_definition(value)["label"],
+        key="material_new_provider_choice",
+    )
+    if st.button("Configurar Nova Fonte de Materiais", type="primary", use_container_width=True, key="add_material_source_card"):
+        cards.append(new_material_card(provider_to_add, card_id=f"material-{provider_to_add}-{uuid.uuid4().hex[:8]}"))
+        _persist_material_source_cards(settings, cards, str(settings.get("material_active_card_id") or ""))
         st.rerun()
-    st.caption(f"{len(current_keys)} chave(s) actualmente guardada(s) para {source_labels.get(selected_source, selected_source)}. As chaves são mantidas no storage local e usadas com rotação interna.")
 
 
 def _api_status_badge(label: str, kind: str = "missing") -> None:
@@ -3927,7 +3980,7 @@ def render_settings():
             key=f"settings_{key}",
         )
 
-    api_keys_tab, material_sources_tab, voice_test_tab = render_localized_tabs(["API Keys", "Fontes de Materiais", "Teste de Voz"])
+    api_keys_tab, google_accounts_tab, material_sources_tab, voice_test_tab = render_localized_tabs(["API Keys", "Contas Google", "Fontes de Materiais", "Teste de Voz"])
 
     with api_keys_tab:
         with st.container(border=True):
@@ -4062,8 +4115,11 @@ def render_settings():
                             st.success("Configurações guardadas localmente. Indique uma pasta válida do motor de vídeo para sincronizar config.toml.")
                     except Exception as exc:
                         st.warning(f"Configurações locais guardadas, mas não foi possível sincronizar config.toml: {exc}")
-        with material_sources_tab:
-            render_material_source_api_keys(settings)
+    with google_accounts_tab:
+        render_google_accounts()
+
+    with material_sources_tab:
+        render_material_source_api_keys(settings)
 
     with voice_test_tab:
         st.subheader("Teste de Voz")
@@ -4527,7 +4583,6 @@ def main():
     ]
     settings_items = [
         ("MCP", ":material/hub:", "MCP"),
-        ("Contas Google", ":material/account_circle:", "Contas Google"),
         ("Notificações", ":material/notifications:", "Notificações"),
         ("Configuração API", ":material/settings:", "Configuração API"),
     ]
@@ -4585,7 +4640,8 @@ def main():
         "Blueprints": "Blueprints Youtube",
         "Configurações Técnicas": "Configuração API",
         "Models AI": "AI Influencers",
-        "Contas Google/YouTube — canais em lote": "Contas Google",
+        "Contas Google/YouTube — canais em lote": "Configuração API",
+        "Contas Google": "Configuração API",
     }
     all_children = [item for items in groups.values() for item in items]
     valid_targets = {item[0] for item in top_pages + all_children}

package/hermes_ui/languages.py

@@ -781,6 +781,7 @@ _CONTENT_TRANSLATION_ROWS = (
     ("O Thunderbolt é o cliente. A API key é enviada exclusivamente ao servidor Postiz configurado; não é colocada em URLs, logs ou repositório.", "O Thunderbolt é o cliente. A API key é enviada exclusivamente ao servidor Postiz configurado; não é colocada em URLs, logs ou repositório.", "Thunderbolt is the client. The API key is sent only to the configured Postiz server; it is not placed in URLs, logs or the repository.", "Thunderbolt 是客户端。API 密钥仅发送到配置的 Postiz 服务器，不会放入 URL、日志或代码库。", "Thunderbolt ist der Client. Der API-Schlüssel wird nur an den konfigurierten Postiz-Server gesendet und nicht in URLs, Logs oder dem Repository abgelegt.", "Thunderbolt là client. API key chỉ gửi đến máy chủ Postiz đã cấu hình; không đặt trong URL, log hoặc repository.", "Thunderbolt istemcidir. API anahtarı yalnızca yapılandırılmış Postiz sunucusuna gönderilir; URL'lere, günlüklerine veya depoya yazılmaz.", "Thunderbolt — клиент. API-ключ отправляется только настроенному серверу Postiz и не помещается в URL, логи или репозиторий.", "Thunderbolt es el cliente. La clave API solo se envía al servidor Postiz configurado; no se incluye en URL, registros ni repositorio.", "Thunderbolt adalah klien. Kunci API hanya dikirim ke server Postiz yang dikonfigurasi; tidak dimasukkan ke URL, log, atau repositori.", "Thunderbolt è il client. La chiave API viene inviata solo al server Postiz configurato; non viene inserita in URL, log o repository."),
     ("Modo de ligação", "Modo de ligação", "Connection mode", "连接模式", "Verbindungsmodus", "Chế độ kết nối", "Bağlantı modu", "Режим подключения", "Modo de conexión", "Mode koneksi", "Modalità di connessione"),
     ("Metadados removidos e nova cópia criada. O original continua preservado.", "Metadados removidos e nova cópia criada. O original continua preservado.", "Metadata removed and a new copy created. The original remains preserved.", "元数据已移除并创建新副本。原文件仍然保留。", "Metadaten entfernt und eine neue Kopie erstellt. Das Original bleibt erhalten.", "Đã xóa siêu dữ liệu và tạo bản sao mới. Bản gốc vẫn được giữ nguyên.", "Üst veriler kaldırıldı ve yeni bir kopya oluşturuldu. Orijinal korunur.", "Метаданные удалены и создана новая копия. Оригинал сохранён.", "Metadatos eliminados y nueva copia creada. El original se conserva.", "Metadata dihapus dan salinan baru dibuat. File asli tetap dipertahankan.", "Metadati rimossi e nuova copia creata. L'originale è preservato."),
+    ("Detalhes da conta Google", "Detalhes da conta Google", "Google account details", "Google 账户详情", "Details des Google-Kontos", "Chi tiết tài khoản Google", "Google hesap ayrıntıları", "Сведения об аккаунте Google", "Detalles de la cuenta de Google", "Detail akun Google", "Dettagli dell'account Google"),
 )
 UI_CONTENT_TRANSLATIONS: dict[str, dict[str, str]] = {code: {} for code in _CONTENT_TRANSLATION_CODES}
 for _row in _CONTENT_TRANSLATION_ROWS:
@@ -922,3 +923,109 @@ __all__ = [
     "language_label", "ui_language_menu_label", "language_locale", "language_option_codes", "language_option_labels",
     "ui_text", "video_language_label", "video_language_options",
 ]
+
+
+_MATERIAL_SOURCE_TRANSLATIONS: dict[str, dict[str, str]] = {
+    "pt": {
+        "Fontes de Materiais": "Fontes de Materiais",
+        "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.": "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.",
+        "Adicionar fonte de materiais": "Adicionar fonte de materiais",
+        "Provedor de materiais": "Provedor de materiais",
+        "Configurar Nova Fonte de Materiais": "Configurar Nova Fonte de Materiais",
+        "Fonte activa": "Fonte activa",
+        "Usar esta fonte na pipeline": "Usar esta fonte na pipeline",
+        "Esta fonte não usa API key.": "Esta fonte não usa API key.",
+    },
+    "en": {
+        "Fontes de Materiais": "Media Sources",
+        "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.": "Configure each provider in an independent card. You can repeat the same provider to store multiple API keys; the selected source will be used by the pipeline.",
+        "Adicionar fonte de materiais": "Add media source",
+        "Provedor de materiais": "Media provider",
+        "Configurar Nova Fonte de Materiais": "Configure New Media Source",
+        "Fonte activa": "Source active",
+        "Usar esta fonte na pipeline": "Use this source in the pipeline",
+        "Esta fonte não usa API key.": "This source does not use an API key.",
+    },
+    "zh": {
+        "Fontes de Materiais": "素材来源",
+        "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.": "在独立卡片中配置每个提供商。可以重复同一提供商以保存多个 API 密钥；所选来源将由流水线使用。",
+        "Adicionar fonte de materiais": "添加素材来源",
+        "Provedor de materiais": "素材提供商",
+        "Configurar Nova Fonte de Materiais": "配置新的素材来源",
+        "Fonte activa": "来源已启用",
+        "Usar esta fonte na pipeline": "在流水线中使用此来源",
+        "Esta fonte não usa API key.": "此来源不使用 API 密钥。",
+    },
+    "de": {
+        "Fontes de Materiais": "Medienquellen",
+        "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.": "Konfigurieren Sie jeden Anbieter in einer eigenen Karte. Derselbe Anbieter kann für mehrere API-Schlüssel wiederholt werden; die ausgewählte Quelle wird von der Pipeline verwendet.",
+        "Adicionar fonte de materiais": "Medienquelle hinzufügen",
+        "Provedor de materiais": "Medienanbieter",
+        "Configurar Nova Fonte de Materiais": "Neue Medienquelle konfigurieren",
+        "Fonte activa": "Quelle aktiv",
+        "Usar esta fonte na pipeline": "Diese Quelle in der Pipeline verwenden",
+        "Esta fonte não usa API key.": "Diese Quelle verwendet keinen API-Schlüssel.",
+    },
+    "vi": {
+        "Fontes de Materiais": "Nguồn phương tiện",
+        "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.": "Định cấu hình từng nhà cung cấp trong một thẻ riêng. Có thể lặp lại cùng nhà cung cấp để lưu nhiều API key; nguồn được chọn sẽ được quy trình sử dụng.",
+        "Adicionar fonte de materiais": "Thêm nguồn phương tiện",
+        "Provedor de materiais": "Nhà cung cấp phương tiện",
+        "Configurar Nova Fonte de Materiais": "Định cấu hình nguồn phương tiện mới",
+        "Fonte activa": "Nguồn đang hoạt động",
+        "Usar esta fonte na pipeline": "Dùng nguồn này trong quy trình",
+        "Esta fonte não usa API key.": "Nguồn này không dùng API key.",
+    },
+    "tr": {
+        "Fontes de Materiais": "Medya kaynakları",
+        "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.": "Her sağlayıcıyı bağımsız bir kartta yapılandırın. Birden fazla API anahtarı saklamak için aynı sağlayıcıyı tekrarlayabilirsiniz; seçilen kaynak akış tarafından kullanılacaktır.",
+        "Adicionar fonte de materiais": "Medya kaynağı ekle",
+        "Provedor de materiais": "Medya sağlayıcısı",
+        "Configurar Nova Fonte de Materiais": "Yeni medya kaynağını yapılandır",
+        "Fonte activa": "Kaynak etkin",
+        "Usar esta fonte na pipeline": "Bu kaynağı akışta kullan",
+        "Esta fonte não usa API key.": "Bu kaynak API anahtarı kullanmaz.",
+    },
+    "ru": {
+        "Fontes de Materiais": "Источники материалов",
+        "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.": "Настройте каждого провайдера в отдельной карточке. Один и тот же провайдер можно повторить для хранения нескольких API-ключей; выбранный источник будет использоваться конвейером.",
+        "Adicionar fonte de materiais": "Добавить источник материалов",
+        "Provedor de materiais": "Провайдер материалов",
+        "Configurar Nova Fonte de Materiais": "Настроить новый источник материалов",
+        "Fonte activa": "Источник активен",
+        "Usar esta fonte na pipeline": "Использовать этот источник в конвейере",
+        "Esta fonte não usa API key.": "Этот источник не использует API-ключ.",
+    },
+    "es": {
+        "Fontes de Materiais": "Fuentes de medios",
+        "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.": "Configura cada proveedor en una tarjeta independiente. Puedes repetir el mismo proveedor para guardar varias claves API; la fuente seleccionada será utilizada por el flujo.",
+        "Adicionar fonte de materiais": "Añadir fuente de medios",
+        "Provedor de materiais": "Proveedor de medios",
+        "Configurar Nova Fonte de Materiais": "Configurar nueva fuente de medios",
+        "Fonte activa": "Fuente activa",
+        "Usar esta fonte na pipeline": "Usar esta fuente en el flujo",
+        "Esta fonte não usa API key.": "Esta fuente no utiliza una clave API.",
+    },
+    "id": {
+        "Fontes de Materiais": "Sumber media",
+        "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.": "Konfigurasikan setiap penyedia dalam kartu terpisah. Penyedia yang sama dapat diulang untuk menyimpan beberapa kunci API; sumber yang dipilih akan digunakan oleh pipeline.",
+        "Adicionar fonte de materiais": "Tambah sumber media",
+        "Provedor de materiais": "Penyedia media",
+        "Configurar Nova Fonte de Materiais": "Konfigurasikan Sumber Media Baru",
+        "Fonte activa": "Sumber aktif",
+        "Usar esta fonte na pipeline": "Gunakan sumber ini di pipeline",
+        "Esta fonte não usa API key.": "Sumber ini tidak menggunakan kunci API.",
+    },
+    "it": {
+        "Fontes de Materiais": "Fonti multimediali",
+        "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.": "Configura ogni provider in una scheda indipendente. Puoi ripetere lo stesso provider per conservare più API key; la fonte selezionata sarà usata dalla pipeline.",
+        "Adicionar fonte de materiais": "Aggiungi fonte multimediale",
+        "Provedor de materiais": "Provider multimediale",
+        "Configurar Nova Fonte de Materiais": "Configura nuova fonte multimediale",
+        "Fonte activa": "Fonte attiva",
+        "Usar esta fonte na pipeline": "Usa questa fonte nella pipeline",
+        "Esta fonte não usa API key.": "Questa fonte non usa una API key.",
+    },
+}
+for _language_code, _material_source_translation in _MATERIAL_SOURCE_TRANSLATIONS.items():
+    UI_TRANSLATIONS[_language_code].update(_material_source_translation)

package/hermes_ui/material_sources.py

@@ -1,8 +1,12 @@
 from __future__ import annotations
 
 from typing import Any
+from uuid import uuid4
 
 
+MATERIAL_CARDS_KEY = "material_source_cards"
+MATERIAL_ACTIVE_CARD_KEY = "material_active_card_id"
+
 MATERIAL_SOURCE_CATALOG: tuple[dict[str, str], ...] = (
     {"code": "pexels", "label": "Pexels", "description": "Banco de vídeos e imagens para materiais da pipeline.", "legacy_key": "pexels_api_keys"},
     {"code": "pixabay", "label": "Pixabay", "description": "Banco de vídeos e imagens para materiais da pipeline.", "legacy_key": "pixabay_api_keys"},
@@ -13,6 +17,9 @@ MATERIAL_SOURCE_CATALOG: tuple[dict[str, str], ...] = (
 )
 
 
+_SOURCE_BY_CODE = {item["code"]: item for item in MATERIAL_SOURCE_CATALOG}
+
+
 def _as_key_list(value: Any) -> list[str]:
     if isinstance(value, list):
         values = value
@@ -32,12 +39,124 @@ def material_source_catalog() -> list[dict[str, str]]:
     return [dict(item) for item in MATERIAL_SOURCE_CATALOG]
 
 
-def material_api_keys(settings: dict[str, Any], source: str) -> list[str]:
+def material_source_definition(source: Any) -> dict[str, str] | None:
+    return _SOURCE_BY_CODE.get(str(source or "").strip().lower())
+
+
+def _new_card(provider: str, api_key: str = "", *, card_id: str | None = None) -> dict[str, Any]:
+    return {
+        "id": card_id or f"material-{provider}-{uuid4().hex[:8]}",
+        "provider": provider,
+        "api_key": str(api_key or "").strip(),
+        "enabled": True,
+    }
+
+
+def normalize_material_card(card: Any, index: int = 0) -> dict[str, Any]:
+    raw = card if isinstance(card, dict) else {}
+    provider = str(raw.get("provider") or raw.get("source") or "pexels").strip().lower()
+    if provider not in _SOURCE_BY_CODE and provider != "local":
+        provider = "pexels"
+    card_id = str(raw.get("id") or f"material-{provider}-{index}").strip()
+    return {
+        "id": card_id or f"material-{provider}-{index}",
+        "provider": provider,
+        "api_key": str(raw.get("api_key") or raw.get("key") or "").strip() if provider != "local" else "",
+        "enabled": bool(raw.get("enabled", True)),
+    }
+
+
+def _cards_key_mapping(cards: list[dict[str, Any]]) -> dict[str, list[str]]:
+    mapping = {item["code"]: [] for item in MATERIAL_SOURCE_CATALOG}
+    for index, raw_card in enumerate(cards):
+        card = normalize_material_card(raw_card, index)
+        provider = card["provider"]
+        api_key = str(card.get("api_key") or "").strip()
+        if card.get("enabled", True) and provider in mapping and api_key and api_key not in mapping[provider]:
+            mapping[provider].append(api_key)
+    return mapping
+
+
+def _sync_legacy_material_keys(settings: dict[str, Any], mapping: dict[str, list[str]]) -> None:
+    settings["material_api_keys"] = mapping
+    for item in MATERIAL_SOURCE_CATALOG:
+        settings[item["legacy_key"]] = list(mapping.get(item["code"], []))
+
+
+def ensure_material_source_cards(settings: dict[str, Any]) -> tuple[dict[str, Any], bool]:
+    """Migrate legacy per-source key lists into stable independent material cards."""
+    original = settings.get(MATERIAL_CARDS_KEY)
+    changed = False
+    if isinstance(original, list) and original:
+        cards = [normalize_material_card(item, index) for index, item in enumerate(original)]
+        changed = cards != original
+    else:
+        cards: list[dict[str, Any]] = []
+        for item in MATERIAL_SOURCE_CATALOG:
+            for key in material_api_keys(settings, item["code"], _ignore_cards=True):
+                cards.append(_new_card(item["code"], key, card_id=f"material-{item['code']}-{len(cards)}"))
+        if not cards:
+            selected = selected_material_source(settings)
+            cards.append(_new_card(selected if selected in _SOURCE_BY_CODE else "pexels", card_id="material-default-0"))
+        changed = True
+
+    settings[MATERIAL_CARDS_KEY] = cards
+    active_id = str(settings.get(MATERIAL_ACTIVE_CARD_KEY) or "").strip()
+    valid_ids = {str(card["id"]) for card in cards}
+    if active_id not in valid_ids:
+        selected_source = selected_material_source(settings)
+        matching = next((card for card in cards if card["provider"] == selected_source), None)
+        active_id = str(matching["id"]) if matching else str(cards[0]["id"])
+        settings[MATERIAL_ACTIVE_CARD_KEY] = active_id
+        changed = True
+
+    mapping = _cards_key_mapping(cards)
+    if settings.get("material_api_keys") != mapping:
+        _sync_legacy_material_keys(settings, mapping)
+        changed = True
+    return settings, changed
+
+
+def ensure_material_source_cards_for_ui(settings: dict[str, Any]) -> list[dict[str, Any]]:
+    migrated, _ = ensure_material_source_cards(settings)
+    return [dict(item) for item in migrated.get(MATERIAL_CARDS_KEY, [])]
+
+
+def new_material_card(provider: str, *, card_id: str | None = None) -> dict[str, Any]:
+    code = str(provider or "").strip().lower()
+    if code not in _SOURCE_BY_CODE:
+        raise ValueError("Fonte de materiais inválida.")
+    return _new_card(code, card_id=card_id)
+
+
+def apply_material_source_cards_to_settings(
+    settings: dict[str, Any],
+    cards: list[dict[str, Any]],
+    active_card_id: str = "",
+) -> dict[str, Any]:
+    normalized_cards = [normalize_material_card(item, index) for index, item in enumerate(cards)]
+    if not normalized_cards:
+        normalized_cards = [_new_card("pexels", card_id="material-default-0")]
+    settings[MATERIAL_CARDS_KEY] = normalized_cards
+    selected_card = next((card for card in normalized_cards if str(card["id"]) == str(active_card_id)), None)
+    if selected_card is None:
+        selected_card = next((card for card in normalized_cards if card.get("enabled", True)), normalized_cards[0])
+    settings[MATERIAL_ACTIVE_CARD_KEY] = str(selected_card["id"])
+    settings["video_source"] = str(selected_card["provider"])
+    _sync_legacy_material_keys(settings, _cards_key_mapping(normalized_cards))
+    return settings
+
+
+def material_api_keys(settings: dict[str, Any], source: str, _ignore_cards: bool = False) -> list[str]:
     code = str(source or "").strip().lower()
+    if not _ignore_cards:
+        cards = settings.get(MATERIAL_CARDS_KEY)
+        if isinstance(cards, list) and cards:
+            return _cards_key_mapping(cards).get(code, [])
     saved = settings.get("material_api_keys", {})
     if isinstance(saved, dict) and code in saved:
         return _as_key_list(saved.get(code))
-    legacy_key = next((item["legacy_key"] for item in MATERIAL_SOURCE_CATALOG if item["code"] == code), f"{code}_api_keys")
+    legacy_key = _SOURCE_BY_CODE.get(code, {}).get("legacy_key", f"{code}_api_keys")
     return _as_key_list(settings.get(legacy_key, ""))
 
 
@@ -47,18 +166,16 @@ def all_material_api_keys(settings: dict[str, Any]) -> dict[str, list[str]]:
 
 def update_material_api_keys(settings: dict[str, Any], source: str, keys: list[str]) -> dict[str, Any]:
     code = str(source or "").strip().lower()
-    if code not in {item["code"] for item in MATERIAL_SOURCE_CATALOG}:
+    if code not in _SOURCE_BY_CODE:
         raise ValueError("Fonte de materiais inválida.")
     cleaned = _as_key_list(keys)
     mapping = all_material_api_keys(settings)
     mapping[code] = cleaned
-    settings["material_api_keys"] = mapping
-    source_entry = next(item for item in MATERIAL_SOURCE_CATALOG if item["code"] == code)
-    settings[source_entry["legacy_key"]] = cleaned
+    _sync_legacy_material_keys(settings, mapping)
     return settings
 
 
 def selected_material_source(settings: dict[str, Any]) -> str:
     source = str(settings.get("video_source") or "pexels").strip().lower()
-    valid = {item["code"] for item in MATERIAL_SOURCE_CATALOG} | {"local"}
+    valid = set(_SOURCE_BY_CODE) | {"local"}
     return source if source in valid else "pexels"

package/package.json

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