@danhachuel/thunderbolt 0.5.70 → 0.5.72

package/app/main.py

@@ -121,6 +121,7 @@ from integrations.upload_routing import OFFICIAL_DAILY_LIMIT, official_upload_co
 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
 from integrations.session_info_health import check_account_session_info_health
+from integrations.youtube_session_manager import renew_account_session
 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
@@ -6570,6 +6571,8 @@ def render_google_accounts(*, include_innertube: bool = True):
                 st.error(health_message, icon="⚠️")
             elif session_health.status == "unknown":
                 st.warning(health_message, icon="⚠️")
+            elif session_health.status in {"blocked_by_google", "invalid_format"}:
+                st.error(health_message, icon="⚠️")
             with st.expander("Detalhes da conta Google", expanded=False):
                 with st.form(f"batch_account_form_{account_id}"):
                     account_cols = st.columns(2)
@@ -6687,6 +6690,30 @@ def render_google_accounts(*, include_innertube: bool = True):
                         except ValueError as exc:
                             st.error(str(exc))
 
+                st.markdown("**Renovação de sessionInfo e cookies**")
+                st.caption("A renovação é manual ou opt-in antes do upload; não há timer residente nem execução ao seleccionar a conta.")
+                renewal_cols = st.columns([2, 1, 1])
+                auto_renew = renewal_cols[0].checkbox(
+                    "Renovar automaticamente antes do upload",
+                    value=bool(batch_account.get("auto_renew_before_upload", False)),
+                    key=f"auto_renew_before_upload_{account_id}",
+                )
+                if renewal_cols[1].button("Renovar agora", key=f"renew_session_info_{account_id}", type="primary", use_container_width=True):
+                    result = renew_account_session(STORAGE, batch_account, settings, force=True, wait_seconds=10)
+                    (st.success if result.ok else st.error)(result.message)
+                    if result.ok:
+                        st.rerun()
+                with renewal_cols[2]:
+                    _api_status_badge(
+                        "Configured" if session_health.status == "healthy" else ("Missing key" if session_health.status == "missing" else "Missing configuration"),
+                        "ready" if session_health.status == "healthy" else "missing",
+                    )
+                if auto_renew != bool(batch_account.get("auto_renew_before_upload", False)):
+                    batch_account["auto_renew_before_upload"] = bool(auto_renew)
+                    settings["youtube_batch_accounts"] = batch_accounts
+                    write_json("settings.json", settings)
+                    st.success("Preferência de renovação guardada para esta conta.")
+
     if youtube_accounts_missing_document:
         st.info("Contas que ainda precisam de dados no documento: " + ", ".join(youtube_accounts_missing_document))
 
@@ -6799,7 +6826,11 @@ def render_google_accounts(*, include_innertube: bool = True):
             st.rerun()
 
     st.divider()
-    st.subheader("Configuração Global: YouTube Data API v3 (API Key)")
+    youtube_global_cols = st.columns([3.2, 1.2])
+    with youtube_global_cols[0]:
+        st.subheader("Configuração Global: YouTube Data API v3 (API Key)")
+    with youtube_global_cols[1]:
+        _render_credential_status(settings.get("youtube_api_key"), required=True)
     st.caption("1. YouTube Data API v3: Metadados públicos (títulos, views, likes) Via MCP integrado.\n\n2. YouTube Analytics API: Métricas internas (CTR, retenção, RPM, tráfego, demografia) Via OAuth 2.0 (Directamente via OAuth das Contas Google/YouTube cadastradas)")
     with st.form("google_global_api_settings_form"):
         st.caption("A autorização OAuth 2.0 é gerida por cada Conta Google/YouTube cadastrada e associada ao canal.")
@@ -7848,6 +7879,9 @@ def render_settings():
         with st.expander("API Tiktok", expanded=False):
             render_tiktok_api_cards(settings)
         with st.expander("API Bilibili", expanded=False):
+            bilibili_cards = settings.get("bilibili_api_cards") if isinstance(settings.get("bilibili_api_cards"), list) else []
+            bilibili_ready = any(bool(card.get("active", True) and card.get("sessdata") and card.get("bili_jct") and card.get("buvid3")) for card in bilibili_cards if isinstance(card, dict))
+            _api_status_badge("Configured" if bilibili_ready else "Missing configuration", "ready" if bilibili_ready else "missing")
             render_bilibili_api_cards(settings)
         with st.expander("Composio", expanded=False):
             st.caption("A API key é guardada apenas no storage local. O slug da ferramenta e o provider são descobertos no Upload via Composio; a autenticação da conta é feita pelo Connect Link do Composio.")
@@ -7887,6 +7921,7 @@ def render_settings():
             upload_post_user_upload = st.text_input("Upload-Post username", value=str(settings.get("upload_post_username") or ""), key="upload_tab_upload_post_user")
             upload_post_platforms_upload = st.text_input("Plataformas Upload-Post", value=str(settings.get("upload_post_platforms") or "youtube,tiktok"), key="upload_tab_upload_post_platforms")
             upload_post_auto_upload = st.checkbox("Publicar automaticamente após gerar", bool(settings.get("upload_post_auto_upload", False)), key="upload_tab_upload_post_auto")
+            _render_credential_status(upload_post_key_upload, required=True)
             if st.button("Guardar Upload-Post", type="primary", use_container_width=True, key="upload_tab_save_upload_post"):
                 settings.update({"upload_post_enabled": bool(upload_post_enabled_upload), "upload_post_api_key": upload_post_key_upload.strip(), "upload_post_username": upload_post_user_upload.strip(), "upload_post_platforms": upload_post_platforms_upload.strip(), "upload_post_auto_upload": bool(upload_post_auto_upload)})
                 write_json("settings.json", settings)
@@ -7899,6 +7934,7 @@ def render_settings():
             postiz_mcp_upload = st.text_input("Postiz MCP URL", value=str(settings.get("postiz_mcp_url") or "https://api.postiz.com/mcp"), key="upload_tab_postiz_mcp")
             postiz_integration_upload = st.text_input("Postiz integração padrão", value=str(settings.get("postiz_integration_id") or ""), key="upload_tab_postiz_integration")
             postiz_auto_upload = st.checkbox("Permitir publicação imediata no Postiz", bool(settings.get("postiz_auto_publish", False)), key="upload_tab_postiz_auto")
+            _render_credential_status(postiz_key_upload, required=True)
             if st.button("Guardar Postiz", type="primary", use_container_width=True, key="upload_tab_save_postiz"):
                 settings.update({"postiz_enabled": bool(postiz_enabled_upload), "postiz_api_key": postiz_key_upload.strip(), "postiz_base_url": postiz_base_upload.strip(), "postiz_mcp_url": postiz_mcp_upload.strip(), "postiz_integration_id": postiz_integration_upload.strip(), "postiz_auto_publish": bool(postiz_auto_upload)})
                 write_json("settings.json", settings)

package/integrations/session_info_health.py

@@ -8,6 +8,7 @@ conta Google/YouTube.
 """
 from __future__ import annotations
 
+import json
 from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
@@ -15,10 +16,10 @@ from typing import Any
 
 from integrations.youtube_direct_credentials import credentials_document_path, load_credentials_document
 
-DEFAULT_SESSION_INFO_TTL_HOURS = 36
+DEFAULT_SESSION_INFO_TTL_HOURS = 19
 DEFAULT_SESSION_INFO_ALERT_HOURS = 6
-MIN_SESSION_INFO_TTL_HOURS = 24
-MAX_SESSION_INFO_TTL_HOURS = 48
+MIN_SESSION_INFO_TTL_HOURS = 1
+MAX_SESSION_INFO_TTL_HOURS = 72
 
 
 def utc_now() -> datetime:
@@ -28,6 +29,11 @@ def utc_now() -> datetime:
 
 def parse_timestamp(value: Any) -> datetime | None:
     """Parse ISO-8601 timestamps used in local credential documents."""
+    if isinstance(value, (int, float)):
+        try:
+            return datetime.fromtimestamp(float(value), tz=timezone.utc)
+        except (TypeError, ValueError, OSError, OverflowError):
+            return None
     text = str(value or "").strip()
     if not text:
         return None
@@ -118,11 +124,17 @@ def health_check_session_info(
     file_text = str(credential_file or "")
     if not session_info:
         return SessionInfoHealth("missing", "Falta sessionInfo nesta conta Google/YouTube.", None, None, None, None, account_id, account_label, file_text, False, True)
+    if str(document.get("sessionInfoHealthStatus") or "").strip() == "blocked_by_google":
+        return SessionInfoHealth("blocked_by_google", "Sessão bloqueada pelo Google; é necessário login manual.", None, None, None, captured.isoformat() if captured else None, account_id, account_label, file_text, True, True)
+    if str(document.get("sessionInfoHealthStatus") or "").strip() == "invalid_format":
+        return SessionInfoHealth("invalid_format", "sessionInfo capturado, mas o formato foi rejeitado.", None, None, None, captured.isoformat() if captured else None, account_id, account_label, file_text, True, True)
     if captured is None:
-        return SessionInfoHealth("unknown", "sessionInfo existe, mas a data de captura não é conhecida; guarde novamente o token para activar o alerta de expiração.", None, None, None, None, account_id, account_label, file_text, True, True)
+        # Legacy documents without a capture date remain compatible with the
+        # existing uploader, while the UI still asks for a manual renewal.
+        return SessionInfoHealth("unknown", "sessionInfo existe, mas a data de captura não é conhecida; renove a sessão para activar o alerta de expiração.", None, None, None, None, account_id, account_label, file_text, True, True)
     age = max(0.0, (current - captured.astimezone(timezone.utc)).total_seconds() / 3600)
-    remaining = float(ttl) - age
-    expires = captured.astimezone(timezone.utc) + timedelta(hours=ttl)
+    expires = parse_timestamp(document.get("expires_at")) or (captured.astimezone(timezone.utc) + timedelta(hours=ttl))
+    remaining = (expires - current.astimezone(timezone.utc)).total_seconds() / 3600
     if remaining <= 0:
         return SessionInfoHealth("expired", f"sessionInfo expirou há {abs(remaining):.1f} horas; renove-o manualmente antes de criar ou enviar conteúdos.", age, remaining, expires.isoformat(), captured.isoformat(), account_id, account_label, file_text, True, True)
     if remaining <= alert:
@@ -160,6 +172,14 @@ def check_account_session_info_health(
     """Load one account document and return its safe SessionInfo health state."""
     settings = settings or {}
     document = load_credentials_document(storage_root, account, settings, create=False)
+    state_path = credentials_document_path(storage_root, account).with_name("renewal_state.json")
+    try:
+        state = json.loads(state_path.read_text(encoding="utf-8")) if state_path.exists() else {}
+    except (OSError, json.JSONDecodeError):
+        state = {}
+    if isinstance(state, dict) and state.get("status") in {"blocked_by_google", "invalid_format"}:
+        document = dict(document)
+        document["sessionInfoHealthStatus"] = state["status"]
     return session_info_health_from_settings(
         account,
         document,

package/integrations/upload_routing.py

@@ -18,6 +18,7 @@ from integrations.postiz import PostizAdapter
 from integrations.session_info_health import check_account_session_info_health, emit_session_info_health_alerts
 from integrations.youtube_direct_credentials import document_status
 from integrations.youtube_direct_upload import YouTubeDirectUploader
+from integrations.youtube_session_manager import renew_account_session
 from integrations.composio_upload import ComposioUploadError, execute_upload
 from hermes_ui.storage import read_json, write_json
 from hermes_ui.languages import language_locale
@@ -157,6 +158,16 @@ def upload_with_default_route(
     direct_ready = False
     if account:
         try:
+            renewal_warning = ""
+            if bool(account.get("auto_renew_before_upload", settings.get("auto_renew_before_upload", False))):
+                current_health = check_account_session_info_health(storage_root, account, settings)
+                if current_health.status in {"expiring", "expired"}:
+                    renewal = renew_account_session(storage_root, account, settings, wait_seconds=10)
+                    if not renewal.ok:
+                        renewal_warning = f"Renovação automática não concluída ({renewal.status}); o upload pode falhar."
+                        attempts.append({"route": "Renovação sessionInfo", "status": "failed", "message": renewal_warning, "data": {"status": renewal.status}})
+                    else:
+                        attempts.append({"route": "Renovação sessionInfo", "status": "success", "message": renewal.message, "data": {"status": renewal.status}})
             status = document_status(storage_root, account, channel, settings, [channel])
             health = check_account_session_info_health(storage_root, account, settings)
             emit_session_info_health_alerts([health])
@@ -165,7 +176,7 @@ def upload_with_default_route(
                 direct_result = IntegrationResult(
                     False,
                     f"Upload directo indisponível: {health.message}",
-                    {"missing": ["sessionInfo"], "session_info_health": health.as_dict()},
+                    {"missing": ["sessionInfo"], "session_info_health": health.as_dict(), "renewal_warning": renewal_warning},
                 )
             elif not direct_ready:
                 missing = list(status.get("missing_cookies", []))
@@ -175,7 +186,7 @@ def upload_with_default_route(
                     missing.append("INNERTUBE_API_KEY")
                 if not status.get("has_delegated_session_id"):
                     missing.append("DELEGATED_SESSION_ID")
-                direct_result = IntegrationResult(False, f"Upload directo indisponível: {', '.join(missing)}.", {"missing": missing})
+                direct_result = IntegrationResult(False, f"Upload directo indisponível: {', '.join(missing)}. {renewal_warning}".strip(), {"missing": missing, "renewal_warning": renewal_warning})
             else:
                 direct_result = None
         except Exception as exc:

package/integrations/youtube_direct_credentials.py

@@ -185,6 +185,10 @@ def _normalise_document(raw: Any, account: dict[str, Any]) -> dict[str, Any]:
         "email": str(raw.get("email") or account.get("email") or "").strip(),
         "sessionInfo": _placeholder_to_empty(raw.get("sessionInfo") or raw.get("session_info") or raw.get("direct_session_info") or _account_session_info(account)),
         "sessionInfoCapturedAt": str(raw.get("sessionInfoCapturedAt") or raw.get("session_info_captured_at") or account.get("sessionInfoCapturedAt") or account.get("session_info_captured_at") or "").strip(),
+        "expires_at": raw.get("expires_at") or account.get("expires_at") or "",
+        "sessionInfoHealthStatus": str(raw.get("sessionInfoHealthStatus") or "").strip(),
+        "renewalLastAttemptAt": str(raw.get("renewalLastAttemptAt") or "").strip(),
+        "renewalLastSuccessAt": str(raw.get("renewalLastSuccessAt") or "").strip(),
         "cookies": {key: cookies.get(key, "") for key in COOKIE_KEYS},
         "INNERTUBE_API_KEY": _placeholder_to_empty(raw.get("INNERTUBE_API_KEY") or raw.get("innertube_api_key") or raw.get("direct_innertube_api_key") or ""),
         "chunk_size": _safe_chunk_size(raw.get("chunk_size", raw.get("direct_chunk_size", DEFAULT_CHUNK_SIZE))),
@@ -229,6 +233,10 @@ def save_credentials_document(storage_root: Path, account: dict[str, Any], docum
         "email": normalised["email"],
         "sessionInfo": normalised["sessionInfo"],
         "sessionInfoCapturedAt": normalised.get("sessionInfoCapturedAt", ""),
+        "expires_at": normalised.get("expires_at", ""),
+        "sessionInfoHealthStatus": normalised.get("sessionInfoHealthStatus", ""),
+        "renewalLastAttemptAt": normalised.get("renewalLastAttemptAt", ""),
+        "renewalLastSuccessAt": normalised.get("renewalLastSuccessAt", ""),
         "cookies": normalised["cookies"],
         # INNERTUBE_API_KEY não pertence ao documento de cookies/credenciais.
         "chunk_size": normalised["chunk_size"],

package/integrations/youtube_session_manager.py

@@ -0,0 +1,371 @@
+"""Safe, opt-in renewal of YouTube cookies and sessionInfo per account.
+
+The module is deliberately one-shot: it never starts Streamlit, workers, or a
+resident polling loop. Browser automation is best-effort and refuses Google
+verification/CAPTCHA pages instead of attempting to bypass them.
+"""
+from __future__ import annotations
+
+import argparse
+import base64
+import json
+import logging
+import os
+import re
+import shutil
+import signal
+import time
+from contextlib import contextmanager
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any, Iterator
+
+from integrations.session_info_health import check_account_session_info_health
+from integrations.youtube_direct_credentials import (
+    COOKIE_KEYS,
+    account_directory,
+    account_key,
+    credentials_document_path,
+    load_credentials_document,
+)
+
+logger = logging.getLogger(__name__)
+LOCK_TIMEOUT_SECONDS = 300
+LOCK_WAIT_SECONDS = 10
+MAX_CAPTURE_ATTEMPTS = 2
+TITLE_SELECTORS = [
+    'input[aria-label="Título"]',
+    'input[aria-label="Title"]',
+    'input[name="title"]',
+    'input[placeholder*="Título"]',
+    'input[placeholder*="Title"]',
+    'ytcp-text-input#title-text-input',
+]
+DESCRIPTION_SELECTORS = [
+    'textarea[aria-label="Descrição"]',
+    'textarea[aria-label="Description"]',
+    'textarea[name="description"]',
+    'textarea[placeholder*="Descrição"]',
+    'textarea[placeholder*="Description"]',
+    'ytcp-mention-drawer textarea',
+]
+BLOCKED_TEXT = ("verify", "verificação", "verification", "captcha", "confirme que você é humano", "confirm it's you", "confirme que é você")
+
+try:
+    from yt_cm import YouTubeCookieManager  # type: ignore
+    YT_CM_AVAILABLE = True
+except ImportError:  # optional by design
+    YouTubeCookieManager = None  # type: ignore
+    YT_CM_AVAILABLE = False
+
+
+def is_yt_cm_available() -> bool:
+    """Return whether optional yt-cm can be imported."""
+    return bool(YT_CM_AVAILABLE)
+
+
+def validate_session_info(token: str | None) -> bool:
+    """Validate the conservative Base64-like shape required by the plan."""
+    value = str(token or "").strip()
+    return bool(value and len(value) >= 50 and re.fullmatch(r"[A-Za-z0-9+/=]+", value))
+
+
+def _safe_error(exc: BaseException) -> str:
+    text = str(exc)
+    for secret in ("sessionInfo", "SID", "SSID", "HSID", "APISID", "SAPISID"):
+        text = text.replace(secret, "[redacted]")
+    return text[:500]
+
+
+def _pid_alive(pid: int) -> bool:
+    if pid <= 0:
+        return False
+    try:
+        os.kill(pid, 0)
+    except (OSError, ProcessLookupError):
+        return False
+    except PermissionError:
+        return True
+    return True
+
+
+@contextmanager
+def account_lock(account_dir: Path, account_id: str, *, wait_seconds: int = 0) -> Iterator[None]:
+    """Acquire an atomic per-account lock, removing only dead/expired locks."""
+    account_dir.mkdir(parents=True, exist_ok=True)
+    path = account_dir / f"{account_key({'id': account_id})}.lock"
+    deadline = time.monotonic() + max(0, wait_seconds)
+    acquired = False
+    while not acquired:
+        payload = {"pid": os.getpid(), "acquired_at": datetime.now(timezone.utc).isoformat(), "timeout_seconds": LOCK_TIMEOUT_SECONDS}
+        try:
+            fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o600)
+            with os.fdopen(fd, "w", encoding="utf-8") as handle:
+                json.dump(payload, handle)
+            acquired = True
+        except FileExistsError:
+            stale = False
+            try:
+                current = json.loads(path.read_text(encoding="utf-8"))
+                pid = int(current.get("pid", 0))
+                acquired_at = datetime.fromisoformat(str(current.get("acquired_at", "")).replace("Z", "+00:00"))
+                age = (datetime.now(timezone.utc) - (acquired_at if acquired_at.tzinfo else acquired_at.replace(tzinfo=timezone.utc))).total_seconds()
+                stale = age > LOCK_TIMEOUT_SECONDS or not _pid_alive(pid)
+            except (OSError, ValueError, TypeError, json.JSONDecodeError):
+                stale = True
+            if stale:
+                try:
+                    path.unlink()
+                except FileNotFoundError:
+                    pass
+                continue
+            if time.monotonic() >= deadline:
+                raise TimeoutError("lock de renovação já está activo")
+            time.sleep(0.25)
+    try:
+        yield
+    finally:
+        try:
+            current = json.loads(path.read_text(encoding="utf-8"))
+            if int(current.get("pid", -1)) == os.getpid():
+                path.unlink(missing_ok=True)
+        except (OSError, ValueError, TypeError, json.JSONDecodeError):
+            pass
+
+
+def _rotate_backups(destination: Path) -> None:
+    bak, bak1, bak2 = (destination.with_name(destination.name + suffix) for suffix in (".bak", ".bak1", ".bak2"))
+    if bak1.exists():
+        os.replace(bak1, bak2)
+    if bak.exists():
+        os.replace(bak, bak1)
+    if destination.exists():
+        shutil.copy2(destination, bak)
+
+
+def _write_renewal_state(directory: Path, status: str) -> None:
+    """Persist only non-secret renewal state for the UI/health check."""
+    path = directory / "renewal_state.json"
+    path.write_text(json.dumps({"status": status, "updated_at": datetime.now(timezone.utc).isoformat()}), encoding="utf-8")
+
+
+def atomic_save_credentials(destination: Path, document: dict[str, Any]) -> None:
+    """Rotate three backups, atomically replace, and restore on failure."""
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    _rotate_backups(destination)
+    temporary = destination.with_name(f".{destination.name}.{os.getpid()}.tmp")
+    try:
+        temporary.write_text(json.dumps(document, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+        try:
+            os.chmod(temporary, 0o600)
+        except OSError:
+            pass
+        os.replace(temporary, destination)
+    except Exception:
+        temporary.unlink(missing_ok=True)
+        latest = destination.with_name(destination.name + ".bak")
+        if latest.exists():
+            os.replace(latest, destination)
+        raise
+
+
+def _blocked_page(page: Any) -> bool:
+    try:
+        body = str(page.locator("body").inner_text(timeout=2000)).lower()
+        if any(marker in body for marker in BLOCKED_TEXT):
+            return True
+        if page.locator('input[type="email"], input[type="password"], iframe[src*="captcha"], iframe[title*="captcha" i]').count() > 0:
+            return True
+    except Exception:
+        return False
+    return False
+
+
+def _first_selector(page: Any, selectors: list[str]) -> str | None:
+    for selector in selectors:
+        try:
+            page.wait_for_selector(selector, timeout=3000)
+            logger.debug("Selector YouTube utilizado: %s", selector)
+            return selector
+        except Exception:
+            continue
+    return None
+
+
+def _capture_with_playwright(document: dict[str, Any], *, logs_dir: Path, video_id: str = "") -> tuple[str, str | None]:
+    try:
+        from playwright.sync_api import sync_playwright  # type: ignore
+    except ImportError:
+        logger.warning("Playwright não instalado; captura sessionInfo indisponível.")
+        return "browser_unavailable", None
+    captured: list[str] = []
+    logs_dir.mkdir(parents=True, exist_ok=True)
+    cookies = [{"name": key, "value": str(document["cookies"][key]), "domain": ".youtube.com", "path": "/"} for key in COOKIE_KEYS if document.get("cookies", {}).get(key)]
+    with sync_playwright() as playwright:
+        browser = playwright.chromium.launch(headless=True)
+        context = browser.new_context()
+        context.add_cookies(cookies)
+        page = context.new_page()
+
+        def on_response(response: Any) -> None:
+            try:
+                text = response.text()
+                for match in re.findall(r"[A-Za-z0-9+/=]{50,}", text):
+                    if validate_session_info(match):
+                        captured.append(match)
+                        break
+            except Exception:
+                pass
+
+        page.on("response", on_response)
+        try:
+            url = "https://studio.youtube.com/"
+            if video_id:
+                url += f"video/{video_id}/edit"
+            page.goto(url, wait_until="domcontentloaded", timeout=30000)
+            if _blocked_page(page):
+                logger.warning("🔒 Sessão bloqueada pelo Google. Renovação manual necessária.")
+                return "blocked_by_google", None
+            selector = _first_selector(page, TITLE_SELECTORS)
+            if selector is None:
+                selector = _first_selector(page, DESCRIPTION_SELECTORS)
+            if selector is None:
+                screenshot = logs_dir / f"failure_{datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%SZ')}.png"
+                page.screenshot(path=str(screenshot), full_page=True)
+                logger.error("Nenhum selector de título ou descrição do YouTube foi encontrado; screenshot: %s", screenshot)
+                return "selector_failure", None
+            try:
+                page.locator(selector).focus()
+                page.keyboard.press("Escape")
+            except Exception:
+                pass
+            page.wait_for_timeout(1500)
+            for token in captured:
+                if validate_session_info(token):
+                    return "captured", token
+            return "invalid_format", None
+        finally:
+            context.close()
+            browser.close()
+
+
+def _try_renew_cookies(document: dict[str, Any], account: dict[str, Any]) -> dict[str, Any]:
+    if not is_yt_cm_available():
+        logger.warning("⚠️ yt-cm não encontrado. A renovação de cookies será pulada. Instale com: pip install yt-cm")
+        return document
+    manager = YouTubeCookieManager()  # type: ignore[operator]
+    for method_name in ("renew", "refresh", "validate"):
+        method = getattr(manager, method_name, None)
+        if callable(method):
+            result = method(document.get("cookies", {}), account=account)
+            if isinstance(result, dict):
+                document["cookies"] = {key: str(result.get(key, document["cookies"].get(key, ""))) for key in COOKIE_KEYS}
+            break
+    return document
+
+
+@dataclass(frozen=True)
+class RenewalResult:
+    ok: bool
+    status: str
+    message: str
+    account_id: str
+    attempts: int = 0
+
+    def as_dict(self) -> dict[str, Any]:
+        return {"ok": self.ok, "status": self.status, "message": self.message, "account_id": self.account_id, "attempts": self.attempts}
+
+
+def renew_account_session(storage_root: Path, account: dict[str, Any], settings: dict[str, Any] | None = None, *, force: bool = False, wait_seconds: int = 0, logs_dir: Path | None = None) -> RenewalResult:
+    settings = settings or {}
+    account_id = str(account.get("id") or "").strip()
+    if not account_id:
+        return RenewalResult(False, "invalid_account", "Conta Google sem ID.", "")
+    health = check_account_session_info_health(storage_root, account, settings)
+    if not force and health.status not in {"expiring", "expired", "missing", "invalid_format"}:
+        return RenewalResult(True, health.status, "Renovação não necessária.", account_id)
+    directory = account_directory(storage_root, account)
+    destination = credentials_document_path(storage_root, account)
+    logs_dir = logs_dir or directory / "logs"
+    try:
+        with account_lock(directory, account_id, wait_seconds=wait_seconds):
+            document = load_credentials_document(storage_root, account, settings, create=False)
+            document = dict(document)
+            try:
+                document = _try_renew_cookies(document, account)
+            except Exception as exc:
+                return RenewalResult(False, "cookie_renewal_failed", f"Falha na renovação de cookies: {_safe_error(exc)}", account_id)
+            for attempt in range(1, MAX_CAPTURE_ATTEMPTS + 1):
+                capture_status, token = _capture_with_playwright(document, logs_dir=logs_dir, video_id=str(account.get("video_id") or ""))
+                if capture_status == "blocked_by_google":
+                    _write_renewal_state(directory, "blocked_by_google")
+                    return RenewalResult(False, "blocked_by_google", "🔒 Sessão bloqueada pelo Google. Renovação manual necessária.", account_id, attempt)
+                if validate_session_info(token):
+                    document["sessionInfo"] = token
+                    now = datetime.now(timezone.utc).isoformat()
+                    document["sessionInfoCapturedAt"] = now
+                    document["expires_at"] = (datetime.now(timezone.utc) + timedelta(hours=19)).isoformat()
+                    document["sessionInfoHealthStatus"] = ""
+                    atomic_save_credentials(destination, document)
+                    _write_renewal_state(directory, "healthy")
+                    return RenewalResult(True, "healthy", "sessionInfo renovado com sucesso.", account_id, attempt)
+                logger.warning("sessionInfo capturado, mas formato inválido. Descartando.")
+            _write_renewal_state(directory, "invalid_format")
+            return RenewalResult(False, "invalid_format", "Não foi possível capturar um sessionInfo válido.", account_id, MAX_CAPTURE_ATTEMPTS)
+    except TimeoutError as exc:
+        return RenewalResult(False, "lock_timeout", str(exc), account_id)
+    except Exception as exc:
+        return RenewalResult(False, "renewal_failed", f"Renovação falhou: {_safe_error(exc)}", account_id)
+
+
+def _accounts_from_settings(settings: dict[str, Any]) -> list[dict[str, Any]]:
+    accounts = settings.get("youtube_batch_accounts", [])
+    return [item for item in accounts if isinstance(item, dict) and str(item.get("id") or "").strip()] if isinstance(accounts, list) else []
+
+
+def run_all_accounts(storage_root: Path, settings: dict[str, Any]) -> int:
+    renewed = failed = ignored = 0
+    for account in _accounts_from_settings(settings):
+        enabled = bool(account.get("auto_renew_enabled", settings.get("auto_renew_enabled", False)))
+        if not enabled:
+            ignored += 1
+            continue
+        health = check_account_session_info_health(storage_root, account, settings)
+        if health.status not in {"expiring", "expired"}:
+            ignored += 1
+            continue
+        result = renew_account_session(storage_root, account, settings)
+        if result.ok:
+            renewed += 1
+        else:
+            failed += 1
+    logger.info("Renovadas: %s, Falhas: %s, Ignoradas: %s", renewed, failed, ignored)
+    return 1 if failed else 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Renovação única de sessões YouTube")
+    parser.add_argument("--all-accounts", action="store_true")
+    parser.add_argument("--account-id")
+    parser.add_argument("--storage-root", default=os.environ.get("THUNDERBOLT_STORAGE_DIR", "storage"))
+    args = parser.parse_args(argv)
+    root = Path(args.storage_root)
+    settings_path = root / "state" / "settings.json"
+    try:
+        settings = json.loads(settings_path.read_text(encoding="utf-8")) if settings_path.exists() else {}
+    except (OSError, json.JSONDecodeError):
+        settings = {}
+    if args.all_accounts:
+        return run_all_accounts(root, settings)
+    accounts = [a for a in _accounts_from_settings(settings) if str(a.get("id")) == str(args.account_id)]
+    if not accounts:
+        return 1
+    result = renew_account_session(root, accounts[0], settings, force=True)
+    return 0 if result.ok else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+
+__all__ = ["RenewalResult", "TITLE_SELECTORS", "account_lock", "atomic_save_credentials", "is_yt_cm_available", "renew_account_session", "run_all_accounts", "validate_session_info"]

package/package.json

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