Files
CenaForge/panel/src/lib/publishing.ts
T
MateuusandClaude Opus 5.5 dc0917b114 Clipador: vídeo final sem camadas de teste ao aprovar; publicação só usa o final
Pedido do dono: o vídeo da fila é de revisão (com as camadas `dev`, ex.: tradução);
ao aprovar, o serviço renderiza de novo sem elas, e só esse vai para as redes.

- db v14: clips.review_dev_json (camadas que entraram na revisão) e final_status/
  final_file/final_thumb/final_cover/final_error/final_at; backfill dos cortes antigos.
- Motor: queue_final/drop_final/render_final; fila renderiza finais primeiro com
  render_clip_edit(dev=False) em clip-<id>-final.mp4; revisão sem camada de teste
  vira o final sem render novo; prune guarda os blocos de quem ainda precisa do final.
- API: clip traz review.devLayers, final e publishFile; aprovar enfileira o final;
  desaprovar, mudar trecho, exportar, re-render e rejudge derrubam o final;
  POST /v1/clips/{id}/final (tentar de novo).
- Painel: etiqueta na lista, player Final/Revisão e estado do final no modal
  (gerando/pronto/erro com "Tentar de novo"), aviso no "Publicar"; o despachante
  relê o corte antes de enviar e espera o final (clipPublishFile), nunca a revisão.
- Testes: clipper/tests/test_final_render.py e testes do despachante no painel.
- Doc: doc/clipador/REVISAO.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 03:27:26 -03:00

1176 lines
66 KiB
TypeScript

// Fila de publicação (publish_jobs) e o trabalho de cada ciclo do despachante (doc/publicacao/PLANO.md, seção 5).
//
// O painel é o cérebro: decide o que vai para qual rede e quando; o Publicador (lib/publisher.ts) só executa.
// Origem dos vídeos:
// - cortes do Clipador (fontes ligadas ao canal: account_channels) — aprovação manual ou automática por canal;
// - episódios aprovados à mão ("Aprovar para publicar", com o render final escolhido).
// Estados: awaiting_approval → scheduled/queued → publishing → published | failed | needs_login; canceled a qualquer
// momento antes de sair. As regras puras (agenda, decisões) estão em lib/publishing-rules.ts, com testes.
//
// Honestidade: nada vira `published` sem ID/URL remota (ou rascunho explícito); com aprovação manual nada sai
// sem um humano aprovar (no Clipador ou aqui).
import fs from "node:fs";
import path from "node:path";
import { getNetwork, markNetworkNeedsLogin, refreshNetwork } from "./accounts";
import { clipperFetch } from "./clipper";
import { all, db, get, now, run } from "./db";
import { dispatcherState, kickDispatcher, logChange } from "./dispatcher";
import { ServiceError } from "./http";
import { REPO_ROOT, SERVABLE_ROOTS, resolveInside, storyDir } from "./paths";
import { cancelJob, createJob, getJob, profileIdFor, publisherStatus, type PublisherJob } from "./publisher";
import {
OCCUPYING, UNSENT, aiGeneratedFor, clientRefFor, clipPublishFile, isDue, jobActions, mayBeLive, needsReflow, parseVideoUrl, placeJob, planClipSync, readPublisherJob,
sendBlocker, tagsFromCaption,
type ClipAction, type ClipInfo, type ClipTarget, type ClipVideo, type ExistingJob,
} from "./publishing-rules";
import { autoCollectMetrics } from "./metrics-sync";
import { getSettings } from "./settings";
import { UserError, getEpisodeById, getStory } from "./stories";
import {
PLATFORMS, PUBLISH_JOB_STATUSES,
type Account, type AccountNetwork, type Platform, type PublishJob, type PublishJobStatus, type PublishSourceKind,
type PublishTiming, type PublishingSummary, type RenderJob,
} from "./types";
import { isUserVoice } from "./voice";
// ---------- linhas e visão ----------
export type JobRow = {
id: number;
account_id: string;
platform: Platform;
source_kind: PublishSourceKind;
source_id: string;
source_label: string;
file: string;
cover: string | null;
title: string;
caption: string;
status: PublishJobStatus;
scheduled_at: string | null;
schedule_source: PublishJob["scheduleSource"];
publisher_job_id: string | null;
step: string;
progress: number;
remote_id: string | null;
url: string | null;
draft: number;
error: string | null;
attempts: number;
cancel_reason: PublishJob["cancelReason"];
published_at: string | null;
created_at: string;
updated_at: string;
/** 'link' = criado pelo despachante (vínculo com o canal); 'manual' = "Publicar" no cartão do corte. */
origin: "link" | "manual";
};
type ViewRow = JobRow & {
account_name: string;
n_status: AccountNetwork["status"] | null;
n_mode: AccountNetwork["mode"];
n_handle: string | null;
n_display_name: string | null;
n_enabled: number | null;
};
const VIEW_SQL = `SELECT j.*, a.name AS account_name, n.status AS n_status, n.mode AS n_mode, n.handle AS n_handle,
n.display_name AS n_display_name, n.enabled AS n_enabled
FROM publish_jobs j JOIN accounts a ON a.id = j.account_id
LEFT JOIN account_networks n ON n.account_id = j.account_id AND n.platform = j.platform`;
function toView(r: ViewRow): PublishJob {
return {
id: r.id, accountId: r.account_id, accountName: r.account_name, platform: r.platform, sourceKind: r.source_kind,
sourceId: r.source_id, sourceLabel: r.source_label, file: r.file, cover: r.cover, title: r.title, caption: r.caption,
status: r.status, scheduledAt: r.scheduled_at, step: r.step, progress: r.progress, remoteId: r.remote_id, url: r.url,
draft: r.draft === 1, error: r.error, attempts: r.attempts, cancelReason: r.cancel_reason, publishedAt: r.published_at,
scheduleSource: r.schedule_source, mayBeLive: mayBeLive(r.status, r.publisher_job_id),
createdAt: r.created_at, updatedAt: r.updated_at,
network: r.n_status ? {
status: r.n_status, mode: r.n_mode, handle: r.n_handle, displayName: r.n_display_name, enabled: r.n_enabled === 1,
} : null,
actions: jobActions(r.status, !!r.publisher_job_id),
};
}
export function getJobView(id: number): PublishJob | undefined {
const row = get<ViewRow>(`${VIEW_SQL} WHERE j.id = ?`, id);
return row ? toView(row) : undefined;
}
/** Lista da fila: filtros opcionais por estados, canal e origem. Abertos primeiro (por horário), depois os finais. */
export function listJobs(filter: {
status?: string[]; accountId?: string; sourceKind?: string; sourceId?: string; limit?: number;
} = {}): PublishJob[] {
const where: string[] = [];
const params: (string | number)[] = [];
if (filter.status?.length) {
const bad = filter.status.filter((s) => !PUBLISH_JOB_STATUSES.includes(s as PublishJobStatus));
if (bad.length) throw new UserError(`Estado desconhecido: ${bad.join(", ")}.`);
where.push(`j.status IN (${filter.status.map(() => "?").join(",")})`);
params.push(...filter.status);
}
if (filter.accountId) { where.push("j.account_id = ?"); params.push(filter.accountId); }
if (filter.sourceKind) {
if (filter.sourceKind !== "clip" && filter.sourceKind !== "episode") throw new UserError("Origem inválida: use clip ou episode.");
where.push("j.source_kind = ?"); params.push(filter.sourceKind);
}
if (filter.sourceId) { where.push("j.source_id = ?"); params.push(filter.sourceId); }
const limit = Math.max(1, Math.min(1000, Math.floor(filter.limit ?? 300)));
return all<ViewRow>(
`${VIEW_SQL} ${where.length ? `WHERE ${where.join(" AND ")}` : ""}
ORDER BY CASE WHEN j.status IN ('published', 'canceled') THEN 1 ELSE 0 END,
CASE WHEN j.status IN ('published', 'canceled') THEN COALESCE(j.published_at, j.updated_at) END DESC,
COALESCE(j.scheduled_at, j.created_at) ASC, j.id ASC
LIMIT ?`, ...params, limit).map(toView);
}
export function publishingSummary(): PublishingSummary {
const counts = Object.fromEntries(PUBLISH_JOB_STATUSES.map((s) => [s, 0])) as Record<PublishJobStatus, number>;
for (const r of all<{ status: PublishJobStatus; n: number }>("SELECT status, COUNT(*) AS n FROM publish_jobs GROUP BY status")) {
counts[r.status] = r.n;
}
const state = dispatcherState();
return {
counts, awaitingApproval: counts.awaiting_approval, problems: counts.failed + counts.needs_login,
paused: getSettings().publishingPaused,
dispatcher: {
running: !!state.timer, lastTickAt: state.lastTickAt, lastError: state.lastError,
publisherOnline: state.publisherOnline, clipperOnline: state.clipperOnline,
},
};
}
function mustJob(id: number): JobRow {
const job = get<JobRow>("SELECT * FROM publish_jobs WHERE id = ?", id);
if (!job) throw new UserError("Publicação não encontrada.");
return job;
}
// ---------- colocação na agenda ----------
function occupiedTimes(accountId: string, platform: Platform, exceptId: number): Date[] {
return all<{ at: string }>(
`SELECT COALESCE(published_at, scheduled_at) AS at FROM publish_jobs
WHERE account_id = ? AND platform = ? AND id != ? AND status IN (${OCCUPYING.map(() => "?").join(",")})
AND COALESCE(published_at, scheduled_at) IS NOT NULL`, accountId, platform, exceptId, ...OCCUPYING)
.map((r) => new Date(r.at));
}
/**
* Job aprovado entra na fila (`timing=now`) ou no próximo horário bom livre (`best_slot`). Só age se o job ainda
* estiver num dos estados `from` (UPDATE condicional): um cancelamento feito no meio de um ciclo nunca é desfeito.
* Saindo de cancelado/falhou é uma nova tentativa (attempts + 1 ⇒ novo clientRef). `reflow` = reencaixe de um
* agendado que venceu com o painel fechado: sempre pelo próximo horário bom (limite do dia + 1 h).
* Devolve false se o job mudou de estado e nada foi feito. Exportado para teste.
*/
export function placeApproved(jobId: number, opts: {
from: PublishJobStatus[]; preferredAt?: Date | null; reflow?: boolean;
/** Troca o "quando sai" do canal só para este job (ex.: escolhido no diálogo "Publicar" do corte). */
timing?: PublishTiming;
}): boolean {
const job = get<JobRow>("SELECT * FROM publish_jobs WHERE id = ?", jobId);
if (!job || !opts.from.includes(job.status)) return false;
const account = get<Account>("SELECT * FROM accounts WHERE id = ?", job.account_id);
if (!account) return false;
const network = getNetwork(job.account_id, job.platform);
const settings = getSettings();
const at = new Date();
const preferredAt = opts.preferredAt && opts.preferredAt.getTime() > at.getTime() ? opts.preferredAt : null;
const placement = placeJob(opts.reflow ? "best_slot" : opts.timing ?? account.timing, {
now: at, timezone: settings.timezone, slots: settings.slots[job.platform], dailyLimit: network?.daily_limit ?? 3,
occupied: occupiedTimes(job.account_id, job.platform, job.id), preferredAt,
});
const guard = `id = ? AND status IN (${opts.from.map(() => "?").join(",")})`;
if (placement.status === "none") {
return run(`UPDATE publish_jobs SET status = 'failed', error = ?, step = '', updated_at = ? WHERE ${guard}`,
placement.reason, now(), jobId, ...opts.from).changes > 0;
}
const step = opts.reflow ? "Reagendado: o horário passou com o painel fechado."
: placement.status === "queued" ? "Na fila para enviar." : preferredAt ? "Agendado por você." : "Agendado para o próximo horário bom.";
const bump = ["canceled", "failed", "needs_login"].includes(job.status) ? 1 : 0;
return run(`UPDATE publish_jobs SET status = ?, scheduled_at = ?, schedule_source = ?, step = ?, error = NULL, cancel_reason = NULL,
publisher_job_id = NULL, progress = 0, attempts = attempts + ?, updated_at = ? WHERE ${guard}`,
placement.status, placement.scheduledAt.toISOString(), preferredAt ? "manual" : "auto", step, bump, now(), jobId, ...opts.from).changes > 0;
}
// ---------- ações humanas ----------
type ClipView = {
id: number; status: string; channelId: string | null; createdAt: string; title: string; caption: string;
file: string | null; thumb: string | null; edit: { cover: string | null } | null;
/** Vídeo final (sem as camadas de teste do vídeo de revisão): só ele vai para as redes. doc/clipador/REVISAO.md */
publishFile?: ClipVideo["publishFile"];
final?: (NonNullable<ClipVideo["final"]> & { cover: string | null }) | null;
};
/** Arquivo que fica no job: o final, se já existe; senão o de revisão só como referência — `sendDue` troca pelo final. */
const jobFileOf = (clip: ClipView) => clip.publishFile ?? clip.file;
async function fetchClip(clipId: number): Promise<ClipView | null> {
const response = await clipperFetch(`/v1/clips/${clipId}`, {}, 15_000);
if (response.status === 404) return null;
if (!response.ok) throw new UserError(`O Clipador respondeu ${response.status} ao ler o corte ${clipId}.`);
return (await response.json()) as ClipView;
}
async function patchClipStatus(clipId: number, status: "approved" | "published"): Promise<void> {
const response = await clipperFetch(`/v1/clips/${clipId}`, {
method: "PATCH", body: JSON.stringify({ status }), headers: { "Content-Type": "application/json" },
}, 15_000);
if (!response.ok) {
let message = `O Clipador respondeu ${response.status}.`;
try { message = String(((await response.json()) as { error?: string; detail?: string }).error ?? message); } catch { /* sem corpo */ }
throw new UserError(message);
}
}
/**
* Aprova o VÍDEO: todos os jobs aguardando dessa mesma origem (todas as redes e canais) entram na agenda.
* Corte: confere no Clipador que ainda está pronto e marca `approved` lá (aprovação humana). Para tirar uma
* rede específica, cancele o job dela.
*/
export async function approveJob(id: number): Promise<PublishJob> {
const job = mustJob(id);
if (job.status !== "awaiting_approval") throw new UserError("Este vídeo não está aguardando aprovação.");
if (job.source_kind === "clip") {
const clipId = Number(job.source_id);
const clip = await fetchClip(clipId);
if (!clip) throw new UserError("O corte não existe mais no Clipador.");
if (clip.status === "ready") await patchClipStatus(clipId, "approved");
else if (clip.status !== "approved") throw new UserError("O corte mudou no Clipador (editado ou rejeitado). Espere ficar pronto de novo.");
run("DELETE FROM clip_auto_approvals WHERE clip_id = ?", clipId);
}
const siblings = all<{ id: number; scheduled_at: string | null }>(
"SELECT id, scheduled_at FROM publish_jobs WHERE source_kind = ? AND source_id = ? AND status = 'awaiting_approval' ORDER BY id",
job.source_kind, job.source_id);
for (const s of siblings) placeApproved(s.id, { from: ["awaiting_approval"], preferredAt: s.scheduled_at ? new Date(s.scheduled_at) : null });
kickDispatcher();
return getJobView(id)!;
}
/** Publicar agora: sai no próximo ciclo, ignorando horário bom e limite do dia (decisão sua). */
export async function publishNow(id: number): Promise<PublishJob> {
let job = mustJob(id);
if (job.status === "awaiting_approval") {
await approveJob(id);
job = mustJob(id);
}
if (!["scheduled", "queued"].includes(job.status) || job.publisher_job_id) {
throw new UserError("Só dá para publicar agora um vídeo aprovado que ainda não foi enviado.");
}
const changed = run(`UPDATE publish_jobs SET status = 'queued', scheduled_at = ?, schedule_source = 'now', step = 'Na fila para enviar agora.',
updated_at = ? WHERE id = ? AND status IN ('scheduled', 'queued') AND publisher_job_id IS NULL`, now(), now(), id).changes;
if (changed === 0) throw new UserError("O vídeo mudou de estado enquanto você clicava. Atualize a lista.");
kickDispatcher();
return getJobView(id)!;
}
export const MAY_BE_LIVE_MESSAGE = "Confira na rede se o vídeo já saiu antes de tentar de novo (o envio anterior pode ter publicado).";
/**
* Tentar de novo: falhou / precisa de login ⇒ volta para a fila agora. Cancelado ⇒ volta a aguardar aprovação
* (precisa aprovar de novo — o vídeo pode ter mudado). Cada tentativa sobe `attempts` (novo clientRef).
* Se o envio anterior chegou ao Publicador e falhou (`mayBeLive`), exige `confirm: true` — senão responde 409.
*/
export function retryJob(id: number, input: { confirm?: unknown } = {}): PublishJob {
const job = mustJob(id);
if (mayBeLive(job.status, job.publisher_job_id) && input.confirm !== true) throw new ServiceError(MAY_BE_LIVE_MESSAGE, 409);
if (job.status === "failed" || job.status === "needs_login") {
run(`UPDATE publish_jobs SET status = 'queued', scheduled_at = ?, schedule_source = 'now', publisher_job_id = NULL, error = NULL,
progress = 0, attempts = attempts + 1, step = 'Na fila para tentar de novo.', updated_at = ? WHERE id = ? AND status = ?`,
now(), now(), id, job.status);
} else if (job.status === "canceled") {
run(`UPDATE publish_jobs SET status = 'awaiting_approval', scheduled_at = NULL, schedule_source = 'auto', publisher_job_id = NULL,
error = NULL, progress = 0, attempts = attempts + 1, cancel_reason = NULL, step = '', updated_at = ? WHERE id = ? AND status = 'canceled'`,
now(), id);
} else {
throw new UserError("Só dá para tentar de novo um vídeo que falhou, pediu login ou foi cancelado.");
}
kickDispatcher();
return getJobView(id)!;
}
/** Cancela este job (só esta rede deste canal). Já enviado ao Publicador: só se ele ainda não começou. */
export async function cancelPublishJob(id: number): Promise<PublishJob> {
const job = mustJob(id);
if (job.status === "published") throw new UserError("Este vídeo já foi publicado; apague direto na rede, se quiser.");
if (job.status === "canceled") return getJobView(id)!;
if (job.publisher_job_id && job.status === "publishing") {
const remote = await cancelJob(job.publisher_job_id).catch((error: unknown) => {
if (error instanceof ServiceError && error.status < 500) throw new UserError("O envio já começou; não dá mais para cancelar.");
throw error;
});
if (remote.status !== "canceled") throw new UserError("O envio já começou; não dá mais para cancelar.");
}
run("UPDATE publish_jobs SET status = 'canceled', cancel_reason = 'user', step = 'Cancelado por você.', updated_at = ? WHERE id = ?",
now(), id);
return getJobView(id)!;
}
/**
* "Já saiu: informar o link": o vídeo foi para a rede, mas o envio não trouxe o link (ou parou depois de publicar).
* Você confere na rede e cola o link; o job vira `published` com esse link (nunca sem ele) e conta como publicação
* real. Evita "Tentar de novo", que publicaria uma segunda vez.
*/
export function markPublished(id: number, input: { url?: unknown }): PublishJob {
const job = mustJob(id);
if (!["failed", "needs_login"].includes(job.status)) {
throw new UserError("Só dá para informar o link de um vídeo que ficou com problema.");
}
const parsed = parseVideoUrl(job.platform, String(input.url ?? ""));
if (!parsed) {
const example: Record<Platform, string> = {
tiktok: "https://www.tiktok.com/@conta/video/123…",
youtube: "https://www.youtube.com/shorts/abc…",
instagram: "https://www.instagram.com/reel/abc…",
};
throw new UserError(`Cole o link do vídeo no ${job.platform === "tiktok" ? "TikTok" : job.platform === "youtube" ? "YouTube" : "Instagram"} (ex.: ${example[job.platform]}).`);
}
const ts = now();
db().exec("BEGIN");
try {
const changed = run(`UPDATE publish_jobs SET status = 'published', url = ?, remote_id = ?, error = NULL, progress = 1,
step = 'Marcado como publicado por você (link conferido na rede).', published_at = ?, updated_at = ?
WHERE id = ? AND status = ?`, parsed.url, parsed.remoteId, ts, ts, id, job.status).changes;
if (changed === 0) throw new UserError("O vídeo mudou de estado enquanto você clicava. Atualize a lista.");
recordPublication(job, parsed.url, ts);
db().exec("COMMIT");
} catch (error) {
db().exec("ROLLBACK");
throw error;
}
kickDispatcher(); // corte com todas as redes publicadas é marcado `published` no Clipador no próximo ciclo
return getJobView(id)!;
}
/**
* "Apaguei na rede": você apagou o vídeo direto na rede (ex.: saiu cortado). O job volta a cancelado — sem link e
* sem o registro de publicação (e as métricas dele) — e a rede fica livre: "Publicar" no cartão do corte (ou aprovar
* o episódio de novo) envia outra vez, com uma tentativa nova (novo clientRef). O painel não apaga nada na rede.
*/
export function markRemoved(id: number): PublishJob {
const job = mustJob(id);
if (job.status !== "published") throw new UserError("Só dá para marcar como apagado um vídeo que está publicado.");
db().exec("BEGIN");
try {
const changed = run(`UPDATE publish_jobs SET status = 'canceled', cancel_reason = 'user', url = NULL, remote_id = NULL,
published_at = NULL, draft = 0, error = NULL, step = 'Apagado da rede por você. Para mandar de novo, use “Publicar” no corte.',
updated_at = ? WHERE id = ? AND status = 'published'`, now(), id).changes;
if (changed === 0) throw new UserError("O vídeo mudou de estado enquanto você clicava. Atualize a lista.");
run("DELETE FROM publications WHERE job_id = ?", id);
db().exec("COMMIT");
} catch (error) {
db().exec("ROLLBACK");
throw error;
}
return getJobView(id)!;
}
const EDITABLE: PublishJobStatus[] = ["awaiting_approval", "scheduled", "queued", "failed", "needs_login"];
/**
* Muda horário, título ou legenda. Horário escolhido à mão não passa pelo limite do dia (decisão sua).
* Aguardando aprovação: o horário fica guardado e vale quando você aprovar.
*/
export function updateJob(id: number, input: { scheduledAt?: unknown; title?: unknown; caption?: unknown }): PublishJob {
const job = mustJob(id);
if (!EDITABLE.includes(job.status)) {
throw new UserError("Este vídeo já está sendo enviado ou terminou; não dá mais para mudar.");
}
const title = input.title === undefined ? job.title : cleanTitle(input.title);
const caption = input.caption === undefined ? job.caption : cleanCaption(input.caption);
let status = job.status;
let scheduledAt = job.scheduled_at;
let step = job.step;
if (input.scheduledAt !== undefined) {
if (job.status === "failed" || job.status === "needs_login") throw new UserError("Use \"Tentar de novo\" antes de mudar o horário.");
const at = new Date(String(input.scheduledAt));
if (Number.isNaN(at.getTime())) throw new UserError("Horário inválido.");
if (at.getTime() < Date.now() - 60_000) throw new UserError("Escolha um horário no futuro.");
if (at.getTime() > Date.now() + 365 * 86_400_000) throw new UserError("Escolha um horário dentro de um ano.");
scheduledAt = at.toISOString();
if (job.status !== "awaiting_approval") {
status = at.getTime() <= Date.now() + 30_000 ? "queued" : "scheduled";
step = status === "queued" ? "Na fila para enviar." : "Agendado por você.";
}
}
const source = input.scheduledAt !== undefined ? "manual" : job.schedule_source;
const changed = run(`UPDATE publish_jobs SET title = ?, caption = ?, status = ?, scheduled_at = ?, schedule_source = ?, step = ?, updated_at = ?
WHERE id = ? AND status = ? AND (publisher_job_id IS NULL OR status IN ('failed', 'needs_login'))`,
title, caption, status, scheduledAt, source, step, now(), id, job.status).changes;
if (changed === 0) throw new UserError("O vídeo mudou de estado enquanto você editava. Atualize a lista.");
return getJobView(id)!;
}
function cleanTitle(raw: unknown): string {
const title = String(raw ?? "").replace(/\s+/g, " ").trim();
if (title.length < 1) throw new UserError("O título não pode ficar vazio.");
if (title.length > 100) throw new UserError("O título pode ter até 100 caracteres (limite do YouTube).");
return title;
}
function cleanCaption(raw: unknown): string {
const caption = String(raw ?? "").trim();
if (caption.length > 2200) throw new UserError("A legenda pode ter até 2.200 caracteres.");
return caption;
}
// ---------- "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[];
/** Redes escolhidas que não entraram, com o motivo em português. */
skipped: { platform: Platform; reason: string }[];
/** Quantas redes entraram (novas, de volta à fila ou adiantadas para agora). */
placed: number;
};
/**
* 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; "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; 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" && 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.");
if (clip.status !== "approved" && clip.status !== "published") throw new UserError("Só dá para publicar um corte aprovado. Aprove o corte antes.");
if (!clip.file) throw new UserError("O corte ainda não tem vídeo pronto.");
const title = (clip.title || `Corte ${clip.id}`).replace(/\s+/g, " ").trim().slice(0, 100);
const caption = (clip.caption ?? "").slice(0, 2200);
const cover = clipCover({ ...clip, status: clip.status });
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);
if (!network || network.status === "disconnected") { skipped.push({ platform, reason: "não está conectada neste canal" }); continue; }
if (network.enabled !== 1) { skipped.push({ platform, reason: "está pausada neste canal" }); continue; }
const existing = get<JobRow>("SELECT * FROM publish_jobs WHERE account_id = ? AND platform = ? AND source_kind = 'clip' AND source_id = ?",
account.id, platform, String(clipId));
if (!existing) {
const info = run(`INSERT INTO publish_jobs (account_id, platform, source_kind, source_id, source_label, file, cover, title, caption, status, origin, created_at, updated_at)
VALUES (?, ?, 'clip', ?, ?, ?, ?, ?, ?, 'awaiting_approval', 'manual', ?, ?)`,
account.id, platform, String(clipId), clip.channelId ?? "", jobFileOf(clip), cover, title, caption, ts, ts);
toPlace.push(Number(info.lastInsertRowid));
} else if (existing.status === "published") {
skipped.push({ platform, reason: "já foi publicado nesta rede" });
} else if (mayBeLive(existing.status, existing.publisher_job_id)) {
skipped.push({ platform, reason: "o envio anterior pode ter saído: confira na rede e use “Tentar de novo” em Publicações" });
} else if (existing.status === "publishing") {
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.
run("UPDATE publish_jobs SET file = ?, cover = ?, title = ?, caption = ?, origin = 'manual', updated_at = ? WHERE id = ?",
jobFileOf(clip), cover, title, caption, ts, existing.id);
toPlace.push(existing.id);
}
}
for (const id of toPlace) {
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, ...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 };
}
// ---------- episódios ----------
/** Renders que podem ir ao ar: perfil final (Godot) ou documentário (montagem), com MP4 no disco. */
function finalRenders(episodeId: number): RenderJob[] {
return all<RenderJob>(
"SELECT * FROM renders WHERE episode_id = ? AND status = 'success' AND mp4 IS NOT NULL AND profile IN ('final', 'documentary') ORDER BY id DESC",
episodeId).filter((r) => fs.existsSync(path.resolve(REPO_ROOT, r.mp4!)));
}
type EpisodeTarget = { accountId: string; name: string; networks: { platform: Platform; status: AccountNetwork["status"]; enabled: boolean; willReceive: boolean }[] };
function episodeTargets(storyId: string): EpisodeTarget[] {
const accounts = all<{ id: string; name: string }>(
`SELECT a.id, a.name FROM account_stories l JOIN accounts a ON a.id = l.account_id
WHERE l.story_id = ? AND l.status = 'active' ORDER BY a.name`, storyId);
return accounts.map((a) => ({
accountId: a.id, name: a.name,
networks: all<AccountNetwork>("SELECT * FROM account_networks WHERE account_id = ? ORDER BY platform", a.id).map((n) => ({
platform: n.platform, status: n.status, enabled: n.enabled === 1, willReceive: receives(n),
})),
}));
}
/** A rede recebe vídeos novos: ligada no canal e já conectada alguma vez (desconectada não acumula fila). */
const receives = (n: Pick<AccountNetwork, "enabled" | "status">) => n.enabled === 1 && n.status !== "disconnected";
export type EpisodeApproval = {
episodeId: number;
approvedAt: string | null;
renderId: number | null;
title: string;
caption: string;
/** Renders finais que podem ser aprovados (o mais novo primeiro). */
renders: { id: number; profile: RenderJob["profile"]; mp4: string; finishedAt: string | null }[];
/** Canais ligados à história e as redes que vão receber. */
targets: EpisodeTarget[];
jobs: PublishJob[];
};
export function episodeApproval(episodeId: number): EpisodeApproval {
const ep = getEpisodeById(episodeId);
if (!ep) throw new UserError("Episódio não encontrado.");
return {
episodeId, approvedAt: ep.approved_at, renderId: ep.approved_render_id,
title: ep.publish_title ?? (ep.title || ""), caption: ep.publish_caption ?? "",
renders: finalRenders(episodeId).map((r) => ({ id: r.id, profile: r.profile, mp4: r.mp4!, finishedAt: r.finished_at })),
targets: episodeTargets(ep.story_id),
jobs: listJobs({ sourceKind: "episode", sourceId: String(episodeId) }),
};
}
/**
* "Aprovar para publicar": exige um render final do episódio. Cria (ou atualiza) os jobs de todos os canais
* ligados à história, nas redes que recebem, já aprovados — o clique é a aprovação humana. Aprovar de novo com
* outro render/título atualiza os jobs que ainda não saíram.
*/
export function approveEpisode(episodeId: number, input: { renderId?: unknown; title?: unknown; caption?: unknown }): EpisodeApproval {
const ep = getEpisodeById(episodeId);
if (!ep) throw new UserError("Episódio não encontrado.");
const story = getStory(ep.story_id)!;
const renderId = Number(input.renderId);
const render = finalRenders(episodeId).find((r) => r.id === renderId);
if (!render) throw new UserError("Escolha um render final deste episódio (renderize no perfil final antes de aprovar).");
const title = cleanTitle(input.title ?? ep.title);
const caption = cleanCaption(input.caption ?? "");
const ts = now();
const label = `${story.title} · ${ep.file_key}`;
const created: number[] = [];
db().exec("BEGIN");
try {
run("UPDATE episodes SET approved_at = ?, approved_render_id = ?, publish_title = ?, publish_caption = ? WHERE id = ?",
ts, render.id, title, caption, episodeId);
for (const target of episodeTargets(ep.story_id)) {
for (const n of target.networks) {
if (!n.willReceive) continue;
const existing = get<JobRow>("SELECT * FROM publish_jobs WHERE account_id = ? AND platform = ? AND source_kind = 'episode' AND source_id = ?",
target.accountId, n.platform, String(episodeId));
if (!existing) {
const info = run(`INSERT INTO publish_jobs (account_id, platform, source_kind, source_id, source_label, file, cover, title, caption, status, created_at, updated_at)
VALUES (?, ?, 'episode', ?, ?, ?, NULL, ?, ?, 'awaiting_approval', ?, ?)`,
target.accountId, n.platform, String(episodeId), label, render.mp4!, title, caption, ts, ts);
created.push(Number(info.lastInsertRowid));
} else if (mayBeLive(existing.status, existing.publisher_job_id)) {
// Pode já estar na rede: fica em "Com problema" até você conferir e usar "Tentar de novo" (com confirmação).
continue;
} else if (UNSENT.includes(existing.status) || existing.status === "canceled" || existing.status === "failed") {
run("UPDATE publish_jobs SET file = ?, title = ?, caption = ?, source_label = ?, updated_at = ? WHERE id = ?",
render.mp4!, title, caption, label, ts, existing.id);
if (existing.status === "awaiting_approval" || existing.status === "canceled" || existing.status === "failed") created.push(existing.id);
}
}
}
db().exec("COMMIT");
} catch (error) {
db().exec("ROLLBACK");
throw error;
}
for (const id of created) placeApproved(id, { from: ["awaiting_approval", "canceled", "failed"] });
kickDispatcher();
return episodeApproval(episodeId);
}
/**
* Desfaz a aprovação: jobs que ainda não saíram são cancelados (os já publicados ficam). Os entregues ao Publicador
* que ele ainda não começou também são cancelados lá; os que já começaram seguem (não dá para parar no meio).
*/
export async function unapproveEpisode(episodeId: number): Promise<EpisodeApproval> {
const ep = getEpisodeById(episodeId);
if (!ep) throw new UserError("Episódio não encontrado.");
run("UPDATE episodes SET approved_at = NULL WHERE id = ?", episodeId);
const step = "Cancelado: a aprovação do episódio foi desfeita.";
run(`UPDATE publish_jobs SET status = 'canceled', cancel_reason = 'unapproved', step = ?, updated_at = ?
WHERE source_kind = 'episode' AND source_id = ? AND status IN ('awaiting_approval', 'scheduled', 'queued') AND publisher_job_id IS NULL`,
step, now(), String(episodeId));
const sent = all<JobRow>("SELECT * FROM publish_jobs WHERE source_kind = 'episode' AND source_id = ? AND status = 'publishing' AND publisher_job_id IS NOT NULL",
String(episodeId));
for (const job of sent) {
try {
if ((await cancelJob(job.publisher_job_id!)).status === "canceled") {
run("UPDATE publish_jobs SET status = 'canceled', cancel_reason = 'unapproved', step = ?, updated_at = ? WHERE id = ? AND status = 'publishing'",
step, now(), job.id);
}
} catch (error) {
console.warn(`[publicação] job ${job.id}: não deu para cancelar no Publicador (${error instanceof Error ? error.message : String(error)}); o envio segue.`);
}
}
return episodeApproval(episodeId);
}
// ---------- ciclo do despachante ----------
const PROFILE_REFRESH_MS = 5 * 60_000;
const MAX_SENDS_PER_TICK = 3;
const profileRefreshedAt = ((globalThis as unknown as { __cenaforgeProfileRefresh?: Map<string, number> }).__cenaforgeProfileRefresh ??= new Map());
/** Um ciclo: perfis → cortes → episódios → vencidos → acompanhar envios → enviar. Cada parte falha sozinha. */
export async function dispatcherTick(): Promise<void> {
const state = dispatcherState();
const errors: string[] = [];
const step = async (topic: string, fn: () => Promise<void> | void) => {
try {
await fn();
logChange(topic, null);
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
errors.push(`${topic}: ${message}`);
logChange(topic, message);
if (!(error instanceof UserError)) console.error(error);
}
};
await step("perfis", async () => { state.publisherOnline = await refreshProfiles(); });
await step("cortes", async () => { state.clipperOnline = await syncClips(); });
await step("episódios", syncEpisodes);
await step("agenda", promoteDue);
if (state.publisherOnline) {
await step("acompanhamento", pollPublishing);
await step("envio", sendDue);
// Números dos posts para o dashboard: roda em segundo plano (pode abrir a janela por ~20 s), não segura o ciclo.
autoCollectMetrics();
} else {
markWaiting("Esperando: o Publicador não está rodando — inicie com pnpm dev.");
}
if (errors.length) throw new Error(errors.join(" · "));
}
/** Relê no Publicador os perfis conectando (a cada ciclo) e os demais (a cada 5 min). false = Publicador fora. */
async function refreshProfiles(): Promise<boolean> {
if (!(await publisherStatus()).online) return false;
for (const n of all<AccountNetwork>("SELECT * FROM account_networks WHERE mode IS NOT NULL")) {
const key = `${n.account_id}|${n.platform}`;
if (n.status !== "connecting" && Date.now() - (profileRefreshedAt.get(key) ?? 0) < PROFILE_REFRESH_MS) continue;
profileRefreshedAt.set(key, Date.now());
try {
await refreshNetwork(n.account_id, n.platform);
logChange(`perfil ${key}`, null);
} catch (error) {
if (error instanceof ServiceError && error.status >= 503) return false;
logChange(`perfil ${key}`, error instanceof Error ? error.message : String(error));
}
}
return true;
}
type FullClip = ClipView & { status: string };
async function listClips(query: string): Promise<FullClip[]> {
const response = await clipperFetch(`/v1/clips?${query}`, {}, 30_000);
if (!response.ok) throw new UserError(`O Clipador respondeu ${response.status} ao listar cortes.`);
return ((await response.json()) as { clips: FullClip[] }).clips;
}
/** Capa do corte: a do vídeo final; senão 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));
let found: string | null = null;
if (clip.publishFile && exists(clip.final?.cover)) found = clip.final!.cover;
else 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)) 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);
}
}
/** 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')`)
.map((a) => ({
accountId: a.id, approvalMode: a.approval_mode, autoSince: a.auto_since,
channels: all<{ channel_id: string; linked_at: string }>(
"SELECT channel_id, linked_at FROM account_channels WHERE account_id = ? AND status = 'active'", a.id)
.map((c) => ({ channelId: c.channel_id, linkedAt: c.linked_at })),
platforms: all<AccountNetwork>("SELECT * FROM account_networks WHERE account_id = ?", a.id).filter(receives).map((n) => n.platform),
}));
const channelIds = [...new Set(targets.flatMap((t) => t.channels.map((c) => c.channelId)))];
// Cortes com jobs ainda em andamento (ou publicados há pouco: falta marcar `published` no Clipador).
const recent = new Date(Date.now() - 2 * 86_400_000).toISOString();
const jobClipIds = all<{ source_id: string }>(
`SELECT DISTINCT source_id FROM publish_jobs WHERE source_kind = 'clip'
AND (status IN ('awaiting_approval', 'scheduled', 'queued', 'publishing', 'failed', 'needs_login')
OR (status = 'published' AND published_at >= ?) OR (status = 'canceled' AND cancel_reason = 'source_changed'))`, recent)
.map((r) => Number(r.source_id));
if (channelIds.length === 0 && jobClipIds.length === 0) return dispatcherState().clipperOnline ?? true;
const offline = (error: unknown) => error instanceof UserError && /fora do ar|não instalado/.test(error.message);
let clips: FullClip[] = [];
let complete = true;
try {
if (channelIds.length) clips = await listClips(`status=ready,approved&channel=${channelIds.map(encodeURIComponent).join(",")}&limit=500`);
} catch (error) {
if (offline(error)) return false;
throw error;
}
const have = new Set(clips.map((c) => c.id));
const missing = jobClipIds.filter((id) => !have.has(id));
for (let i = 0; i < missing.length; i += 200) {
try {
clips.push(...await listClips(`ids=${missing.slice(i, i + 200).join(",")}&limit=500`));
} catch (error) {
if (offline(error)) return false;
// Sem a consulta por ids, "sumiu" não quer dizer "apagado": nada é cancelado por ausência neste ciclo.
complete = false;
logChange("cortes por id", error instanceof Error ? error.message : String(error));
}
}
const ids = [...new Set([...clips.map((c) => c.id), ...jobClipIds])];
const idsJson = JSON.stringify(ids.map(String));
const jobs: ExistingJob[] = all<JobRow>(
"SELECT * FROM publish_jobs WHERE source_kind = 'clip' AND source_id IN (SELECT value FROM json_each(?))", idsJson)
.map((j) => ({ id: j.id, accountId: j.account_id, platform: j.platform, sourceId: j.source_id, status: j.status, cancelReason: j.cancel_reason, publisherJobId: j.publisher_job_id, origin: j.origin }));
const autoApproved = new Set(all<{ clip_id: number }>(
"SELECT clip_id FROM clip_auto_approvals WHERE clip_id IN (SELECT value FROM json_each(?))", JSON.stringify(ids)).map((r) => r.clip_id));
const infos: ClipInfo[] = clips.map((c) => ({ id: c.id, status: c.status, channelId: c.channelId, createdAt: c.createdAt }));
const actions = planClipSync({ clips: infos, complete, autoApproved, targets, jobs });
await applyClipActions(actions, new Map(clips.map((c) => [c.id, c])));
return true;
}
async function applyClipActions(actions: ClipAction[], clips: Map<number, FullClip>): Promise<void> {
// Aprovar no Clipador primeiro: se falhar, os jobs "aprovados" desse corte esperam o próximo ciclo.
const failedApprovals = new Set<number>();
for (const a of actions) {
if (a.kind !== "approve_clip") continue;
// Registra ANTES do PATCH: se o ciclo cair entre os dois, o corte aprovado não é confundido com aprovação humana.
const inserted = run("INSERT INTO clip_auto_approvals (clip_id, approved_at) VALUES (?, ?) ON CONFLICT (clip_id) DO NOTHING", a.clipId, now()).changes > 0;
try {
await patchClipStatus(a.clipId, "approved");
} catch (error) {
if (inserted) run("DELETE FROM clip_auto_approvals WHERE clip_id = ?", a.clipId);
failedApprovals.add(a.clipId);
logChange(`aprovar corte ${a.clipId}`, error instanceof Error ? error.message : String(error));
}
}
const ts = now();
for (const a of actions) {
switch (a.kind) {
case "create": {
const clip = clips.get(a.clipId);
if (!clip?.file) break;
const approved = a.approved && !failedApprovals.has(a.clipId);
const info = run(`INSERT INTO publish_jobs (account_id, platform, source_kind, source_id, source_label, file, cover, title, caption, status, created_at, updated_at)
VALUES (?, ?, 'clip', ?, ?, ?, ?, ?, ?, 'awaiting_approval', ?, ?)
ON CONFLICT (account_id, platform, source_kind, source_id) DO NOTHING`,
a.accountId, a.platform, String(clip.id), clip.channelId ?? "", jobFileOf(clip), clipCover(clip),
(clip.title || `Corte ${clip.id}`).slice(0, 100), (clip.caption ?? "").slice(0, 2200), ts, ts);
if (approved && info.changes > 0) placeApproved(Number(info.lastInsertRowid), { from: ["awaiting_approval"] });
break;
}
case "approve": {
const job = mustJob(a.jobId);
if (failedApprovals.has(Number(job.source_id))) break;
placeApproved(a.jobId, { from: ["awaiting_approval"], preferredAt: job.scheduled_at ? new Date(job.scheduled_at) : null });
break;
}
case "revive": {
const job = mustJob(a.jobId);
const clip = clips.get(Number(job.source_id));
if (!clip?.file) break;
// Guarda: só renasce o que o despachante cancelou (cancelado por você fica cancelado).
const revived = run(`UPDATE publish_jobs SET status = 'awaiting_approval', cancel_reason = NULL, error = NULL, publisher_job_id = NULL,
progress = 0, attempts = attempts + 1, schedule_source = 'auto', step = 'O corte está pronto de novo.', file = ?, cover = ?,
title = ?, caption = ?, scheduled_at = NULL, updated_at = ?
WHERE id = ? AND status = 'canceled' AND cancel_reason IN ('source_changed', 'unlinked')`,
jobFileOf(clip), clipCover(clip), (clip.title || `Corte ${clip.id}`).slice(0, 100), (clip.caption ?? "").slice(0, 2200), ts, a.jobId).changes;
if (revived && a.approved && !failedApprovals.has(clip.id)) placeApproved(a.jobId, { from: ["awaiting_approval"] });
break;
}
case "cancel":
run(`UPDATE publish_jobs SET status = 'canceled', cancel_reason = ?, step = ?, updated_at = ?
WHERE id = ? AND status IN ('awaiting_approval', 'scheduled', 'queued') AND publisher_job_id IS NULL`,
a.reason, a.reason === "unlinked" ? UNLINKED_CLIP_STEP : "Cancelado: o corte mudou no Clipador (editado, rejeitado ou apagado).",
ts, a.jobId);
break;
case "forget_auto":
run("DELETE FROM clip_auto_approvals WHERE clip_id = ?", a.clipId);
break;
case "mark_clip_published":
try {
await patchClipStatus(a.clipId, "published");
} catch (error) {
logChange(`marcar corte ${a.clipId}`, error instanceof Error ? error.message : String(error));
}
break;
case "approve_clip":
break;
}
}
}
const UNLINKED_CLIP_STEP = "Cancelado: a fonte foi desligada deste canal.";
const UNLINKED_STORY_STEP = "Cancelado: a história foi desligada deste canal.";
/** O vínculo que justifica o job ainda está ativo? (fonte ↔ canal para corte; história ↔ canal para episódio) */
function linkActive(job: Pick<JobRow, "account_id" | "source_kind" | "source_id" | "source_label" | "origin">): boolean {
if (job.source_kind === "clip") {
if (job.origin === "manual") return true; // você mandou publicar este corte neste canal: não depende do vínculo
return !!get("SELECT 1 FROM account_channels WHERE account_id = ? AND channel_id = ? AND status = 'active'", job.account_id, job.source_label);
}
return !!get(`SELECT 1 FROM account_stories l JOIN episodes e ON e.story_id = l.story_id
WHERE e.id = ? AND l.account_id = ? AND l.status = 'active'`, Number(job.source_id), job.account_id);
}
function cancelUnlinked(job: Pick<JobRow, "id" | "source_kind">): void {
run(`UPDATE publish_jobs SET status = 'canceled', cancel_reason = 'unlinked', step = ?, updated_at = ?
WHERE id = ? AND status IN ('awaiting_approval', 'scheduled', 'queued') AND publisher_job_id IS NULL`,
job.source_kind === "clip" ? UNLINKED_CLIP_STEP : UNLINKED_STORY_STEP, now(), job.id);
}
/** Jobs de episódio que não saíram: episódio apagado, aprovação desfeita, render sumiu ou história desligada ⇒ cancela. */
function syncEpisodes(): void {
const jobs = all<JobRow>(`SELECT * FROM publish_jobs WHERE source_kind = 'episode' AND status IN ('awaiting_approval', 'scheduled', 'queued')
AND publisher_job_id IS NULL`);
for (const job of jobs) {
const ep = get<{ approved_at: string | null }>("SELECT approved_at FROM episodes WHERE id = ?", Number(job.source_id));
const fileOk = fs.existsSync(path.resolve(REPO_ROOT, job.file));
if (ep?.approved_at && fileOk) {
if (!linkActive(job)) cancelUnlinked(job);
continue;
}
run(`UPDATE publish_jobs SET status = 'canceled', cancel_reason = 'unapproved', step = ?, updated_at = ?
WHERE id = ? AND status IN ('awaiting_approval', 'scheduled', 'queued') AND publisher_job_id IS NULL`,
!ep ? "Cancelado: o episódio foi apagado." : !ep.approved_at ? "Cancelado: a aprovação do episódio foi desfeita." : "Cancelado: o arquivo do vídeo sumiu.",
now(), job.id);
}
}
/**
* Agendados com horário vencido entram na fila. Vencidos há mais de 30 min pela agenda automática (painel fechado)
* são reencaixados no próximo horário bom — nada de rajada ao reabrir o painel.
*/
function promoteDue(): void {
const at = new Date();
for (const job of all<JobRow>("SELECT * FROM publish_jobs WHERE status = 'scheduled' ORDER BY scheduled_at, id")) {
if (!isDue({ status: job.status, scheduledAt: job.scheduled_at }, at)) continue;
if (needsReflow({ scheduleSource: job.schedule_source, scheduledAt: job.scheduled_at }, at)) {
placeApproved(job.id, { from: ["scheduled"], reflow: true });
continue;
}
run("UPDATE publish_jobs SET status = 'queued', step = 'Na fila para enviar.', updated_at = ? WHERE id = ? AND status = 'scheduled'", now(), job.id);
}
}
function markWaiting(step: string): void {
run("UPDATE publish_jobs SET step = ? WHERE status = 'queued' AND publisher_job_id IS NULL AND step != ?", step, step);
}
/** Acompanha os envios no Publicador e grava o resultado. Um job com problema não impede os outros. */
async function pollPublishing(): Promise<void> {
for (const job of all<JobRow>("SELECT * FROM publish_jobs WHERE status = 'publishing' AND publisher_job_id IS NOT NULL")) {
const topic = `acompanhar job ${job.id}`;
try {
let remote: PublisherJob;
try {
remote = await getJob(job.publisher_job_id!);
} catch (error) {
if (error instanceof ServiceError && error.status === 404) {
run(`UPDATE publish_jobs SET status = 'failed', error = ?, updated_at = ? WHERE id = ? AND status = 'publishing'`,
"O Publicador não encontrou este envio (os dados dele foram apagados?). Confira na rede antes de tentar de novo.", now(), job.id);
continue;
}
throw error;
}
finishFromPublisher(job, remote);
if (remote.status === "needs_login") {
// Autorização oficial vencida: o Publicador marca o perfil `expired` — espelha o estado real.
await refreshNetwork(job.account_id, job.platform).catch((error: unknown) => logChange(`perfil ${job.account_id}|${job.platform}`, errorText(error)));
}
logChange(topic, null);
} catch (error) {
if (error instanceof ServiceError && error.status >= 503) throw error; // Publicador caiu: o ciclo registra
logChange(topic, errorText(error));
}
}
}
const errorText = (error: unknown) => (error instanceof Error ? error.message : String(error));
/** Aplica o estado do job do Publicador (exportado para teste). */
export function finishFromPublisher(job: JobRow, remote: Pick<PublisherJob, "status" | "step" | "progress" | "remoteId" | "url" | "draft" | "error">): void {
const update = readPublisherJob(remote);
const ts = now();
db().exec("BEGIN");
try {
run(`UPDATE publish_jobs SET status = ?, step = ?, progress = ?, remote_id = ?, url = ?, draft = ?, error = ?,
published_at = CASE WHEN ? = 'published' THEN ? ELSE published_at END,
cancel_reason = CASE WHEN ? = 'canceled' THEN 'user' ELSE cancel_reason END, updated_at = ? WHERE id = ?`,
update.status, update.step, update.progress, update.remoteId, update.url, update.draft ? 1 : 0, update.error,
update.status, ts, update.status, ts, job.id);
if (update.status === "published") recordPublication(job, update.url, ts);
if (update.networkNeedsLogin) markNetworkNeedsLogin(job.account_id, job.platform, update.error);
db().exec("COMMIT");
} catch (error) {
db().exec("ROLLBACK");
throw error;
}
}
/** Registro real (simulated = 0) para o dashboard. Um simulado do mesmo episódio/canal/rede sai da frente. */
function recordPublication(job: JobRow, url: string | null, at: string): void {
if (job.source_kind === "episode") {
const episodeId = Number(job.source_id);
if (!get("SELECT 1 FROM episodes WHERE id = ?", episodeId)) return;
run("DELETE FROM publications WHERE episode_id = ? AND account_id = ? AND platform = ? AND simulated = 1", episodeId, job.account_id, job.platform);
run(`INSERT OR IGNORE INTO publications (episode_id, clip_id, account_id, platform, url, published_at, simulated, job_id)
VALUES (?, NULL, ?, ?, ?, ?, 0, ?)`, episodeId, job.account_id, job.platform, url ?? "", at, job.id);
} else {
run(`INSERT OR IGNORE INTO publications (episode_id, clip_id, account_id, platform, url, published_at, simulated, job_id)
VALUES (NULL, ?, ?, ?, ?, ?, 0, ?)`, Number(job.source_id), job.account_id, job.platform, url ?? "", at, job.id);
}
}
/** Episódio usa voz de personagem (RVC) ou clonada? (voz da montagem: stories/<id>/<file_key>.montage.json) */
function episodeUsesPersonaVoice(episodeId: number): boolean {
const ep = getEpisodeById(episodeId);
if (!ep) return false;
const file = path.join(storyDir(ep.story_id), `${ep.file_key}.montage.json`);
try {
const saved = JSON.parse(fs.readFileSync(file, "utf8")) as { voiceId?: string };
return isUserVoice(String(saved.voiceId ?? ""));
} catch (error) {
// Sem como saber a voz: por cautela, rotula como feito com IA (o canal pode forçar com ai_label = never).
console.warn(`[publicação] episódio ${episodeId}: não deu para ler a voz (${errorText(error)}); rótulo de IA ligado por cautela.`);
return true;
}
}
/** Vídeo final de um job de corte, lido no Clipador agora; ou o motivo de esperar (Clipador fora, final não pronto). */
async function clipFinalForJob(job: JobRow): Promise<{ file: string; cover: string | null } | { wait: string }> {
let clip: ClipView | null;
try {
clip = await fetchClip(Number(job.source_id));
} catch (error) {
return { wait: `Esperando o Clipador para conferir o vídeo final (${errorText(error)}).` };
}
if (!clip) return { wait: "Esperando: o corte não existe mais no Clipador." };
const target = clipPublishFile(clip);
if ("wait" in target) return target;
return { file: target.file, cover: clip.publishFile ? clipCover(clip) : null };
}
/**
* Envia ao Publicador os jobs vencidos cujo perfil está pronto (um envio por perfil por vez). Seguro contra:
* - cancelamento no meio do ciclo: relê a linha antes de enviar e grava com UPDATE condicional; se o job mudou
* enquanto o Publicador criava o envio, cancela o envio lá;
* - falha ambígua (timeout/conexão caída): o job fica na fila e o reenvio usa o MESMO clientRef ("<id>:<attempts>"),
* que o Publicador reconhece e devolve o envio existente em vez de criar outro.
*/
async function sendDue(): Promise<void> {
const settings = getSettings();
const at = new Date();
const due = all<JobRow>("SELECT * FROM publish_jobs WHERE status = 'queued' AND publisher_job_id IS NULL ORDER BY scheduled_at, id")
.filter((j) => isDue({ status: j.status, scheduledAt: j.scheduled_at }, at));
const busy = new Set(all<{ k: string }>("SELECT account_id || '|' || platform AS k FROM publish_jobs WHERE status = 'publishing'").map((r) => r.k));
let sent = 0;
for (const listed of due) {
// Relê: entre a lista e aqui houve awaits (envios anteriores) — pode ter sido cancelado ou mudado.
const job = get<JobRow>("SELECT * FROM publish_jobs WHERE id = ? AND status = 'queued' AND publisher_job_id IS NULL", listed.id);
if (!job) continue;
const setStep = (step: string) => {
if (job.step !== step) run("UPDATE publish_jobs SET step = ? WHERE id = ? AND status = 'queued'", step, job.id);
};
if (!linkActive(job)) { cancelUnlinked(job); continue; }
const network = getNetwork(job.account_id, job.platform);
const blocker = sendBlocker(network, settings.publishingPaused);
if (blocker) { setStep(blocker); continue; }
if (needsReflow({ scheduleSource: job.schedule_source, scheduledAt: job.scheduled_at }, at)) {
// Ficou na fila muito tempo (painel fechado ou rede esperando): volta para a agenda em vez de sair em rajada.
placeApproved(job.id, { from: ["queued"], reflow: true });
continue;
}
const key = `${job.account_id}|${job.platform}`;
if (busy.has(key) || sent >= MAX_SENDS_PER_TICK) { setStep("Esperando o envio anterior terminar."); continue; }
if (job.source_kind === "clip") {
// Corte: só o vídeo FINAL vai para as redes (doc/clipador/REVISAO.md). Relê no Clipador na hora de enviar e,
// sem final pronto, espera — nunca manda o vídeo de revisão (com as camadas de teste).
const target = await clipFinalForJob(job);
if ("wait" in target) { setStep(target.wait); continue; }
if (target.file !== job.file || (target.cover && target.cover !== job.cover)) {
run("UPDATE publish_jobs SET file = ?, cover = COALESCE(?, cover), updated_at = ? WHERE id = ? AND status = 'queued'",
target.file, target.cover, now(), job.id);
job.file = target.file;
if (target.cover) job.cover = target.cover;
}
}
// O Publicador só aceita arquivos dentro de output/, stories/ ou assets/ (as mesmas pastas que o painel serve).
const file = resolveInside(job.file, SERVABLE_ROOTS);
if (!file || !fs.existsSync(file)) {
run("UPDATE publish_jobs SET status = 'failed', error = ?, updated_at = ? WHERE id = ? AND status = 'queued'",
file ? `Arquivo do vídeo não encontrado: ${job.file}` : `O vídeo precisa estar em output/, stories/ ou assets/ (está em ${job.file}).`,
now(), job.id);
continue;
}
// Capa fora dessas pastas (ou sumida) não impede o envio: vai sem capa.
const coverPath = job.cover ? resolveInside(job.cover, SERVABLE_ROOTS) : null;
const cover = coverPath && fs.existsSync(coverPath) ? coverPath : null;
const account = get<Account>("SELECT * FROM accounts WHERE id = ?", job.account_id);
if (!account || !network) continue;
const usesPersonaVoice = job.source_kind === "episode" && account.ai_label === "auto" ? episodeUsesPersonaVoice(Number(job.source_id)) : false;
let remote: PublisherJob;
try {
remote = await createJob({
profileId: profileIdFor(job.account_id, job.platform), platform: job.platform, file, cover,
title: job.title.slice(0, 100), caption: job.caption.slice(0, 2200), tags: tagsFromCaption(job.caption),
// Corte de live não é conteúdo feito com IA (pedido do dono, 17/11/2026): nunca leva o rótulo, nem com "sempre".
privacy: network.privacy, publishAt: null,
aiGenerated: job.source_kind === "clip" ? false : aiGeneratedFor(account.ai_label, usesPersonaVoice),
madeForKids: false, tiktokMode: network.tiktok_mode, clientRef: clientRefFor(job.id, job.attempts),
});
} catch (error) {
if (error instanceof ServiceError && error.status >= 503) {
// Fora do ar ou sem resposta (pode ter criado!): fica na fila; o reenvio usa o mesmo clientRef.
setStep("Esperando: o Publicador não está rodando ou não respondeu — inicie com pnpm dev.");
return;
}
if (error instanceof ServiceError && (error.status === 401 || error.status === 403 || error.status === 404)) {
// Chave errada, rota inexistente (versão antiga do Publicador): problema de instalação, não do vídeo.
setStep(`Esperando: o Publicador está indisponível ou mal configurado (${error.status}: ${error.message}).`);
logChange("Publicador", `indisponível ou mal configurado (${error.status}: ${error.message})`);
return;
}
if (error instanceof ServiceError && error.status === 409) {
// Perfil não está `connected` no Publicador: espelha o estado real e o job continua esperando.
await refreshNetwork(job.account_id, job.platform).catch((e: unknown) => logChange(`perfil ${key}`, errorText(e)));
setStep(`Esperando: ${error.message}`);
continue;
}
if (error instanceof ServiceError && error.status < 500) {
// Pedido recusado pelo Publicador (arquivo, título, data…): falha com a mensagem dele. Nada foi criado lá.
run("UPDATE publish_jobs SET status = 'failed', error = ?, updated_at = ? WHERE id = ? AND status = 'queued'", error.message, now(), job.id);
continue;
}
throw error; // 5xx do Publicador: fica na fila (mesmo clientRef no próximo ciclo)
}
const changed = run(`UPDATE publish_jobs SET status = 'publishing', publisher_job_id = ?, step = ?, progress = ?, error = NULL, updated_at = ?
WHERE id = ? AND status = 'queued' AND publisher_job_id IS NULL`,
remote.jobId, remote.step || "Enviado ao Publicador.", remote.progress ?? 0, now(), job.id).changes;
if (changed === 0) {
// Cancelado (ou mudado) enquanto o Publicador criava o envio: desfaz lá.
let undone = false;
try {
undone = (await cancelJob(remote.jobId)).status === "canceled";
} catch (error) {
logChange(`job ${job.id}`, `não deu para cancelar o envio ${remote.jobId} no Publicador: ${errorText(error)}`);
}
if (!undone) {
// O envio seguiu lá: volta a acompanhar de verdade (nunca fingir que foi cancelado).
run(`UPDATE publish_jobs SET status = 'publishing', publisher_job_id = ?, cancel_reason = NULL,
step = 'Você cancelou, mas o envio já tinha começado no Publicador.', updated_at = ? WHERE id = ?`, remote.jobId, now(), job.id);
}
continue;
}
busy.add(key);
sent++;
}
}
// O laço do despachante é ligado uma vez só (instrumentation.ts) e guarda a função do ciclo daquele momento. No
// `pnpm dev`, o código recarregado (HMR) chega às rotas mas NÃO ao laço — que seguiria com a versão antiga das regras.
// Toda vez que este módulo é carregado de novo, a versão nova se registra no laço que já está rodando.
{
const state = dispatcherState();
if (state.tick && state.tick !== dispatcherTick) state.tick = dispatcherTick;
}
/** Plataformas válidas (para as rotas). */
export function mustPlatform(platform: string): Platform {
if (!PLATFORMS.includes(platform as Platform)) throw new UserError("Rede social inválida.");
return platform as Platform;
}