@danhachuel/thunderbolt 0.2.60 → 0.2.61

package/app/main.py

@@ -42,7 +42,7 @@ from integrations.platforms import IntegrationResult, TikTokAdapter, YouTubeAdap
 from integrations.postiz import PostizAdapter
 from integrations.upload_routing import OFFICIAL_DAILY_LIMIT, official_upload_count, upload_with_default_route
 from integrations.youtube_direct_upload import YouTubeDirectUploader
-from integrations.youtube_direct_credentials import delete_credentials_document, direct_account_status, document_status, ensure_credentials_document, merge_credentials_document, parse_credentials_document, save_credentials_document, update_credentials_document_session_info
+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
 from integrations.youtube_batch import account_key as youtube_batch_account_key, account_status as youtube_batch_account_status, authorize_account as authorize_youtube_batch_account, delete_account_token as delete_youtube_batch_token, list_my_channels as list_youtube_batch_channels, loopback_redirect_uri
 from integrations.local_runtime import MoneyPrinterRuntime
 from integrations.moneyprinter_config import sync_moneyprinter_config
@@ -2571,7 +2571,7 @@ def render_settings():
             account_email_snapshot = str(batch_account.get("email") or "sem e-mail")
             account_label_snapshot = str(batch_account.get("label") or "Canais YouTube")
             ensure_credentials_document(STORAGE, batch_account, settings, channel_state)
-            direct_status = direct_account_status(STORAGE, batch_account)
+            direct_status = direct_account_status(STORAGE, batch_account, settings)
             missing_document_parts = list(direct_status.get("missing_cookies", []))
             if not direct_status.get("has_session_info"):
                 missing_document_parts.append("sessionInfo")
@@ -2678,6 +2678,31 @@ def render_settings():
         if youtube_accounts_missing_document:
             st.info("Contas que ainda precisam de dados no documento: " + ", ".join(youtube_accounts_missing_document))
 
+        st.divider()
+        st.markdown("### INNERTUBE_API_KEY")
+        st.caption("Esta chave pertence à conta Google/YouTube seleccionada e fica guardada na configuração da conta. Não faz parte do documento de cookies/credenciais e não é editada no separador API Keys.")
+        account_key_options = [str(account.get("id")) for account in batch_accounts if account.get("id")]
+        account_key_labels = {str(account.get("id")): f"{account.get('label', 'Canais YouTube')} — {account.get('email', 'sem e-mail')}" for account in batch_accounts if account.get("id")}
+        if account_key_options:
+            with st.form("innertube_api_key_form"):
+                selected_key_account_id = st.selectbox("Conta Google/YouTube", account_key_options, format_func=lambda value: account_key_labels.get(value, value), key="innertube_key_account")
+                selected_key_account = next(account for account in batch_accounts if str(account.get("id")) == selected_key_account_id)
+                current_innertube_api_key = direct_account_status(STORAGE, selected_key_account, settings).get("innertube_api_key", "")
+                innertube_api_key_value = st.text_input("INNERTUBE_API_KEY", value=current_innertube_api_key, type="password", key=f"innertube_api_key_{selected_key_account_id}", help="Chave usada pelo Upload directo desta conta. Guarde-a aqui, separada do documento de cookies.")
+                save_innertube_api_key = st.form_submit_button("Guardar INNERTUBE_API_KEY", type="primary", use_container_width=True)
+            if save_innertube_api_key:
+                selected_key_account["innertube_api_key"] = innertube_api_key_value.strip()
+                selected_key_account.pop("INNERTUBE_API_KEY", None)
+                settings.pop("direct_innertube_api_key", None)
+                settings["youtube_batch_accounts"] = batch_accounts
+                write_json("settings.json", settings)
+                document = load_credentials_document(STORAGE, selected_key_account, settings, channel_state, create=True)
+                save_credentials_document(STORAGE, selected_key_account, document)
+                st.success("INNERTUBE_API_KEY guardada na configuração da conta Google/YouTube, fora do documento de cookies.")
+                st.rerun()
+        else:
+            st.info("Adicione primeiro uma conta Google/YouTube para configurar a INNERTUBE_API_KEY.")
+
         st.divider()
         st.markdown("### Adicionar outra conta Gmail")
         st.caption("Este formulário fica fora dos cartões das contas existentes. A associação de canais não depende da completude deste documento; ela apenas ficará pendente para Upload directo até os campos serem preenchidos.")
@@ -2689,7 +2714,7 @@ def render_settings():
                 new_account_client_id = st.text_input("OAuth Client ID", key="new_batch_account_client_id")
             with add_cols[1]:
                 new_account_client_secret = st.text_input("OAuth Client Secret", type="password", key="new_batch_account_client_secret")
-                new_account_session_info = st.text_input("sessionInfo token desta conta Google", type="password", key="new_batch_account_session_info", help="Token sessionInfo desta conta. Os cookies, INNERTUBE_API_KEY, chunk_size e delegated_session_ids continuam apenas no documento.")
+                new_account_session_info = st.text_input("sessionInfo token desta conta Google", type="password", key="new_batch_account_session_info", help="Token sessionInfo desta conta. Os cookies e delegated_session_ids ficam no documento; a INNERTUBE_API_KEY é configurada no bloco próprio acima.")
                 new_account_document = st.file_uploader("Documento de cookies/credenciais opcional", type=["json"], key="new_batch_account_credentials_document", help="Pode subir agora um JSON completo ou apenas o documento de cookies. Se não subir, será criado um credentials.json padrão vazio.")
             add_account = st.form_submit_button("Adicionar conta Google/YouTube", type="primary", use_container_width=True)
         if add_account:
@@ -2763,10 +2788,6 @@ def render_settings():
                 st.caption("A YouTube Data API Key é uma credencial Google Cloud separada do OAuth. Só é necessária se escolher o método YouTube Data API para consultar métricas oficiais. Não é necessária para Página pública — sem API Key, para autorizar OAuth ou para fazer upload.")
                 youtube_api_key = text_setting("YouTube Data API Key (opcional)", "youtube_api_key", secret=True, help_text="Credencial separada, criada em Google Cloud > APIs e serviços > Credenciais > Chave de API. Não cole aqui o Client ID nem o Client Secret.")
 
-            st.caption("As credenciais e parâmetros do Upload directo — cookies, sessionInfo, INNERTUBE_API_KEY, chunk_size e DELEGATED_SESSION_ID — são lidos exclusivamente do documento JSON por conta Google. Não são editados nesta UI.")
-            direct_innertube_api_key = str(settings.get("direct_innertube_api_key", "") or "")
-            direct_chunk_size = int(settings.get("direct_chunk_size", 262144) or 262144)
-
             with st.expander("Serviço, materiais e rede"):
                 cols = st.columns(2)
                 with cols[0]:
@@ -2917,7 +2938,6 @@ def render_settings():
                     "youtube_client_id": youtube_client_id, "youtube_client_secret": youtube_client_secret,
                     "kaggle_username": kaggle_username.strip(), "kaggle_api_key": kaggle_api_key.strip(), "kaggle_kernel_slug": kaggle_kernel_slug.strip() or "thunderbolt-niche-finder",
                     "apify_api_token": apify_api_token.strip(), "apify_actor_id": apify_actor_id.strip() or DEFAULT_ACTOR_ID, "apify_poll_interval_seconds": int(apify_poll_interval), "apify_run_timeout_seconds": int(apify_run_timeout),
-                    "direct_innertube_api_key": direct_innertube_api_key, "direct_chunk_size": direct_chunk_size,
                     "log_level": log_level, "listen_host": listen_host, "listen_port": listen_port, "video_source": video_source,
                     "endpoint": endpoint, "proxy_http": proxy_http, "proxy_https": proxy_https, "match_materials_to_script": match_materials_to_script,
                     "llm_provider": llm_provider, "openai_api_key": openai_api_key, "openai_base_url": openai_base_url, "openai_model_name": openai_model_name,

package/integrations/youtube_direct_credentials.py

@@ -101,8 +101,7 @@ def parse_credentials_document(content: bytes, filename: str = DIRECT_DOCUMENT_N
         raise ValueError(f"Faltam cookies obrigatórios no documento {filename}: {', '.join(missing)}.")
     if not document["sessionInfo"]:
         raise ValueError(f"Falta sessionInfo no documento {filename}.")
-    if not document["INNERTUBE_API_KEY"]:
-        raise ValueError(f"Falta INNERTUBE_API_KEY no documento {filename}.")
+    # INNERTUBE_API_KEY é configurada separadamente na UI de Contas Google/YouTube.
     return document
 
 
@@ -128,6 +127,20 @@ def _account_session_info(account: dict[str, Any]) -> str:
     return str(account.get("sessionInfo") or account.get("session_info") or account.get("direct_session_info") or "").strip()
 
 
+def account_innertube_api_key(account: dict[str, Any] | None, document: dict[str, Any] | None = None, settings: dict[str, Any] | None = None) -> str:
+    """Return the account-level key; document value is only a legacy migration fallback."""
+    account = account or {}
+    document = document or {}
+    settings = settings or {}
+    return str(
+        account.get("innertube_api_key")
+        or account.get("INNERTUBE_API_KEY")
+        or settings.get("direct_innertube_api_key")
+        or document.get("INNERTUBE_API_KEY")
+        or ""
+    ).strip()
+
+
 def _normalise_document(raw: Any, account: dict[str, Any]) -> dict[str, Any]:
     raw = raw if isinstance(raw, dict) else {}
     cookies = _normalise_pairs(raw.get("cookies", raw))
@@ -187,7 +200,7 @@ def save_credentials_document(storage_root: Path, account: dict[str, Any], docum
         "email": normalised["email"],
         "sessionInfo": normalised["sessionInfo"],
         "cookies": normalised["cookies"],
-        "INNERTUBE_API_KEY": normalised["INNERTUBE_API_KEY"],
+        # INNERTUBE_API_KEY não pertence ao documento de cookies/credenciais.
         "chunk_size": normalised["chunk_size"],
         "delegated_session_ids": normalised["delegated_session_ids"],
     }
@@ -277,7 +290,7 @@ def merge_credentials_document(
 
     The upload may contain only cookies or the full Frontend API document. Existing
     non-empty values are preserved, so uploading cookies never discards sessionInfo,
-    INNERTUBE_API_KEY, chunk_size or delegated channel IDs.
+    chunk_size or delegated channel IDs. INNERTUBE_API_KEY is configured separately.
     """
     try:
         raw = json.loads(content.decode("utf-8-sig", errors="replace"))
@@ -295,8 +308,8 @@ def merge_credentials_document(
     incoming_session = _placeholder_to_empty(session_info_override) or incoming.get("sessionInfo", "")
     if incoming_session:
         merged["sessionInfo"] = incoming_session
-    if incoming.get("INNERTUBE_API_KEY"):
-        merged["INNERTUBE_API_KEY"] = incoming["INNERTUBE_API_KEY"]
+    # INNERTUBE_API_KEY recebida num JSON é deliberadamente ignorada: a fonte oficial
+    # é a configuração separada da secção Contas Google/YouTube.
     if "chunk_size" in raw:
         merged["chunk_size"] = incoming["chunk_size"]
     for key, value in incoming.get("delegated_session_ids", {}).items():
@@ -325,14 +338,16 @@ def document_status(storage_root: Path, account: dict[str, Any], channel: dict[s
     document = load_credentials_document(storage_root, account, settings, channels, create=True)
     missing_cookies = [key for key in COOKIE_KEYS if not document["cookies"].get(key)]
     delegated = delegated_session_id(document, channel or {}) if channel else ""
+    innertube_api_key = account_innertube_api_key(account, document, settings)
     return {
         "document_file": str(path),
         "document_exists": path.exists(),
         "missing_cookies": missing_cookies,
         "has_session_info": bool(document.get("sessionInfo")),
-        "has_innertube_api_key": bool(document.get("INNERTUBE_API_KEY")),
+        "has_innertube_api_key": bool(innertube_api_key),
+        "innertube_api_key": innertube_api_key,
         "has_delegated_session_id": bool(delegated) if channel is not None else None,
-        "ready": not missing_cookies and bool(document.get("sessionInfo")) and bool(document.get("INNERTUBE_API_KEY")) and (channel is None or bool(delegated)),
+        "ready": not missing_cookies and bool(document.get("sessionInfo")) and bool(innertube_api_key) and (channel is None or bool(delegated)),
     }
 
 
@@ -364,9 +379,9 @@ def save_cookie_file(storage_root: Path, account: dict[str, Any], content: bytes
     return destination
 
 
-def direct_account_status(storage_root: Path, account: dict[str, Any]) -> dict[str, Any]:
-    """Backward-compatible account status; the source of truth is credentials.json."""
-    status = document_status(storage_root, account)
+def direct_account_status(storage_root: Path, account: dict[str, Any], settings: dict[str, Any] | None = None) -> dict[str, Any]:
+    """Return account status; cookies stay in credentials.json and the API key is separate."""
+    status = document_status(storage_root, account, settings=settings)
     return {
         "cookie_file": status["document_file"],
         "document_exists": status["document_exists"],
@@ -374,6 +389,7 @@ def direct_account_status(storage_root: Path, account: dict[str, Any]) -> dict[s
         "missing_cookies": status["missing_cookies"],
         "has_session_info": status["has_session_info"],
         "has_innertube_api_key": status["has_innertube_api_key"],
+        "innertube_api_key": status.get("innertube_api_key", ""),
         "ready": status["ready"],
         "document_file": status["document_file"],
     }

package/integrations/youtube_direct_upload.py

@@ -9,7 +9,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
-from integrations.youtube_direct_credentials import COOKIE_KEYS, delegated_session_id, load_credentials_document
+from integrations.youtube_direct_credentials import COOKIE_KEYS, account_innertube_api_key, delegated_session_id, load_credentials_document
 from urllib.parse import quote
 
 import requests
@@ -49,7 +49,8 @@ def _session_info(settings: dict[str, Any], channel: dict[str, Any], account: di
 
 
 def _innertube_api_key(settings: dict[str, Any], channel: dict[str, Any], account: dict[str, Any] | None = None, storage_root: Path | None = None) -> str:
-    return str(_direct_document(settings, channel, account, storage_root).get("INNERTUBE_API_KEY", "") or "").strip()
+    document = _direct_document(settings, channel, account, storage_root)
+    return account_innertube_api_key(account, document, settings)
 
 
 def _delegated_session(settings: dict[str, Any], channel: dict[str, Any], account: dict[str, Any] | None = None, storage_root: Path | None = None) -> str:
@@ -96,7 +97,7 @@ def validate_direct_upload(video_path: str | Path, channel: dict[str, Any], sett
     if not _session_info(settings, channel, account, storage_root):
         return "Falta sessionInfo no documento de credenciais da conta."
     if not _innertube_api_key(settings, channel, account, storage_root):
-        return "Falta INNERTUBE_API_KEY no documento de credenciais da conta."
+        return "Falta INNERTUBE_API_KEY no cartão da conta Google/YouTube."
     if not _delegated_session(settings, channel, account, storage_root):
         return "Falta DELEGATED_SESSION_ID deste canal no documento de credenciais da conta."
     return None

package/package.json

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