// 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(`${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( `${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; 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("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("SELECT * FROM publish_jobs WHERE id = ?", jobId); if (!job || !opts.from.includes(job.status)) return false; const account = get("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 & { 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 { 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 { 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 { 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 { 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 { 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 = { 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 { const map = raw && typeof raw === "object" && !Array.isArray(raw) ? raw as Record : {}; const times = new Map(); 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 { if (!Number.isInteger(clipId) || clipId <= 0) throw new UserError("Corte inválido."); const account = get("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("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( "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("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) => 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("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 { 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("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 }).__cenaforgeProfileRefresh ??= new Map()); /** Um ciclo: perfis → cortes → episódios → vencidos → acompanhar envios → enviar. Cada parte falha sozinha. */ export async function dispatcherTick(): Promise { const state = dispatcherState(); const errors: string[] = []; const step = async (topic: string, fn: () => Promise | 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 { if (!(await publisherStatus()).online) return false; for (const n of all("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 { 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--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//` 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 { keepClipCovers(); const targets: ClipTarget[] = all>( `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("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( "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): Promise { // Aprovar no Clipador primeiro: se falhar, os jobs "aprovados" desse corte esperam o próximo ciclo. const failedApprovals = new Set(); 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): 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): 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(`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("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 { for (const job of all("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): 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//.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 (":"), * que o Publicador reconhece e devolve o envio existente em vez de criar outro. */ async function sendDue(): Promise { const settings = getSettings(); const at = new Date(); const due = all("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("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("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; }