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
+177
View File
@@ -0,0 +1,177 @@
"""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.