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
+150
View File
@@ -0,0 +1,150 @@
"""Cofre de segredos do Publicador (tokens de acesso, refresh tokens, client secrets).
Tudo fica num arquivo só (data/publisher/vault.bin): um JSON cifrado com a DPAPI do Windows
(`CryptProtectData`, escopo do USUÁRIO). Só a mesma conta do Windows, nesta máquina, consegue abrir. Copiar o
arquivo para outro PC ou outro usuário não adianta: lá ele não decifra.
Nos testes, um cifrador falso é injetado (`Vault(path, cipher=...)`); a DPAPI real só existe no Windows.
"""
from __future__ import annotations
import json
import os
import sys
import threading
from pathlib import Path
from typing import Any, Protocol
class VaultError(RuntimeError):
"""O cofre não abriu (arquivo de outro usuário/máquina, corrompido, ou DPAPI indisponível)."""
class Cipher(Protocol):
def protect(self, data: bytes) -> bytes: ...
def unprotect(self, data: bytes) -> bytes: ...
# Entropia extra: um segredo fixo do app que entra na cifra junto com a chave do usuário. Não é senha; só impede
# que outro programa do mesmo usuário abra o arquivo chamando CryptUnprotectData "às cegas".
_ENTROPY = b"CenaForge.Publisher.vault.v1"
class DpapiCipher:
"""DPAPI via ctypes (crypt32.dll). Sem dependência externa."""
CRYPTPROTECT_UI_FORBIDDEN = 0x01
def __init__(self) -> None:
if sys.platform != "win32":
raise VaultError("O cofre do Publicador usa a DPAPI do Windows; este sistema não tem.")
import ctypes
from ctypes import wintypes
class DataBlob(ctypes.Structure):
_fields_ = [("cbData", wintypes.DWORD), ("pbData", ctypes.POINTER(ctypes.c_char))]
self._ctypes = ctypes
self._blob = DataBlob
self._crypt32 = ctypes.WinDLL("crypt32", use_last_error=True)
self._kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
self._kernel32.LocalFree.argtypes = [ctypes.c_void_p]
self._kernel32.LocalFree.restype = ctypes.c_void_p
for fn in (self._crypt32.CryptProtectData, self._crypt32.CryptUnprotectData):
fn.argtypes = [ctypes.POINTER(DataBlob), ctypes.c_void_p, ctypes.POINTER(DataBlob), ctypes.c_void_p,
ctypes.c_void_p, wintypes.DWORD, ctypes.POINTER(DataBlob)]
fn.restype = wintypes.BOOL
def _to_blob(self, data: bytes):
buffer = self._ctypes.create_string_buffer(data, len(data))
blob = self._blob(len(data), self._ctypes.cast(buffer, self._ctypes.POINTER(self._ctypes.c_char)))
return blob, buffer # o buffer precisa continuar vivo enquanto o blob for usado
def _call(self, fn, data: bytes, what: str) -> bytes:
ctypes = self._ctypes
in_blob, _keep_in = self._to_blob(data)
entropy, _keep_entropy = self._to_blob(_ENTROPY)
out_blob = self._blob()
ok = fn(ctypes.byref(in_blob), None, ctypes.byref(entropy), None, None, self.CRYPTPROTECT_UI_FORBIDDEN,
ctypes.byref(out_blob))
if not ok:
code = ctypes.get_last_error()
raise VaultError(f"A DPAPI do Windows não conseguiu {what} o cofre (erro {code}). O arquivo pode ser de "
"outro usuário ou de outro computador.")
try:
return ctypes.string_at(out_blob.pbData, out_blob.cbData)
finally:
self._kernel32.LocalFree(out_blob.pbData)
def protect(self, data: bytes) -> bytes:
return self._call(self._crypt32.CryptProtectData, data, "cifrar")
def unprotect(self, data: bytes) -> bytes:
return self._call(self._crypt32.CryptUnprotectData, data, "abrir")
class Vault:
"""Dicionário de segredos persistido cifrado. Chaves usadas: `app:<platform>` e `token:<profileId>`."""
def __init__(self, path: Path, cipher: Cipher | None = None):
self.path = path
self._cipher = cipher
self._lock = threading.RLock()
@property
def cipher(self) -> Cipher:
if self._cipher is None:
self._cipher = DpapiCipher()
return self._cipher
def _read(self) -> dict[str, Any]:
if not self.path.is_file():
return {}
raw = self.path.read_bytes()
if not raw:
return {}
try:
return json.loads(self.cipher.unprotect(raw).decode("utf-8"))
except VaultError:
raise
except Exception as exc: # JSON quebrado ou cifra inválida
raise VaultError("O cofre do Publicador está corrompido ou não pertence a este usuário do Windows.") from exc
def _write(self, data: dict[str, Any]) -> None:
self.path.parent.mkdir(parents=True, exist_ok=True)
blob = self.cipher.protect(json.dumps(data, ensure_ascii=False).encode("utf-8"))
tmp = self.path.with_suffix(".tmp")
tmp.write_bytes(blob)
os.replace(tmp, self.path) # troca atômica: nunca fica meio arquivo se o processo cair
def get(self, key: str) -> Any:
with self._lock:
return self._read().get(key)
def set(self, key: str, value: Any) -> None:
with self._lock:
data = self._read()
data[key] = value
self._write(data)
def update(self, key: str, **fields: Any) -> dict:
"""Mescla campos no segredo `key` (ex.: gravar o refresh token novo do TikTok sem perder o resto)."""
with self._lock:
data = self._read()
current = dict(data.get(key) or {})
current.update(fields)
data[key] = current
self._write(data)
return current
def delete(self, key: str) -> None:
with self._lock:
data = self._read()
if key in data:
del data[key]
self._write(data)
def keys(self) -> list[str]:
with self._lock:
return list(self._read().keys())