"""Navegador do modo "sessão logada". Regra do projeto (inviolável): o Chrome/Edge é aberto como PROCESSO NORMAL e VISÍVEL, com um perfil próprio e vazio (`--user-data-dir=data/publisher/browser/`). O usuário faz o login à mão, com 2FA se tiver. Só DEPOIS o serviço se conecta pela porta de depuração (CDP, faixa 4540–4549) com o Playwright (`connect_over_cdp`). Nada de navegador "de automação", stealth, patchright ou burla de detecção — o Google bloqueia login em navegador controlado e não vamos tentar contornar isso. A porta de depuração dá controle total do navegador a quem falar com ela, então ela fica aberta o MENOS possível: a janela é fechada depois de cada envio, depois da conferência bem-sucedida ("Já entrei") e quando fica ociosa (5 min; 15 min se foi aberta para o login). Antes de usar uma porta, conferimos que ela é do NOSSO navegador (o `DevToolsActivePort` do perfil, quando existe; senão a marca `CenaForgeWindow.json` + o PID que escuta na porta — o Chrome 157+ com porta fixa não grava o `DevToolsActivePort`). O pacote `playwright` entra só pelo driver: NUNCA rodar `playwright install` (não baixa navegador nenhum). """ from __future__ import annotations import json import os import shutil import socket import subprocess import sys import threading import time import urllib.request from contextlib import contextmanager from dataclasses import dataclass from pathlib import Path from ...config import BROWSER_PORT_RANGE from ..base import PublishError # Janela ociosa é fechada sozinha (reduz o tempo com a porta CDP aberta). IDLE_CLOSE_S = 5 * 60 # A janela aberta para o usuário entrar na conta ganha mais tempo (login com 2FA pode demorar). LOGIN_IDLE_CLOSE_S = 15 * 60 @dataclass(frozen=True) class BrowserInfo: kind: str # "chrome" | "msedge" path: str def _registry_app_path(exe: str) -> str | None: if sys.platform != "win32": return None import winreg key_path = rf"SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\{exe}" for hive in (winreg.HKEY_CURRENT_USER, winreg.HKEY_LOCAL_MACHINE): try: with winreg.OpenKey(hive, key_path) as key: value, _ = winreg.QueryValueEx(key, None) if value and Path(value).is_file(): return str(value) except OSError: continue return None def _candidates(kind: str, env: dict[str, str]) -> list[Path]: roots = [env.get("PROGRAMFILES"), env.get("PROGRAMFILES(X86)"), env.get("LOCALAPPDATA")] tail = (Path("Google") / "Chrome" / "Application" / "chrome.exe" if kind == "chrome" else Path("Microsoft") / "Edge" / "Application" / "msedge.exe") return [Path(root) / tail for root in roots if root] def detect_browser(override: str | None = None, env: dict[str, str] | None = None, registry=_registry_app_path) -> BrowserInfo | None: """Chrome (preferido) ou Edge instalados. `override` = PUBLISHER_BROWSER_PATH.""" env = dict(os.environ) if env is None else env if override: path = Path(override) if path.is_file(): return BrowserInfo("msedge" if "edge" in path.name.lower() else "chrome", str(path)) return None for kind, exe in (("chrome", "chrome.exe"), ("msedge", "msedge.exe")): for candidate in _candidates(kind, env): if candidate.is_file(): return BrowserInfo(kind, str(candidate)) found = registry(exe) if found: return BrowserInfo(kind, found) if sys.platform != "win32": # conveniência fora do Windows (desenvolvimento) for kind, names in (("chrome", ["google-chrome", "chromium"]), ("msedge", ["microsoft-edge"])): for name in names: if found := shutil.which(name): return BrowserInfo(kind, found) return None def port_is_free(port: int) -> bool: with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as probe: try: probe.bind(("127.0.0.1", port)) return True except OSError: return False def launch_args(browser: BrowserInfo, user_data_dir: Path, port: int, url: str) -> list[str]: # Só o mínimo: perfil próprio, porta de depuração local e sem a tela de boas-vindas. Nenhuma flag que esconda # automação (nada de --disable-blink-features=AutomationControlled e afins). return [browser.path, f"--user-data-dir={user_data_dir}", f"--remote-debugging-port={port}", "--remote-debugging-address=127.0.0.1", "--no-first-run", "--no-default-browser-check", url] def cdp_version(port: int) -> dict | None: try: with urllib.request.urlopen(f"http://127.0.0.1:{port}/json/version", timeout=2) as response: data = json.loads(response.read()) return data if isinstance(data, dict) and data.get("Browser") else None except (OSError, ValueError): return None def cdp_alive(port: int) -> bool: return cdp_version(port) is not None def devtools_file(user_dir: Path) -> tuple[int, str] | None: """(porta, "/devtools/browser/") que o Chrome/Edge grava em `DevToolsActivePort` na pasta do perfil. Atenção: o Chrome recente (157+) NÃO grava esse arquivo quando a porta é fixa (`--remote-debugging-port=4540`); por isso existe também a marca própria (`WINDOW_MARK`).""" try: lines = (user_dir / "DevToolsActivePort").read_text(encoding="utf-8").splitlines() return int(lines[0].strip()), (lines[1].strip() if len(lines) > 1 else "") except (OSError, ValueError, IndexError): return None # Marca gravada pelo Publicador na pasta do perfil ao abrir a janela: {"pid": , "port": }. WINDOW_MARK = "CenaForgeWindow.json" BROWSER_EXES = {"chrome.exe", "msedge.exe", "chrome", "chromium", "google-chrome", "microsoft-edge", "msedge"} def window_mark(user_dir: Path) -> tuple[int, int] | None: """(pid, porta) da marca gravada ao abrir a janela.""" try: data = json.loads((user_dir / WINDOW_MARK).read_text(encoding="utf-8")) return int(data["pid"]), int(data["port"]) except (OSError, ValueError, KeyError, TypeError): return None def write_window_mark(user_dir: Path, pid: int, port: int) -> None: (user_dir / WINDOW_MARK).write_text(json.dumps({"pid": pid, "port": port}), encoding="utf-8") def listener_pid(port: int) -> int | None: """PID do processo que ESCUTA na porta TCP (127.0.0.1/IPv4). Windows: GetExtendedTcpTable (sem dependência).""" if sys.platform != "win32": return None import ctypes from ctypes import wintypes class TcpRowOwnerPid(ctypes.Structure): _fields_ = [("state", wintypes.DWORD), ("local_addr", wintypes.DWORD), ("local_port", wintypes.DWORD), ("remote_addr", wintypes.DWORD), ("remote_port", wintypes.DWORD), ("owning_pid", wintypes.DWORD)] af_inet, tcp_table_owner_pid_listener, error_insufficient_buffer = 2, 3, 122 get_table = ctypes.windll.iphlpapi.GetExtendedTcpTable size = wintypes.DWORD(0) for _ in range(3): # a tabela pode crescer entre a consulta do tamanho e a leitura buffer = ctypes.create_string_buffer(max(size.value, 4)) result = get_table(buffer, ctypes.byref(size), False, af_inet, tcp_table_owner_pid_listener, 0) if result == error_insufficient_buffer: continue if result != 0: return None count = ctypes.cast(buffer, ctypes.POINTER(wintypes.DWORD))[0] rows = (TcpRowOwnerPid * count).from_address(ctypes.addressof(buffer) + ctypes.sizeof(wintypes.DWORD)) for row in rows: if socket.ntohs(row.local_port & 0xFFFF) == port: return int(row.owning_pid) return None return None def process_exe_name(pid: int) -> str | None: """Nome do executável do processo (ex.: "chrome.exe"), ou None.""" if sys.platform != "win32": return None import ctypes from ctypes import wintypes kernel32 = ctypes.windll.kernel32 handle = kernel32.OpenProcess(0x1000, False, pid) # PROCESS_QUERY_LIMITED_INFORMATION if not handle: return None try: buffer = ctypes.create_unicode_buffer(1024) length = wintypes.DWORD(len(buffer)) if not kernel32.QueryFullProcessImageNameW(handle, 0, buffer, ctypes.byref(length)): return None return Path(buffer.value).name.lower() finally: kernel32.CloseHandle(handle) def active_port(user_dir: Path) -> int | None: info = devtools_file(user_dir) if info: return info[0] mark = window_mark(user_dir) return mark[1] if mark else None def owns_port(user_dir: Path, port: int, version: dict | None = None) -> bool: """A porta é do NOSSO navegador deste perfil? Outro programa ouvindo na mesma porta não passa. 1. Se o Chrome/Edge gravou `DevToolsActivePort` no perfil: o arquivo precisa apontar para a porta e o id do navegador (`/devtools/browser/`) precisa bater com o que a porta responde. 2. Senão (Chrome 157+ com porta fixa não grava o arquivo): a marca que o Publicador gravou ao abrir a janela precisa apontar para a porta, e quem escuta nela precisa ser exatamente aquele processo — e um Chrome/Edge (protege contra PID reaproveitado depois de reiniciar o Windows).""" version = version if version is not None else cdp_version(port) if not version: return False info = devtools_file(user_dir) if info: ws = str(version.get("webSocketDebuggerUrl") or "") return info[0] == port and bool(info[1]) and ws.endswith(info[1]) mark = window_mark(user_dir) if not mark or mark[1] != port: return False pid = listener_pid(port) return pid is not None and pid == mark[0] and process_exe_name(pid) in BROWSER_EXES @dataclass class _Window: process: subprocess.Popen | None # None = janela que já estava aberta (achada pelo DevToolsActivePort/marca) port: int user_dir: Path idle_limit_s: float = IDLE_CLOSE_S last_used: float = 0.0 def alive(self) -> bool: if self.process is not None: return self.process.poll() is None return cdp_alive(self.port) class BrowserManager: """Uma janela de navegador por perfil, aberta só enquanto precisa.""" def __init__(self, browser_dir: Path, browser: BrowserInfo | None, port_range: tuple[int, int] = BROWSER_PORT_RANGE, popen=subprocess.Popen, start_reaper: bool = True): self.browser_dir = browser_dir self.browser = browser self.port_range = port_range self._popen = popen self._windows: dict[str, _Window] = {} self._busy: set[str] = set() self._lock = threading.RLock() self._start_reaper = start_reaper self._reaper: threading.Thread | None = None def profile_dir(self, profile_id: str) -> Path: return self.browser_dir / profile_id def _free_port(self) -> int: used = {w.port for w in self._windows.values() if w.alive()} for port in range(self.port_range[0], self.port_range[1] + 1): if port not in used and port_is_free(port): return port raise PublishError("Todas as janelas de navegador do Publicador estão em uso (máximo 10). Feche alguma e " "tente de novo.") def is_open(self, profile_id: str) -> bool: with self._lock: window = self._windows.get(profile_id) return bool(window and window.alive()) @contextmanager def in_use(self, profile_id: str): """Marca a janela como ocupada: o fechamento por ociosidade não mexe nela enquanto isso.""" with self._lock: self._busy.add(profile_id) try: yield finally: with self._lock: self._busy.discard(profile_id) window = self._windows.get(profile_id) if window: window.last_used = time.time() def open(self, profile_id: str, url: str, for_login: bool = False) -> int: """Abre (ou reaproveita) a janela do perfil e devolve a porta CDP — sempre conferindo que a porta é nossa.""" if not self.browser: raise PublishError("Não encontrei o Google Chrome nem o Microsoft Edge neste computador. Instale o Chrome " "(recomendado) para usar a Sessão logada.") limit = LOGIN_IDLE_CLOSE_S if for_login else IDLE_CLOSE_S user_dir = self.profile_dir(profile_id) with self._lock: window = self._windows.get(profile_id) if window and window.alive(): if not owns_port(user_dir, window.port): self._windows.pop(profile_id, None) raise PublishError("A porta do navegador deste perfil não responde como o nosso navegador. Feche " "as janelas do navegador do CenaForge e tente de novo.") window.last_used, window.idle_limit_s = time.time(), max(window.idle_limit_s, limit) return window.port # Janela deste perfil que ficou aberta de uma execução anterior do Publicador: reaproveita, se for nossa. previous = active_port(user_dir) if previous and self.port_range[0] <= previous <= self.port_range[1] and owns_port(user_dir, previous): self._windows[profile_id] = _Window(None, previous, user_dir, limit, time.time()) self._ensure_reaper() return previous port = self._free_port() user_dir.mkdir(parents=True, exist_ok=True) for stale in ("DevToolsActivePort", WINDOW_MARK): # resto de execução anterior não pode confundir o dono try: (user_dir / stale).unlink() except OSError: pass flags = subprocess.CREATE_NEW_PROCESS_GROUP if sys.platform == "win32" else 0 process = self._popen(launch_args(self.browser, user_dir, port, url), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, creationflags=flags) write_window_mark(user_dir, process.pid, port) self._windows[profile_id] = _Window(process, port, user_dir, limit, time.time()) self._wait_cdp(port, user_dir, process) self._ensure_reaper() return port def _wait_cdp(self, port: int, user_dir: Path, process: subprocess.Popen | None = None, timeout_s: float = 20) -> None: deadline = time.time() + timeout_s while time.time() < deadline: if owns_port(user_dir, port): return if process is not None and process.poll() is not None: # O processo saiu logo: o Chrome entregou a URL para uma janela que já estava aberta com este perfil # (e essa janela não tem a nossa porta de depuração). raise PublishError("Já existe uma janela do navegador aberta com este perfil. Feche essa janela (a " "conta continua logada) e tente de novo.") time.sleep(0.5) raise PublishError("O navegador abriu mas não respondeu. Feche todas as janelas dele e tente de novo. (Se o " "Chrome já estava aberto com este mesmo perfil, ele precisa ser fechado antes.)") # ---------- fechamento def _ensure_reaper(self) -> None: if not self._start_reaper or (self._reaper and self._reaper.is_alive()): return self._reaper = threading.Thread(target=self._reap_loop, name="publisher-browser-idle", daemon=True) self._reaper.start() def _reap_loop(self) -> None: while True: time.sleep(30) try: self.close_idle() except Exception: # noqa: BLE001 - o vigia não pode morrer pass with self._lock: if not self._windows: self._reaper = None return def close_idle(self, now: float | None = None) -> list[str]: """Fecha as janelas paradas há mais que o limite (ou já fechadas pelo usuário). Devolve os perfis.""" now = now or time.time() with self._lock: idle = [pid for pid, w in self._windows.items() if pid not in self._busy and (not w.alive() or now - w.last_used >= w.idle_limit_s)] for profile_id in idle: self.close(profile_id) return idle def close(self, profile_id: str, graceful: bool = True) -> None: """Fecha a janela. `graceful`: pede ao navegador para fechar (CDP Browser.close), que grava os cookies — a sessão logada não se perde. Só mata o processo se ele não fechar sozinho. NÃO chamar dentro de um bloco `sync_playwright()` aberto na mesma thread.""" with self._lock: window = self._windows.pop(profile_id, None) if not window or not window.alive(): return if graceful and owns_port(window.user_dir, window.port): try: from playwright.sync_api import sync_playwright with sync_playwright() as pw: browser = pw.chromium.connect_over_cdp(f"http://127.0.0.1:{window.port}", timeout=5000, is_local=True) browser.new_browser_cdp_session().send("Browser.close") except Exception: # noqa: BLE001 - "melhor esforço"; abaixo o processo é encerrado à força pass if window.process is None: return try: window.process.wait(timeout=10 if graceful else 0.1) return except subprocess.TimeoutExpired: pass if sys.platform == "win32": subprocess.run(["taskkill", "/pid", str(window.process.pid), "/T", "/F"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) else: window.process.terminate() try: window.process.wait(timeout=10) except subprocess.TimeoutExpired: pass def remove_profile(self, profile_id: str) -> None: """Fecha a janela e apaga o diretório do perfil (cookies = a sessão logada).""" target = self.profile_dir(profile_id).resolve() root = self.browser_dir.resolve() if target.parent != root: # só apaga pasta filha direta de data/publisher/browser raise PublishError("Caminho do perfil de navegador inválido.") self.close(profile_id, graceful=False) for _ in range(5): # o Chrome demora um instante para soltar os arquivos if not target.exists(): return shutil.rmtree(target, ignore_errors=True) time.sleep(0.5) def close_all(self) -> None: for profile_id in list(self._windows): self.close(profile_id)