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
+125
View File
@@ -0,0 +1,125 @@
"""Tipos comuns aos envios (API oficial e sessão logada)."""
from __future__ import annotations
import base64
import hashlib
import os
import secrets
import time
from dataclasses import dataclass, field
from pathlib import Path
from typing import Callable, Literal
import httpx
# Callback de progresso: (texto curto em pt-BR para a UI, fração 0..1).
Progress = Callable[[str, float], None]
Sleep = Callable[[float], None]
PLATFORMS = ("youtube", "tiktok", "instagram")
class PublishError(Exception):
"""Falha que o usuário precisa ler. `kind`: 'failed' (erro comum), 'needs_login' (entrar de novo) ou
'expired' (a autorização da API venceu: conectar de novo). A mensagem já sai em pt-BR, sem jargão."""
def __init__(self, message: str, kind: Literal["failed", "needs_login", "expired"] = "failed"):
super().__init__(message)
self.message = message
self.kind = kind
@dataclass
class JobSpec:
"""O que o worker entrega ao uploader (vem do JobInput do contrato)."""
job_id: str
profile_id: str
platform: str
file: Path
cover: Path | None
title: str
caption: str
tags: list[str] = field(default_factory=list)
privacy: str = "public"
publish_at: str | None = None
ai_generated: bool = False
made_for_kids: bool = False
tiktok_mode: str = "direct"
@dataclass
class PublishResult:
remote_id: str | None
url: str | None
draft: bool = False
# Texto final para a UI ("Publicado", "Enviado para a caixa de entrada do TikTok"…).
step: str = "Publicado"
@dataclass
class Tokens:
access_token: str
access_expires_at: float | None # epoch (s)
refresh_token: str | None = None
refresh_expires_at: float | None = None # epoch (s); None = sem prazo conhecido
extra: dict = field(default_factory=dict)
def to_vault(self) -> dict:
return {"accessToken": self.access_token, "accessExpiresAt": self.access_expires_at,
"refreshToken": self.refresh_token, "refreshExpiresAt": self.refresh_expires_at, **self.extra}
# ---------- PKCE (RFC 7636)
def make_verifier() -> str:
# 64 caracteres do alfabeto "unreserved" (A-Z a-z 0-9 - _): dentro dos 43–128 exigidos.
return secrets.token_urlsafe(48)[:64]
def challenge_s256_base64url(verifier: str) -> str:
"""Desafio padrão do RFC (Google): base64url sem `=` do SHA-256."""
digest = hashlib.sha256(verifier.encode("ascii")).digest()
return base64.urlsafe_b64encode(digest).rstrip(b"=").decode("ascii")
def challenge_s256_hex(verifier: str) -> str:
"""Desafio do TikTok (Login Kit desktop): o SHA-256 em HEXADECIMAL, não base64url. Diferente do RFC de propósito
— é assim que a documentação do TikTok pede, e o desafio em base64url é recusado."""
return hashlib.sha256(verifier.encode("ascii")).hexdigest()
# ---------- utilidades
def iter_chunks(path: Path, sizes: list[int]):
"""Lê o arquivo em blocos de tamanhos dados (o último pode ser maior)."""
with path.open("rb") as handle:
offset = 0
for size in sizes:
data = handle.read(size)
yield offset, data
offset += len(data)
def file_size(path: Path) -> int:
return os.path.getsize(path)
def expires_in(seconds: object) -> float | None:
try:
return time.time() + float(seconds) # type: ignore[arg-type]
except (TypeError, ValueError):
return None
def response_json(response: httpx.Response) -> dict:
try:
data = response.json()
except ValueError:
return {}
return data if isinstance(data, dict) else {}
def network_error(name: str, exc: Exception) -> PublishError:
return PublishError(f"Não consegui falar com o {name} (internet caiu ou o site está fora do ar). "
f"Tente de novo daqui a pouco. Detalhe: {type(exc).__name__}")