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:
2026-11-17 16:35:09 -03:00
co-authored by Claude Opus 5.5
commit 84f30bbc2d
484 changed files with 74826 additions and 0 deletions
+425
View File
@@ -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)