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:
+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