Painel: ordenar fila de cortes, horário específico ao publicar e capas preservadas

Clipador (fila de cortes)
- Seletor "Ordenar": mais novos, mais antigos, maior/menor nota da IA, sinal
  mais forte e mais longos; a escolha fica lembrada no navegador.
- A fila abre filtrada pela sessão que está gravando.
- Gancho automático logo abaixo da câmera e legenda desviada enquanto o gancho
  a cobriria; posição do gancho editável no painel.

Publicação
- "Publicar este corte" ganha "Horário específico": um dia e hora para todas
  as redes ou um diferente por rede (timing "at" + scheduledAt por rede na rota
  POST /api/publishing/clips/[id]), com validação e testes.
- Capa do vídeo publicado copiada para output/publishing/covers/: apagar a
  sessão no Clipador não quebra mais a miniatura do dashboard; jobs antigos
  migram no ciclo de sincronização.
- Dashboard só usa capa que existe no disco; corrige a regex do número do
  episódio (link do episódio).
- Canais de publicação: seletor compacto de canais e detalhe reorganizado.
- Publicador: confirmação pela página pública quando o YouTube Studio fica com
  a caixa de envio aberta; estatísticas por rede.

Skill cenaforge 1.44.0 com as regras e a armadilha das capas.

Testes: painel 68/68, Clipador 279, Publicador 84.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-17 19:54:13 -03:00
co-authored by Claude Opus 5.5
parent 84f30bbc2d
commit f165659e4e
30 changed files with 1174 additions and 370 deletions
+6 -2
View File
@@ -110,10 +110,14 @@ async function collect({ accountId, force = false }: { accountId?: string; force
saveSync(account, platform, startedAt, null, stats.items.length, stats.missing.length);
result.groups.push({ accountId: account, platform, read: stats.items.length, missing: stats.missing.length, error: null });
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
// 404 = o Publicador rodando é anterior à rota /stats (o pnpm dev não foi reiniciado depois da atualização).
const message = error instanceof ServiceError && error.status === 404
? "o Publicador está com a versão antiga, sem a leitura de números. Reinicie o pnpm dev."
: error instanceof Error ? error.message : String(error);
saveSync(account, platform, startedAt, message, 0, byRemote.size);
result.groups.push({ accountId: account, platform, read: 0, missing: byRemote.size, error: message });
if (error instanceof ServiceError && error.status === 503) break; // Publicador fora: as outras redes também falhariam
// Publicador fora ou desatualizado: as outras redes falhariam do mesmo jeito.
if (error instanceof ServiceError && (error.status === 503 || error.status === 404)) break;
}
}
return result;
+6 -2
View File
@@ -4,7 +4,10 @@
// `simulateMetrics()` ainda gera dados de EXEMPLO (simulated = 1) para ver o dashboard sem nada publicado; tudo
// que é simulado é marcado e sai de uma vez com `clearSimulated()`.
import crypto from "node:crypto";
import fs from "node:fs";
import path from "node:path";
import { all, get, run } from "./db";
import { REPO_ROOT } from "./paths";
import { listMetricSyncs, type MetricSync } from "./metrics-sync";
import type { MetricTotals, Platform } from "./types";
@@ -83,12 +86,13 @@ function videos(where: string, params: string[], base: string): VideoMetrics[] {
return [...map.entries()].map(([key, list]) => {
const first = list[0];
const sum = (k: "views" | "likes" | "comments" | "shares" | "saves") => list.reduce((n, r) => n + (r[k] ?? 0), 0);
const n = first.file_key ? /^ep(d+)/i.exec(first.file_key)?.[1] : undefined;
const n = first.file_key ? /^ep(\d+)/i.exec(first.file_key)?.[1] : undefined;
const captured = list.map((r) => r.captured_at).filter((c): c is string => !!c).sort();
return {
key, kind: first.clip_id !== null ? "clip" as const : "episode" as const,
title: list.find((r) => r.title)?.title || (first.clip_id !== null ? `Corte ${first.clip_id}` : "Episódio"),
cover: list.find((r) => r.cover)?.cover ?? null,
// Só capa que ainda existe no disco (a de um corte cuja sessão foi apagada some): sem ela, o marcador vazio.
cover: list.map((r) => r.cover).find((c): c is string => !!c && fs.existsSync(path.resolve(REPO_ROOT, c))) ?? null,
href: first.story_id ? (n ? `/stories/${first.story_id}/episodes/${Number(n)}` : `/stories/${first.story_id}`) : null,
publishedAt: first.published_at, capturedAt: captured.at(-1) ?? null,
totals: totals({ views: sum("views"), likes: sum("likes"), comments: sum("comments"), shares: sum("shares"), saves: sum("saves"),
+18
View File
@@ -413,6 +413,24 @@ describe("\"Publicar\" no cartão do corte (origem manual)", () => {
assert.deepEqual([after.status, after.attempts], ["queued", attempts + 1]);
});
it("horário específico: agenda no horário escolhido para a rede (manual), mesmo se já estava na fila", async () => {
const at = new Date(Date.now() + 3 * 86_400_000);
at.setUTCMinutes(17, 0, 0);
// O job do corte 500 está na fila (teste anterior): o horário escolhido o reagenda.
const r = await pub.publishClip(500, { accountId: "canal", platforms: ["youtube"], timing: "at", scheduledAt: { youtube: at.toISOString() } });
assert.equal(r.placed, 1);
const row = dbm.get<import("./publishing").JobRow>("SELECT * FROM publish_jobs WHERE source_kind = 'clip' AND source_id = '500'")!;
assert.deepEqual([row.status, row.schedule_source, row.scheduled_at], ["scheduled", "manual", at.toISOString()]);
});
it("horário específico: recusa rede sem horário, horário passado e além de um ano", async () => {
const base = { accountId: "canal", platforms: ["youtube"], timing: "at" };
await assert.rejects(pub.publishClip(500, { ...base, scheduledAt: {} }), /dia e a hora do YouTube/);
await assert.rejects(pub.publishClip(500, { ...base, scheduledAt: { youtube: "2020-01-01T10:00:00Z" } }), /já passou/);
await assert.rejects(pub.publishClip(500, { ...base, scheduledAt: { youtube: new Date(Date.now() + 400 * 86_400_000).toISOString() } }), /um ano/);
await assert.rejects(pub.publishClip(500, { ...base, timing: "ontem" }), /now, best_slot ou at/);
});
it("recusa corte que não está aprovado, canal inexistente e lista vazia de redes", async () => {
await assert.rejects(pub.publishClip(501, { accountId: "canal", platforms: ["youtube"] }), /aprovado/);
await assert.rejects(pub.publishClip(500, { accountId: "nao-existe", platforms: ["youtube"] }), /canal de publicação/);
+78 -10
View File
@@ -409,6 +409,24 @@ function cleanCaption(raw: unknown): string {
}
// ---------- "Publicar" no cartão do corte ----------
/** "Quando sai" do diálogo do corte: os do canal mais "at" (horário escolhido por você, por rede). */
export type ClipTiming = PublishTiming | "at";
/** Mesmos limites da troca de horário de um job (updateJob): futuro (1 min de folga) e até um ano. */
function readChosenTimes(raw: unknown, platforms: Platform[]): Map<Platform, Date> {
const map = raw && typeof raw === "object" && !Array.isArray(raw) ? raw as Record<string, unknown> : {};
const times = new Map<Platform, Date>();
for (const platform of platforms) {
const at = new Date(String(map[platform] ?? ""));
const name = platform === "youtube" ? "YouTube" : platform === "tiktok" ? "TikTok" : "Instagram";
if (map[platform] === undefined || Number.isNaN(at.getTime())) throw new UserError(`Escolha o dia e a hora do ${name}.`);
if (at.getTime() < Date.now() - 60_000) throw new UserError(`O horário do ${name} já passou. Escolha um horário no futuro.`);
if (at.getTime() > Date.now() + 365 * 86_400_000) throw new UserError(`O horário do ${name} passa de um ano. Escolha uma data mais perto.`);
times.set(platform, at);
}
return times;
}
export type ClipPublishResult = {
/** Jobs deste corte depois da ação (todos os canais e redes). */
jobs: PublishJob[];
@@ -422,17 +440,22 @@ export type ClipPublishResult = {
* Publica um corte APROVADO num canal de publicação, nas redes escolhidas — sem precisar ligar a fonte inteira ao
* canal. O clique é a aprovação humana. Os jobs ficam com `origin = 'manual'` (o despachante não os cancela por
* "fonte desligada"). `timing`: "now" sai no próximo ciclo (ignora horário bom e limite do dia, decisão sua);
* "best_slot" entra no próximo horário bom livre; ausente = o que o canal usa.
* "best_slot" entra no próximo horário bom livre; "at" sai no horário que você escolheu para cada rede
* (`scheduledAt`: { rede: ISO }, pode ser um igual para todas ou um diferente por rede; como "now", é decisão sua
* e não passa pelo horário bom nem pelo limite do dia); ausente = o que o canal usa.
* Rede que já tem esse corte publicado, em envio ou que pode já ter saído fica de fora (com o motivo).
*/
export async function publishClip(clipId: number, input: { accountId?: unknown; platforms?: unknown; timing?: unknown }): Promise<ClipPublishResult> {
export async function publishClip(clipId: number, input: { accountId?: unknown; platforms?: unknown; timing?: unknown; scheduledAt?: unknown }): Promise<ClipPublishResult> {
if (!Number.isInteger(clipId) || clipId <= 0) throw new UserError("Corte inválido.");
const account = get<Account>("SELECT * FROM accounts WHERE id = ?", String(input.accountId ?? ""));
if (!account) throw new UserError("Escolha um canal de publicação.");
const platforms = Array.isArray(input.platforms) ? [...new Set(input.platforms.map((p) => mustPlatform(String(p))))] : [];
if (platforms.length === 0) throw new UserError("Escolha pelo menos uma rede.");
if (input.timing !== undefined && input.timing !== "now" && input.timing !== "best_slot") throw new UserError("Quando sai: use now ou best_slot.");
const timing: PublishTiming = (input.timing as PublishTiming | undefined) ?? account.timing;
if (input.timing !== undefined && input.timing !== "now" && input.timing !== "best_slot" && input.timing !== "at") {
throw new UserError("Quando sai: use now, best_slot ou at.");
}
const timing: ClipTiming = (input.timing as ClipTiming | undefined) ?? account.timing;
const chosenAt = timing === "at" ? readChosenTimes(input.scheduledAt, platforms) : null;
const clip = await fetchClip(clipId);
if (!clip) throw new UserError("O corte não existe mais no Clipador.");
@@ -445,6 +468,7 @@ export async function publishClip(clipId: number, input: { accountId?: unknown;
const skipped: ClipPublishResult["skipped"] = [];
const toPlace: number[] = [];
const toNow: number[] = [];
const toReschedule: { id: number; at: Date }[] = [];
const ts = now();
for (const platform of platforms) {
const network = getNetwork(account.id, platform);
@@ -465,6 +489,7 @@ export async function publishClip(clipId: number, input: { accountId?: unknown;
skipped.push({ platform, reason: "já está sendo enviado" });
} else if (existing.status === "scheduled" || existing.status === "queued") {
if (timing === "now") toNow.push(existing.id);
else if (chosenAt) toReschedule.push({ id: existing.id, at: chosenAt.get(platform)! });
else skipped.push({ platform, reason: existing.status === "queued" ? "já está na fila" : "já está agendado" });
} else {
// Aguardando aprovação, cancelado, falhou (sem envio no Publicador) ou pediu login: volta com o vídeo atual.
@@ -475,16 +500,24 @@ export async function publishClip(clipId: number, input: { accountId?: unknown;
}
for (const id of toPlace) {
placeApproved(id, { from: ["awaiting_approval", "canceled", "failed", "needs_login"], timing });
const platform = get<{ platform: Platform }>("SELECT platform FROM publish_jobs WHERE id = ?", id)!.platform;
// Horário escolhido: no mínimo daqui a 5 s, senão placeApproved o trataria como passado e cairia no horário bom.
const preferredAt = chosenAt ? new Date(Math.max(chosenAt.get(platform)!.getTime(), Date.now() + 5_000)) : null;
placeApproved(id, { from: ["awaiting_approval", "canceled", "failed", "needs_login"], timing: timing === "now" ? "now" : "best_slot", preferredAt });
if (timing === "now") toNow.push(id);
}
for (const { id, at } of toReschedule) {
run(`UPDATE publish_jobs SET status = 'scheduled', scheduled_at = ?, schedule_source = 'manual', step = 'Agendado por você.',
error = NULL, updated_at = ? WHERE id = ? AND status IN ('scheduled', 'queued') AND publisher_job_id IS NULL`,
new Date(Math.max(at.getTime(), Date.now() + 5_000)).toISOString(), now(), id);
}
for (const id of new Set(toNow)) {
// "Agora" escolhido por você: sai no próximo ciclo, mesmo se o limite do dia já foi atingido.
run(`UPDATE publish_jobs SET status = 'queued', scheduled_at = ?, schedule_source = 'now', step = 'Na fila para enviar agora.',
error = NULL, updated_at = ? WHERE id = ? AND status IN ('scheduled', 'queued', 'failed') AND publisher_job_id IS NULL`, now(), now(), id);
}
// Sem horário livre, placeApproved marca "falhou" (com o motivo): só conta o que ficou na fila ou agendado.
const placed = [...new Set([...toPlace, ...toNow])]
const placed = [...new Set([...toPlace, ...toNow, ...toReschedule.map((r) => r.id)])]
.filter((id) => ["scheduled", "queued"].includes(get<{ status: string }>("SELECT status FROM publish_jobs WHERE id = ?", id)?.status ?? "")).length;
kickDispatcher();
return { jobs: listJobs({ sourceKind: "clip", sourceId: String(clipId) }), skipped, placed };
@@ -682,16 +715,51 @@ async function listClips(query: string): Promise<FullClip[]> {
/** Capa do corte: a do editor; senão `clip-<id>-cover.jpg` ao lado do vídeo; senão a miniatura. */
function clipCover(clip: FullClip): string | null {
const exists = (rel: string | null | undefined) => !!rel && fs.existsSync(path.resolve(REPO_ROOT, rel));
if (exists(clip.edit?.cover)) return clip.edit!.cover;
if (clip.file) {
let found: string | null = null;
if (exists(clip.edit?.cover)) found = clip.edit!.cover;
else if (clip.file) {
const cover = path.posix.join(path.posix.dirname(clip.file.replace(/\\/g, "/")), `clip-${clip.id}-cover.jpg`);
if (exists(cover)) return cover;
if (exists(cover)) found = cover;
}
if (!found && exists(clip.thumb) && /\.(jpe?g|png)$/i.test(clip.thumb!)) found = clip.thumb;
return found ? keepCover(clip.id, found) : null;
}
/**
* Pasta de capas do painel: o Clipador apaga `output/clipper/<sessão>/` inteira quando você apaga a sessão, e a
* capa de um vídeo já publicado sumiria do dashboard. Aqui fica uma cópia que só o painel mexe.
*/
const KEPT_COVERS = "output/publishing/covers";
/** Copia a capa do corte para a pasta do painel e devolve o caminho da cópia (ou o original, se a cópia falhar). */
function keepCover(clipId: number, rel: string): string {
const normalized = rel.replace(/\\/g, "/");
if (normalized.startsWith(`${KEPT_COVERS}/`)) return normalized;
const kept = `${KEPT_COVERS}/clip-${clipId}${path.extname(normalized).toLowerCase() || ".jpg"}`;
try {
fs.mkdirSync(path.resolve(REPO_ROOT, KEPT_COVERS), { recursive: true });
fs.copyFileSync(path.resolve(REPO_ROOT, normalized), path.resolve(REPO_ROOT, kept));
return kept;
} catch {
return normalized;
}
}
/** Jobs de corte cuja capa ainda está na pasta do Clipador: passa para a cópia do painel enquanto o arquivo existe. */
function keepClipCovers(): void {
const rows = all<{ id: number; source_id: string; cover: string }>(
`SELECT id, source_id, cover FROM publish_jobs WHERE source_kind = 'clip' AND cover IS NOT NULL AND cover NOT LIKE ?`,
`${KEPT_COVERS}/%`);
for (const r of rows) {
if (!fs.existsSync(path.resolve(REPO_ROOT, r.cover))) continue;
const kept = keepCover(Number(r.source_id), r.cover);
if (kept !== r.cover) run("UPDATE publish_jobs SET cover = ? WHERE id = ?", kept, r.id);
}
return exists(clip.thumb) && /\.(jpe?g|png)$/i.test(clip.thumb!) ? clip.thumb : null;
}
/** Sincroniza a fila com o Clipador. false = Clipador fora (ou não instalado) — nada muda neste ciclo. */
async function syncClips(): Promise<boolean> {
keepClipCovers();
const targets: ClipTarget[] = all<Pick<Account, "id" | "approval_mode" | "auto_since">>(
`SELECT a.id, a.approval_mode, a.auto_since FROM accounts a
WHERE EXISTS (SELECT 1 FROM account_channels l WHERE l.account_id = a.id AND l.status = 'active')`)