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:
@@ -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;
|
||||
|
||||
@@ -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"),
|
||||
|
||||
@@ -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
@@ -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')`)
|
||||
|
||||
Reference in New Issue
Block a user