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
+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')`)