Gerador de vídeos narrativos (Godot + FFmpeg), painel Next.js, serviço de voz, Clipador de lives e Publicador para YouTube, TikTok e Instagram. Inclui a leitura das visualizações dos posts para o Dashboard e o botão "Publicar no <rede>" nos cartões das publicações. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
426 lines
19 KiB
Python
426 lines
19 KiB
Python
"""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/<profileId>`). 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/<id>") 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": <processo do navegador>, "port": <CDP>}.
|
||
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/<id>`) 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)
|