CenaForge: primeira versão pública
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>
This commit is contained in:
@@ -0,0 +1,425 @@
|
||||
"""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)
|
||||
Reference in New Issue
Block a user