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>
1176 lines
66 KiB
TypeScript
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;
|
|
}
|