@danhachuel/thunderbolt 0.5.86 → 0.5.88

package/integrations/youtube_batch.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import hashlib
+import errno
 import json
 import os
 import re
@@ -46,6 +47,14 @@ def _authorization_error_message(email: str, exc: Exception) -> str:
     return f"A autorização da conta {email} falhou: {detail}"
 
 
+def _is_address_in_use_error(exc: BaseException) -> bool:
+    """Return whether an OAuth callback bind failed because its port is busy."""
+    if getattr(exc, "winerror", None) == 10048 or getattr(exc, "errno", None) == errno.EADDRINUSE:
+        return True
+    detail = str(exc).lower()
+    return "10048" in detail or "address already in use" in detail or "only one usage" in detail
+
+
 def _text(value: Any) -> str:
     return str(value or "").strip()
 
@@ -115,15 +124,26 @@ def authorize_account(account: dict[str, Any], storage_root: Path, *, open_brows
     except ImportError as exc:
         return IntegrationResult(False, "As dependências Google OAuth ainda não estão instaladas. Execute a instalação do Thunderbolt novamente.", {"status": "missing_dependencies", "error": str(exc)})
     try:
-        flow = InstalledAppFlow.from_client_config(_client_config(account), BATCH_SCOPES)
-        credentials = flow.run_local_server(
-            host=loopback_host(),
-            port=loopback_port(),
-            open_browser=open_browser,
-            access_type="offline",
-            prompt="consent",
-            include_granted_scopes="true",
-        )
+        credentials = None
+        configured_port = loopback_port()
+        for attempt, port in enumerate((configured_port, 0)):
+            flow = InstalledAppFlow.from_client_config(_client_config(account), BATCH_SCOPES)
+            try:
+                credentials = flow.run_local_server(
+                    host=loopback_host(),
+                    port=port,
+                    open_browser=open_browser,
+                    access_type="offline",
+                    prompt="consent",
+                    include_granted_scopes="true",
+                )
+                break
+            except OSError as exc:
+                if attempt == 0 and _is_address_in_use_error(exc):
+                    continue
+                raise
+        if credentials is None:
+            raise RuntimeError("Não foi possível iniciar o callback OAuth local.")
         path = token_path(storage_root, account)
         _save_credentials(path, credentials)
         return IntegrationResult(True, f"Conta Google autorizada para listagem de canais: {email}.", {"status": "authorized", "email": email, "token_path": str(path)})

package/integrations/youtube_session_manager.py

@@ -14,6 +14,8 @@ import os
 import re
 import shutil
 import signal
+import subprocess
+import sys
 import time
 from contextlib import contextmanager
 from dataclasses import dataclass
@@ -52,6 +54,70 @@ DESCRIPTION_SELECTORS = [
 ]
 BLOCKED_TEXT = ("verify", "verificação", "verification", "captcha", "confirme que você é humano", "confirm it's you", "confirme que é você")
 
+
+class _BrowserUnavailableError(RuntimeError):
+    """Raised when Playwright cannot find or prepare a usable browser."""
+
+
+def _looks_like_missing_playwright_browser(error: BaseException) -> bool:
+    message = str(error).lower()
+    return "executable doesn't exist" in message or "executable does not exist" in message or "playwright was just installed" in message
+
+
+def _install_playwright_chromium() -> bool:
+    """Install the bundled Chromium once when Playwright reports it missing."""
+    try:
+        result = subprocess.run(
+            [os.fspath(sys.executable), "-m", "playwright", "install", "chromium"],
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=300,
+        )
+    except (OSError, subprocess.SubprocessError) as exc:
+        logger.warning("Não foi possível preparar o Chromium do Playwright: %s", _safe_error(exc))
+        return False
+    if result.returncode != 0:
+        detail = (result.stderr or result.stdout or "").strip().splitlines()
+        logger.warning("A instalação automática do Chromium falhou: %s", detail[-1] if detail else "erro desconhecido")
+        return False
+    return True
+
+
+def _launch_playwright_browser(playwright: Any) -> Any:
+    """Launch the configured browser, recovering from a missing Playwright binary."""
+    configured_path = str(os.environ.get("THUNDERBOLT_CHROME_PATH") or "").strip()
+    launch_kwargs: dict[str, Any] = {"headless": True}
+    if configured_path:
+        if not Path(configured_path).is_file():
+            raise _BrowserUnavailableError(f"Executável Chrome/Chromium não encontrado: {configured_path}")
+        launch_kwargs["executable_path"] = configured_path
+
+    try:
+        return playwright.chromium.launch(**launch_kwargs)
+    except Exception as initial_error:
+        if configured_path or not _looks_like_missing_playwright_browser(initial_error):
+            raise
+
+        # Prefer an already installed Google Chrome before downloading another
+        # browser. This is particularly useful on Windows machines where the
+        # Playwright cache was removed but Chrome itself is still available.
+        try:
+            return playwright.chromium.launch(headless=True, channel="chrome")
+        except Exception as chrome_error:
+            if not _looks_like_missing_playwright_browser(initial_error):
+                raise initial_error
+            if not _install_playwright_chromium():
+                raise _BrowserUnavailableError(
+                    "O Chromium do Playwright não está instalado e não foi possível prepará-lo automaticamente."
+                ) from chrome_error
+            try:
+                return playwright.chromium.launch(headless=True)
+            except Exception as retry_error:
+                raise _BrowserUnavailableError(
+                    "O Chromium do Playwright continua indisponível depois da instalação automática."
+                ) from retry_error
+
 try:
     from yt_cm import YouTubeCookieManager  # type: ignore
     YT_CM_AVAILABLE = True
@@ -203,7 +269,11 @@ def _capture_with_playwright(document: dict[str, Any], *, logs_dir: Path, video_
     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)
+        try:
+            browser = _launch_playwright_browser(playwright)
+        except _BrowserUnavailableError as exc:
+            logger.error("Browser Playwright indisponível: %s", _safe_error(exc))
+            return "browser_unavailable", None
         context = browser.new_context()
         context.add_cookies(cookies)
         page = context.new_page()
@@ -298,6 +368,14 @@ def renew_account_session(storage_root: Path, account: dict[str, Any], settings:
                 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 == "browser_unavailable":
+                    return RenewalResult(
+                        False,
+                        "browser_unavailable",
+                        "Renovação falhou: o Chromium do Playwright não está disponível. Execute novamente a instalação do Thunderbolt e tente renovar outra vez.",
+                        account_id,
+                        attempt,
+                    )
                 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)

package/package.json

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

package/scripts/cli.mjs

@@ -135,7 +135,7 @@ function check() {
     console.error(`Python não encontrado. Execute: npx.cmd --yes @danhachuel/thunderbolt install`);
     process.exit(1);
   }
-  const requiredModules = ["streamlit", "requests", "pandas", "toml", "imageio_ffmpeg", "edge_tts", "sklearn", "mlxtend", "plotly", "seaborn", "kagglehub", "composio"];
+  const requiredModules = ["streamlit", "requests", "pandas", "toml", "imageio_ffmpeg", "edge_tts", "sklearn", "mlxtend", "plotly", "seaborn", "kagglehub", "composio", "playwright"];
   const missing = requiredModules.filter((moduleName) => !moduleAvailable(moduleName));
   const ffmpeg = moduleAvailable("imageio_ffmpeg");
   const mptPath = configuredMoneyPrinterPath();

package/scripts/install.mjs

@@ -452,6 +452,17 @@ function installRequirementIfNeeded(requirementsPath, stateKey, modules, label)
   writeDependencyState({ [stateKey]: currentHash });
 }
 
+function installPlaywrightBrowsers() {
+  if (!existsSync(pythonBin)) return;
+  console.log("Playwright: a verificar o browser Chromium... ");
+  const result = spawnSync(pythonBin, ["-m", "playwright", "install", "chromium"], { stdio: "inherit", env: pythonEnvironment });
+  if (result.status !== 0) {
+    console.error("Não foi possível instalar o browser Chromium do Playwright.");
+    console.error("Execute novamente o instalador depois de confirmar o acesso à Internet.");
+    process.exit(result.status || 1);
+  }
+}
+
 function writeSettings(moneyprinterPath) {
   const stateDir = join(thunderboltHome, "storage", "state");
   mkdirSync(stateDir, { recursive: true });
@@ -470,7 +481,8 @@ function writeSettings(moneyprinterPath) {
 
 function installThunderboltDependencies(python) {
   if (!existsSync(pythonBin)) run(python.command, [...python.args, "-m", "venv", venvPath]);
-  installRequirementIfNeeded(join(root, "requirements.txt"), "thunderbolt_requirements_sha256", ["streamlit", "requests", "pandas", "toml", "imageio_ffmpeg", "edge_tts", "google.auth", "google_auth_oauthlib", "googleapiclient", "yt_dlp", "deno", "youtube_transcript_api", "huggingface_hub"], "Thunderbolt");
+  installRequirementIfNeeded(join(root, "requirements.txt"), "thunderbolt_requirements_sha256", ["streamlit", "requests", "pandas", "toml", "imageio_ffmpeg", "edge_tts", "google.auth", "google_auth_oauthlib", "googleapiclient", "yt_dlp", "deno", "youtube_transcript_api", "huggingface_hub", "playwright"], "Thunderbolt");
+  installPlaywrightBrowsers();
 }
 
 function installMoneyPrinterDependencies(moneyprinterPath) {