Files
MateuusandClaude Opus 5.5 84f30bbc2d 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>
2026-11-17 16:35:09 -03:00

184 lines
8.5 KiB
TypeScript

// Lançador local da prova de conceito. Não é backend nem painel: só unifica os
// comandos de Godot e FFmpeg. Uso: pnpm <comando> -- [opções]
import fs from "node:fs";
import path from "node:path";
import { parseArgs, stringOption, numberOption, UsageError, type ParsedArgs } from "./lib/args.ts";
import { GODOT_OVERRIDE_FILE, GODOT_PROJECT_DIR, LOCK_FILE, OUTPUT_DIR, displayPath, displayToolPath, resolveFromRoot } from "./lib/paths.ts";
import { runProcess, succeeded, describeFailure } from "./lib/process.ts";
import { ffmpegEncoders, findTool, toolVersion, chooseVideoEncoder, MissingToolError, type ToolName, type Tool } from "./lib/tools.ts";
import { render, PROFILES, type ProfileName } from "./lib/render.ts";
import { evaluateProbe, probeVideo, type Expectation } from "./lib/verify.ts";
const DEFAULT_CONFIG = "config/demo-street.json";
const HELP = `CenaForge — prova de conceito de vídeo com Godot
Comandos:
pnpm run doctor checa executáveis, versões e diretórios
(no pnpm 11, "pnpm doctor" é o diagnóstico do próprio pnpm)
pnpm preview [-- --config <json>] abre a cena na Godot (tempo real)
pnpm render -- --config <json> --profile preview|final [--keep-frames] [--debug-frame-index] [--warmup-frames N]
pnpm verify -- --file <arquivo.mp4> [--width N --height N --fps N --duration S --frames N]
pnpm prepare-assets gera as fachadas distantes (headless)
pnpm test testes do lançador e da lógica da cena
Caminhos relativos partem da raiz do projeto.`;
async function main(argv: string[]): Promise<number> {
const [command, ...rest] = argv.filter((a, i) => !(i === 0 && a === "--"));
const args = parseArgs(rest);
switch (command) {
case "doctor":
return doctor();
case "preview":
return preview(args);
case "render":
return renderCommand(args);
case "verify":
return verifyCommand(args);
case "prepare-assets":
return godotHeadlessScript("res://tools/generate_backgrounds.gd");
case "test-godot":
return godotHeadlessScript("res://tests/run_tests.gd");
case undefined:
case "help":
case "--help":
console.log(HELP);
return 0;
default:
console.error(`Comando desconhecido: ${command}\n\n${HELP}`);
return 64;
}
}
async function doctor(): Promise<number> {
let problems = 0;
console.log(`Node ${process.version} em ${process.platform}/${process.arch}`);
const tools: Partial<Record<ToolName, Tool>> = {};
for (const name of ["godot", "ffmpeg", "ffprobe"] as const) {
try {
const tool = findTool(name);
tools[name] = tool;
console.log(`ok ${name.padEnd(8)} ${await toolVersion(tool)} [${tool.source}: ${displayToolPath(tool.path)}]`);
} catch (error) {
problems++;
console.log(`FALTA ${name.padEnd(8)} ${(error as Error).message}`);
}
}
if (tools.ffmpeg) {
const enc = await ffmpegEncoders(tools.ffmpeg);
try {
console.log(`ok encoder ${chooseVideoEncoder(enc).name} (libx264=${enc.libx264} h264_nvenc=${enc.h264_nvenc} libopenh264=${enc.libopenh264} aac=${enc.aac})`);
} catch (error) {
problems++;
console.log(`FALTA encoder ${(error as Error).message}`);
}
}
try {
fs.mkdirSync(OUTPUT_DIR, { recursive: true });
fs.accessSync(OUTPUT_DIR, fs.constants.W_OK);
const stat = fs.statfsSync(OUTPUT_DIR);
const freeGB = (stat.bavail * stat.bsize) / 2 ** 30;
console.log(`${freeGB < 2 ? "AVISO" : "ok "} saída ${displayPath(OUTPUT_DIR)} gravável, ${freeGB.toFixed(1)} GB livres (prévia usa ~0,3 GB de PNG temporário; final ~1,5 GB)`);
} catch (error) {
problems++;
console.log(`FALTA saída ${(error as Error).message}`);
}
const graphical = process.platform === "win32" || process.platform === "darwin" || !!process.env.DISPLAY || !!process.env.WAYLAND_DISPLAY;
console.log(`${graphical ? "ok " : "AVISO"} gráfico ${graphical ? "sessão gráfica presumida (o render abre uma janela)" : "sem DISPLAY/WAYLAND_DISPLAY: o render 3D precisa de backend gráfico"}`);
console.log("info GPU o adaptador real é registrado no report.json de cada render");
if (fs.existsSync(GODOT_OVERRIDE_FILE)) console.log(`AVISO override ${displayPath(GODOT_OVERRIDE_FILE)} existe (sobra de render interrompido?)`);
if (fs.existsSync(LOCK_FILE)) console.log(`AVISO trava ${displayPath(LOCK_FILE)} existe`);
console.log(problems === 0 ? "\nAmbiente pronto." : `\n${problems} problema(s) encontrado(s).`);
return problems === 0 ? 0 : 1;
}
async function preview(args: ParsedArgs): Promise<number> {
const config = resolveFromRoot(stringOption(args, "config") ?? DEFAULT_CONFIG);
const godot = findTool("godot");
if (fs.existsSync(GODOT_OVERRIDE_FILE) && !fs.existsSync(LOCK_FILE)) {
// Sobra de render interrompido: alteraria o tamanho da janela da prévia.
fs.rmSync(GODOT_OVERRIDE_FILE);
console.warn("Removido override.cfg deixado por um render interrompido.");
}
console.log(`Prévia de ${displayPath(config)} — Espaço pausa, R reinicia, ←/→ quadro a quadro, L repete, Esc sai.`);
const r = await runProcess(godot.path, ["--path", GODOT_PROJECT_DIR, "--", "--config", config], { inheritStdio: true });
if (!succeeded(r)) {
console.error(describeFailure("godot", r));
return r.exitCode ?? 1;
}
return 0;
}
async function renderCommand(args: ParsedArgs): Promise<number> {
const profile = (stringOption(args, "profile") ?? "preview") as ProfileName;
if (!(profile in PROFILES)) throw new UsageError(`--profile precisa ser ${Object.keys(PROFILES).join(" ou ")}`);
const warmup = numberOption(args, "warmup-frames") ?? 3;
if (!Number.isInteger(warmup) || warmup < 0 || warmup > 30) throw new UsageError("--warmup-frames precisa ser inteiro entre 0 e 30");
return render({
configPath: stringOption(args, "config") ?? DEFAULT_CONFIG,
profile,
keepFrames: args.options.has("keep-frames"),
debugFrameIndex: args.options.has("debug-frame-index"),
warmupFrames: warmup,
});
}
async function verifyCommand(args: ParsedArgs): Promise<number> {
const fileArg = stringOption(args, "file");
if (!fileArg) throw new UsageError("informe --file <arquivo.mp4>");
const file = resolveFromRoot(fileArg);
if (!fs.existsSync(file)) {
console.error(`Arquivo não encontrado: ${fileArg}`);
return 1;
}
// Expectativas: opções explícitas > scene.json da mesma pasta de execução.
const expectation: Expectation = {};
const sceneFile = path.join(path.dirname(file), "scene.json");
if (fs.existsSync(sceneFile)) {
const scene = JSON.parse(fs.readFileSync(sceneFile, "utf8"));
expectation.width = scene.video?.width;
expectation.height = scene.video?.height;
expectation.fps = scene.video?.fps;
expectation.durationSeconds = scene.video?.durationSeconds;
if (expectation.fps && expectation.durationSeconds) expectation.frames = Math.round(expectation.fps * expectation.durationSeconds);
expectation.audio = scene.audio?.enabled === true;
console.log(`Expectativas lidas de ${displayPath(sceneFile)}`);
}
expectation.width = numberOption(args, "width") ?? expectation.width;
expectation.height = numberOption(args, "height") ?? expectation.height;
expectation.fps = numberOption(args, "fps") ?? expectation.fps;
expectation.durationSeconds = numberOption(args, "duration") ?? expectation.durationSeconds;
expectation.frames = numberOption(args, "frames") ?? expectation.frames;
const probe = await probeVideo(findTool("ffprobe"), file);
const checks = evaluateProbe(probe, expectation);
console.log(`\n${displayPath(file)}`);
for (const c of checks) console.log(` ${c.ok ? "ok " : "FALHA"} ${c.name} — ${c.detail}`);
const ok = checks.every((c) => c.ok);
console.log(ok ? "\nVídeo verificado." : "\nVerificação falhou.");
return ok ? 0 : 1;
}
async function godotHeadlessScript(script: string): Promise<number> {
const godot = findTool("godot");
const r = await runProcess(godot.path, ["--headless", "--path", GODOT_PROJECT_DIR, "--script", script], { inheritStdio: true });
if (!succeeded(r)) console.error(describeFailure(`godot ${script}`, r));
return succeeded(r) ? 0 : r.exitCode ?? 1;
}
main(process.argv.slice(2)).then(
(code) => {
process.exitCode = code;
},
(error: unknown) => {
if (error instanceof UsageError || error instanceof MissingToolError) {
console.error(`Erro: ${error.message}`);
process.exitCode = 64;
} else {
console.error(error);
process.exitCode = 1;
}
},
);