"""Executa conferência de sessão e envios no navegador do perfil (Playwright conectado por CDP). Ciclo da janela (para a porta de depuração ficar aberta o mínimo): - "Conectar"/"Entrar de novo": abre a janela na página de login e deixa o usuário entrar (fecha sozinha após 15 min ociosa); - "Já entrei" (check): conferiu que está logado ⇒ fecha a janela (os cookies ficam no perfil); não está ⇒ deixa aberta para o usuário terminar o login; - envio: abre, envia e fecha. Se a rede pedir login/captcha, deixa aberta para o usuário resolver. """ from __future__ import annotations import threading import time from contextlib import contextmanager from pathlib import Path from typing import Any, Callable from ..base import JobSpec, Progress, PublishError, PublishResult, Sleep from . import instagram_web, tiktok_studio, youtube_studio from .browser import BrowserManager from .common import Uploader, screenshot UPLOADERS: dict[str, Uploader] = { "youtube": youtube_studio.UPLOADER, "tiktok": tiktok_studio.UPLOADER, "instagram": instagram_web.UPLOADER, } # Onde o usuário faz o login à mão (a janela abre aqui). LOGIN_URLS = { "youtube": "https://studio.youtube.com/", "tiktok": "https://www.tiktok.com/login", "instagram": "https://www.instagram.com/accounts/login/", } def browser_error_text(detail: str) -> str: """Frase em pt-BR para um erro do Playwright (o detalhe técnico vai junto, depois).""" if "larger than 50Mb" in detail: return "O navegador recusou o arquivo do vídeo por ser grande demais para a conexão atual. Reinicie o pnpm dev." if "Timeout" in detail and ".click" in detail: return ("Um botão ou campo da página não respondeu ao clique a tempo — em geral um aviso do site aberto por " "cima, ou o site mudou de layout. Veja a captura e tente de novo.") if "Timeout" in detail: return "A página demorou demais para responder. Confira a internet e a janela, e tente de novo." if "Target page, context or browser has been closed" in detail or "has been closed" in detail: return "A janela do navegador foi fechada no meio do envio. Deixe a janela aberta e tente de novo." return "O navegador travou ou mudou de página no meio do envio. Confira a janela e tente de novo." class SessionRunner: def __init__(self, browsers: BrowserManager, logs_dir: Path, sleep: Sleep = time.sleep): self.browsers = browsers self.logs_dir = logs_dir self.sleep = sleep # Uma ação de navegador por vez (conferência e envio não se atropelam). self.lock = threading.Lock() @contextmanager def _busy_guard(self, wait_s: float): if not self.lock.acquire(timeout=wait_s): raise PublishError("O navegador do Publicador está ocupado com um envio agora. Espere terminar e tente de novo.") try: yield finally: self.lock.release() def open_for_login(self, profile_id: str, platform: str) -> None: url = LOGIN_URLS[platform] was_open = self.browsers.is_open(profile_id) port = self.browsers.open(profile_id, url, for_login=True) if was_open: # janela já aberta: abre uma aba na página de login e traz para a frente with self._busy_guard(3), self.browsers.in_use(profile_id): self._with_page(port, lambda page: (page.goto(url), page.bring_to_front()), keep_page=True, label=f"{platform}-{profile_id}-abrir") def check(self, profile_id: str, platform: str) -> str | None: """None = sessão válida (e a janela é fechada); texto = motivo para entrar de novo (janela fica aberta).""" uploader = UPLOADERS[platform] holder: dict[str, Any] = {} with self._busy_guard(5): port = self.browsers.open(profile_id, uploader.upload_url, for_login=True) with self.browsers.in_use(profile_id): def run(page: Any) -> None: holder["reason"] = uploader.check(page, self.sleep) self._with_page(port, run, keep_page=lambda: holder.get("reason") is not None, label=f"{platform}-{profile_id}-check") if holder.get("reason") is None: self.browsers.close(profile_id) return holder.get("reason") def publish(self, spec: JobSpec, progress: Progress) -> PublishResult: uploader = UPLOADERS[spec.platform] holder: dict[str, Any] = {} with self.lock: port = self.browsers.open(spec.profile_id, uploader.upload_url) keep_window = False try: with self.browsers.in_use(spec.profile_id): def run(page: Any) -> None: holder["result"] = uploader.upload(page, spec, progress, self.sleep) self._with_page(port, run, keep_page=lambda: "result" not in holder, label=f"{spec.platform}-{spec.job_id}") except PublishError as exc: # Login/captcha: a janela fica para o usuário resolver (fecha sozinha se ficar ociosa). keep_window = exc.kind == "needs_login" raise finally: if not keep_window: self.browsers.close(spec.profile_id) return holder["result"] def read_stats(self, profile_id: str, platform: str, ids: list[str]) -> dict[str, Any]: """Números dos posts pela janela logada (só lê). Espera até 2 min um envio em andamento terminar. Fecha a janela no fim, a não ser que ela já estivesse aberta antes (o usuário pode estar usando).""" from .stats import READERS url, reader = READERS[platform] holder: dict[str, Any] = {} with self._busy_guard(120): was_open = self.browsers.is_open(profile_id) port = self.browsers.open(profile_id, url) try: with self.browsers.in_use(profile_id): def run(page: Any) -> None: holder["stats"] = reader(page, ids, self.sleep) self._with_page(port, run, keep_page=False, label=f"{platform}-{profile_id}-numeros") finally: if not was_open: self.browsers.close(profile_id) return holder.get("stats", {}) def _with_page(self, port: int, fn: Callable[[Any], Any], keep_page: bool | Callable[[], bool], label: str) -> None: try: from playwright.sync_api import Error as PlaywrightError from playwright.sync_api import sync_playwright except ImportError as exc: # pragma: no cover - depende da venv raise PublishError("O Playwright não está instalado no Publicador. Rode o setup.bat de novo.") from exc with sync_playwright() as pw: try: # is_local: o Chrome roda NESTE computador (127.0.0.1, a porta é conferida como nossa). Sem isso o # Playwright trata o navegador como remoto e recusa enviar arquivo > 50 MB ("Cannot transfer files # larger than 50Mb to a browser not co-located with the server") — e os cortes passam de 100 MB. browser = pw.chromium.connect_over_cdp(f"http://127.0.0.1:{port}", timeout=15000, is_local=True) except PlaywrightError as exc: raise PublishError("Não consegui me conectar à janela do navegador. Feche a janela do perfil e tente " "de novo.") from exc context = browser.contexts[0] if browser.contexts else browser.new_context() page = context.new_page() page.set_default_timeout(30000) keep = True try: fn(page) keep = keep_page() if callable(keep_page) else keep_page except PublishError as exc: # Sem captura em login/captcha/verificação (a tela pode ter dados pessoais); só em falha comum. if exc.kind == "failed": shot = screenshot(page, self.logs_dir, label) if shot: exc.message += f" (Captura: {shot.name})" exc.args = (exc.message,) raise except PlaywrightError as exc: shot = screenshot(page, self.logs_dir, label) raise PublishError(f"{browser_error_text(str(exc))}{f' (Captura: {shot.name})' if shot else ''} " f"Detalhe: {str(exc)[:160]}") from exc finally: if not keep: try: page.close() except PlaywrightError: pass # Aqui só desconectamos; quem fecha a janela (quando deve) é o BrowserManager.close, fora deste bloco.