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
+237
View File
@@ -0,0 +1,237 @@
"""TikTok pela API oficial (Login Kit desktop + Content Posting API).
OAuth: PKCE S256 com o desafio em HEXADECIMAL (particularidade do TikTok), redirect
http://127.0.0.1:4530/oauth/callback/tiktok. Access token vale 2 h; o refresh token vale 180 dias e é ROTATIVO:
toda renovação devolve um novo e o antigo morre — por isso o serviço grava o novo sempre (ver service.py).
Envio por FILE_UPLOAD (PULL_FROM_URL exige domínio verificado). Dois modos:
- `direct`: Direct Post (`video.publish`) — antes consulta `creator_info`. Sem auditoria do app só sai SELF_ONLY.
- `draft`: vai para a caixa de entrada do app do TikTok (`video.upload`); o usuário termina de publicar no celular.
"""
from __future__ import annotations
import time
from typing import Callable
from urllib.parse import urlencode
import httpx
from .base import (JobSpec, Progress, PublishError, PublishResult, Sleep, Tokens, challenge_s256_hex, expires_in,
file_size, network_error, response_json)
AUTH_URL = "https://www.tiktok.com/v2/auth/authorize/"
API = "https://open.tiktokapis.com"
TOKEN_URL = f"{API}/v2/oauth/token/"
SCOPES = "user.info.basic,video.upload,video.publish"
MB = 1024 * 1024
PRIVACY = {"public": "PUBLIC_TO_EVERYONE", "private": "SELF_ONLY",
# "Não listado" não existe no TikTok: o mais próximo sem expor o vídeo é "Somente eu".
"unlisted": "SELF_ONLY"}
UNAUDITED = ("O TikTok só permite publicar como privado (Somente eu) até o app ser auditado. "
"Use o modo Rascunho ou a Sessão logada.")
TokenProvider = Callable[[bool], str]
def chunk_plan(size: int, single_max: int = 64 * MB, chunk: int = 32 * MB) -> tuple[int, int]:
"""(chunk_size, total_chunk_count) pelas regras do TikTok: até 64 MB vai inteiro; acima, blocos de 5–64 MB em
que o último absorve o resto (pode passar do tamanho do bloco, até 128 MB)."""
if size <= single_max:
return size, 1
return chunk, max(1, size // chunk)
def explain(code: str, message: str = "") -> PublishError:
if code == "unaudited_client_can_only_post_to_private_accounts":
return PublishError(UNAUDITED + " (A conta do TikTok também precisa estar como privada.)")
if code == "privacy_level_option_mismatch":
return PublishError("A privacidade escolhida não está disponível para esta conta do TikTok. "
"Escolha outra no canal de publicação.")
if code in ("spam_risk_too_many_posts", "spam_risk_too_many_pending_share", "spam_risk_user_banned_from_posting"):
return PublishError("O TikTok bloqueou novos envios por enquanto (limite diário atingido — no modo Rascunho são "
"até 5 pendentes por dia). Publique os rascunhos no app ou tente de novo amanhã.")
if code == "reached_active_user_cap":
return PublishError("O app do TikTok ainda sem auditoria aceita só 5 contas por dia. Tente amanhã.")
if code in ("access_token_invalid", "token_not_authorized_for_specified_url"):
return PublishError("A autorização do TikTok venceu. Conecte o TikTok de novo em Canais de publicação.", "expired")
if code == "scope_not_authorized":
return PublishError("Falta permissão no TikTok. Conecte de novo e aceite todas as permissões pedidas.", "expired")
if code == "rate_limit_exceeded":
return PublishError("O TikTok pediu para ir mais devagar (muitas chamadas por minuto). Tente de novo daqui a pouco.")
return PublishError(f"O TikTok recusou o envio ({code or 'erro desconhecido'}). {message}".strip())
def _check(response: httpx.Response) -> dict:
body = response_json(response)
error = body.get("error") or {}
code = str(error.get("code") or "") if isinstance(error, dict) else str(error)
if response.status_code >= 400 or (code and code != "ok"):
raise explain(code or str(response.status_code), str(error.get("message") or "") if isinstance(error, dict) else "")
return body.get("data") or {}
class TikTokApi:
# Limites dos blocos (sobrescritos nos testes para não precisar de arquivo de 64 MB).
single_max = 64 * MB
chunk = 32 * MB
poll_s = 5.0
poll_max = 180 # ~15 min
def __init__(self, client: httpx.Client, client_key: str, client_secret: str, redirect_uri: str,
sleep: Sleep = time.sleep):
self.client, self.client_key, self.client_secret = client, client_key, client_secret
self.redirect_uri, self.sleep = redirect_uri, sleep
# ---------- OAuth
def authorize_url(self, state: str, verifier: str) -> str:
params = {"client_key": self.client_key, "scope": SCOPES, "response_type": "code",
"redirect_uri": self.redirect_uri, "state": state,
"code_challenge": challenge_s256_hex(verifier), "code_challenge_method": "S256"}
return f"{AUTH_URL}?{urlencode(params)}"
def _token_request(self, data: dict) -> Tokens:
try:
response = self.client.post(TOKEN_URL, data={**data, "client_key": self.client_key,
"client_secret": self.client_secret},
headers={"Content-Type": "application/x-www-form-urlencoded"})
except httpx.HTTPError as exc:
raise network_error("TikTok", exc) from exc
body = response_json(response)
if response.status_code >= 400 or body.get("error") or not body.get("access_token"):
error = str(body.get("error") or response.status_code)
if error in ("invalid_grant", "invalid_request") and data.get("grant_type") == "refresh_token":
raise PublishError("A autorização do TikTok expirou. Conecte o TikTok de novo em Canais de publicação.",
"expired")
if error in ("invalid_client", "unauthorized_client"):
raise PublishError("O TikTok recusou o Client Key/Secret do app. Confira em Configurações → Apps das redes.")
raise PublishError(f"O TikTok recusou a autorização ({error}). Tente conectar de novo.")
return Tokens(body["access_token"], expires_in(body.get("expires_in")), body.get("refresh_token"),
expires_in(body.get("refresh_expires_in")), {"openId": body.get("open_id")})
def exchange_code(self, code: str, verifier: str) -> Tokens:
return self._token_request({"code": code, "grant_type": "authorization_code",
"redirect_uri": self.redirect_uri, "code_verifier": verifier})
def refresh(self, refresh_token: str) -> Tokens:
# Rotativo: o refresh devolvido substitui o antigo (quem chama grava o novo no cofre na hora).
return self._token_request({"grant_type": "refresh_token", "refresh_token": refresh_token})
def _post(self, path: str, access_token: str, json: dict | None = None) -> dict:
try:
response = self.client.post(f"{API}{path}", json=json or {}, headers={
"Authorization": f"Bearer {access_token}", "Content-Type": "application/json; charset=UTF-8"})
except httpx.HTTPError as exc:
raise network_error("TikTok", exc) from exc
return _check(response)
def user_info(self, access_token: str) -> tuple[str | None, str | None]:
"""(nome de exibição, @usuário). O usuário vem do creator_info (o user.info.basic não traz)."""
name = handle = None
try:
response = self.client.get(f"{API}/v2/user/info/", params={"fields": "open_id,display_name"},
headers={"Authorization": f"Bearer {access_token}"})
name = ((response_json(response).get("data") or {}).get("user") or {}).get("display_name")
except httpx.HTTPError:
pass
try:
info = self.creator_info(access_token)
name = name or info.get("creator_nickname")
handle = info.get("creator_username")
except PublishError:
pass
return name, (f"@{handle}" if handle and not str(handle).startswith("@") else handle)
def creator_info(self, access_token: str) -> dict:
return self._post("/v2/post/publish/creator_info/query/", access_token)
# ---------- envio
def post_info(self, spec: JobSpec, creator: dict) -> dict:
privacy = PRIVACY.get(spec.privacy, "SELF_ONLY")
options = list(creator.get("privacy_level_options") or [])
if options and privacy not in options:
if options == ["SELF_ONLY"]:
raise PublishError(UNAUDITED)
raise PublishError(f"A privacidade \"{spec.privacy}\" não está disponível nesta conta do TikTok "
f"(a conta oferece: {', '.join(options)}). Mude a privacidade no canal de publicação.")
return {
"title": spec.caption[:2200], "privacy_level": privacy,
# Diretriz do TikTok: interações começam DESMARCADAS (o criador escolhe permitir). Sem campo para isso no
# contrato do job, ficam desligadas — e desligadas também se o criador já desligou na conta.
"disable_comment": True, "disable_duet": True, "disable_stitch": True,
"brand_content_toggle": False, "brand_organic_toggle": False,
"is_aigc": bool(spec.ai_generated),
}
def upload(self, spec: JobSpec, token: TokenProvider, progress: Progress) -> PublishResult:
total = file_size(spec.file)
chunk_size, count = chunk_plan(total, self.single_max, self.chunk)
source = {"source": "FILE_UPLOAD", "video_size": total, "chunk_size": chunk_size, "total_chunk_count": count}
access = token(False)
draft = spec.tiktok_mode == "draft"
username = None
if draft:
progress("Abrindo o envio para a caixa de entrada do TikTok…", 0.02)
data = self._post("/v2/post/publish/inbox/video/init/", access, {"source_info": source})
else:
progress("Consultando a conta do TikTok…", 0.01)
creator = self.creator_info(access)
username = creator.get("creator_username")
body = {"post_info": self.post_info(spec, creator), "source_info": source}
progress("Abrindo a publicação no TikTok…", 0.03)
data = self._post("/v2/post/publish/video/init/", access, body)
publish_id, upload_url = data.get("publish_id"), data.get("upload_url")
if not publish_id or not upload_url:
raise PublishError("O TikTok não devolveu o endereço de envio. Tente de novo daqui a pouco.")
self._put_chunks(spec, upload_url, total, chunk_size, count, progress)
return self._wait(publish_id, token, progress, draft, username, spec.privacy)
def _put_chunks(self, spec: JobSpec, upload_url: str, total: int, chunk_size: int, count: int,
progress: Progress) -> None:
with spec.file.open("rb") as handle:
for index in range(count):
start = index * chunk_size
# O último bloco leva o resto do arquivo.
length = total - start if index == count - 1 else chunk_size
handle.seek(start)
data = handle.read(length)
end = start + len(data) - 1
try:
response = self.client.put(upload_url, content=data, headers={
"Content-Type": "video/mp4", "Content-Length": str(len(data)),
"Content-Range": f"bytes {start}-{end}/{total}"})
except httpx.HTTPError as exc:
raise network_error("TikTok", exc) from exc
if response.status_code not in (200, 201, 206):
raise PublishError(f"O TikTok recusou um pedaço do vídeo (código {response.status_code}). "
"Tente de novo; se repetir, confira se o vídeo tem até 10 min e 4 GB.")
progress(f"Enviando vídeo… {int((end + 1) * 100 / total)}%", 0.05 + 0.8 * (end + 1) / total)
def _wait(self, publish_id: str, token: TokenProvider, progress: Progress, draft: bool,
username: str | None, privacy: str) -> PublishResult:
progress("Aguardando o TikTok processar…", 0.88)
for _ in range(self.poll_max):
data = self._post("/v2/post/publish/status/fetch/", token(False), {"publish_id": publish_id})
status = data.get("status")
if status == "FAILED":
reason = str(data.get("fail_reason") or "")
raise explain(reason, "O TikTok não conseguiu processar o vídeo.")
if draft and status == "SEND_TO_USER_INBOX":
return PublishResult(publish_id, None, True,
"Enviado para a caixa de entrada do TikTok: abra o app para revisar e publicar")
if status == "PUBLISH_COMPLETE":
# (sic) o campo da API é "publicaly_available_post_id".
posts = data.get("publicaly_available_post_id") or []
if posts and username:
post = str(posts[0])
return PublishResult(post, f"https://www.tiktok.com/@{username}/video/{post}", False, "Publicado no TikTok")
if PRIVACY.get(privacy) == "SELF_ONLY":
return PublishResult(publish_id, None, False, "Publicado no TikTok como privado (Somente eu)")
return PublishResult(str(posts[0]) if posts else publish_id, None, False,
"Publicado no TikTok; o link ainda não apareceu (confira no app)")
self.sleep(self.poll_s)
raise PublishError("O TikTok demorou demais para processar o vídeo. Confira no app antes de tentar de novo "
"(pode ter publicado).")