@praeko/cli 0.0.0-stage → 0.1.1

package/dist/chunks/chunk-Z325UM27.mjs

@@ -0,0 +1,34 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+
+// ../core/src/contrato.mjs
+var REDES = { yt: "youtube", youtube: "youtube", ig: "instagram", instagram: "instagram", tt: "tiktok", tiktok: "tiktok" };
+var REDES_VALIDAS = ["youtube", "instagram", "tiktok"];
+var MODOS = { youtube: ["privado", "agendado", "publico"], tiktok: ["rascunho", "direto"], instagram: ["agora"] };
+var PROVEDORES = ["buffer", "local", "remoto"];
+function validarPedido(p) {
+  const e = [];
+  if (!p || typeof p !== "object") return ["pedido vazio"];
+  if (!p.midia?.video) e.push("midia.video \xE9 obrigat\xF3rio");
+  if (!p.titulo && !p.textos?.youtube?.titulo) e.push("falta o t\xEDtulo");
+  if (!Array.isArray(p.destinos) || !p.destinos.length) e.push("destinos vazio");
+  for (const d of p.destinos || []) {
+    if (!REDES_VALIDAS.includes(d.rede)) {
+      e.push(`rede desconhecida: ${d.rede}`);
+      continue;
+    }
+    if (!p.textos?.[d.rede]?.texto) e.push(`falta textos.${d.rede}.texto`);
+    if (d.quando != null && Number.isNaN(Date.parse(d.quando))) e.push(`${d.rede}: quando inv\xE1lido (${d.quando})`);
+    if (d.midia != null && (typeof d.midia !== "object" || Array.isArray(d.midia) || ["video", "capa"].some((k) => d.midia[k] != null && typeof d.midia[k] !== "string"))) e.push(`${d.rede}: midia do destino precisa ser { video?: <id>, capa?: <id> }`);
+    if (d.modo && !MODOS[d.rede].includes(d.modo)) e.push(`${d.rede}: modo "${d.modo}" inv\xE1lido (use ${MODOS[d.rede].join(", ")})`);
+  }
+  const todos = JSON.stringify(p.textos || {});
+  const marc = [...new Set(todos.match(/\[[A-Z][A-Z_]{3,}\]/g) || [])];
+  if (marc.length) e.push(`texto com marcador n\xE3o preenchido: ${marc.join(", ")}`);
+  return e;
+}
+
+export {
+  REDES,
+  PROVEDORES,
+  validarPedido
+};

package/dist/chunks/chunk-ZZKGFOPH.mjs

@@ -0,0 +1,415 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  caminhoEstado,
+  caminhoLeitura,
+  pastaEstado
+} from "./chunk-TTGQU5CG.mjs";
+import {
+  segredos
+} from "./chunk-QDZLRBTP.mjs";
+import {
+  validarPedido
+} from "./chunk-Z325UM27.mjs";
+import {
+  __export
+} from "./chunk-LCFK6X55.mjs";
+
+// ../core/src/adaptadores/buffer.mjs
+var buffer_exports = {};
+__export(buffer_exports, {
+  REF_CHAVE: () => REF_CHAVE,
+  criar: () => criar
+});
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+
+// ../core/src/hospedagem.mjs
+import { randomBytes } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { basename } from "node:path";
+var tipo = (arq) => /\.mp4$/i.test(arq) ? "video/mp4" : /\.mov$/i.test(arq) ? "video/quicktime" : "application/octet-stream";
+function chaveObjeto(slug, arquivo, aleatorio = randomBytes(8).toString("hex")) {
+  return `${slug}/${aleatorio}/${basename(arquivo)}`;
+}
+function configHospedagem(config) {
+  const h = config.hospedagem;
+  if (!h) throw new Error('sem hospedagem: defina em praeko.json "hospedagem": { "tipo": "r2", "bucket": "...", "urlBase": "https://..." } ou passe --url');
+  if (h.tipo !== "r2") throw new Error(`hospedagem "${h.tipo}" n\xE3o suportada (use "r2")`);
+  if (!h.bucket || !/^https:\/\//.test(h.urlBase || "")) throw new Error("hospedagem r2 precisa de bucket e urlBase https://");
+  return h;
+}
+function subir({ h, slug, arquivo, cwd, rodar = spawnSync }) {
+  const chave = chaveObjeto(slug, arquivo);
+  const r = rodar("npx", ["--yes", "wrangler@4", "r2", "object", "put", `${h.bucket}/${chave}`, "--file", arquivo, "--content-type", tipo(arquivo), "--remote"], { cwd, stdio: "inherit" });
+  if (r.status !== 0) throw new Error("wrangler n\xE3o conseguiu subir o arquivo (voc\xEA fez `npx wrangler login`?)");
+  return { url: `${h.urlBase.replace(/\/$/, "")}/${chave}`, chave };
+}
+function apagar({ h, chave, cwd, rodar = spawnSync }) {
+  const r = rodar("npx", ["--yes", "wrangler@4", "r2", "object", "delete", `${h.bucket}/${chave}`, "--remote"], { cwd, stdio: "inherit" });
+  return r.status === 0;
+}
+
+// ../core/src/capa-quadro.mjs
+var capa_quadro_exports = {};
+__export(capa_quadro_exports, {
+  argsFfmpeg: () => argsFfmpeg,
+  dimensoesImagem: () => dimensoesImagem,
+  embutirCapa: () => embutirCapa,
+  mesmaProporcao: () => mesmaProporcao,
+  sondar: () => sondar
+});
+import { spawnSync as spawnSync2 } from "node:child_process";
+var num = (s) => {
+  const [a, b] = String(s).split("/").map(Number);
+  return b ? a / b : a;
+};
+function sondar(arq, rodar = spawnSync2) {
+  const r = rodar("ffprobe", ["-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height,r_frame_rate", "-show_entries", "format=duration", "-of", "json", arq], { encoding: "utf8" });
+  if (r.status !== 0) throw new Error(`ffprobe falhou em ${arq}`);
+  const j = JSON.parse(r.stdout), s = j.streams[0];
+  return { largura: s.width, altura: s.height, fps: num(s.r_frame_rate), duracao: +j.format.duration };
+}
+function dimensoesImagem(arq, rodar = spawnSync2) {
+  const r = rodar("ffprobe", ["-v", "error", "-show_entries", "stream=width,height", "-of", "json", arq], { encoding: "utf8" });
+  if (r.status !== 0) throw new Error(`ffprobe falhou em ${arq}`);
+  const s = JSON.parse(r.stdout).streams[0];
+  return { largura: s.width, altura: s.height };
+}
+var mesmaProporcao = (a, b) => Math.abs(a.largura / a.altura - b.largura / b.altura) < 0.02 * (b.largura / b.altura);
+function argsFfmpeg({ video, capa, saida, largura, altura, quadros = 2, duracao = 3600, fps = 30 }) {
+  const filtro = `[1:v]scale=${largura}:${altura}:force_original_aspect_ratio=increase,crop=${largura}:${altura},setsar=1,format=yuv420p[c];[0:v][c]overlay=enable='lt(n,${quadros})':format=auto,format=yuv420p[v]`;
+  return ["-v", "error", "-y", "-i", video, "-loop", "1", "-framerate", String(fps), "-t", String(duracao + 1), "-i", capa, "-filter_complex", filtro, "-map", "[v]", "-map", "0:a?", "-c:v", "libx264", "-crf", "16", "-preset", "medium", "-c:a", "copy", "-movflags", "+faststart", "-t", String(duracao), saida];
+}
+function embutirCapa({ video, capa, saida, quadros = 2, rodar = spawnSync2 }) {
+  const v = sondar(video, rodar), c = dimensoesImagem(capa, rodar);
+  if (!mesmaProporcao(c, v)) throw new Error(`a capa (${c.largura}x${c.altura}) n\xE3o tem a propor\xE7\xE3o do v\xEDdeo (${v.largura}x${v.altura})`);
+  const r = rodar("ffmpeg", argsFfmpeg({ video, capa, saida, largura: v.largura, altura: v.altura, quadros, duracao: v.duracao, fps: v.fps }), { stdio: "inherit" });
+  if (r.status !== 0) throw new Error("ffmpeg falhou ao colar a capa");
+  const d = sondar(saida, rodar);
+  if (Math.abs(d.duracao - v.duracao) > 0.1) throw new Error(`a dura\xE7\xE3o mudou (${v.duracao.toFixed(2)} s \u2192 ${d.duracao.toFixed(2)} s); abortei`);
+  return { saida, quadros };
+}
+
+// ../core/src/config.mjs
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+var ARQUIVOS_CONFIG = ["praeko.json", "arauto.json", "marca.json"];
+function normalizarConfig(bruto = {}) {
+  if (bruto.publicacao && typeof bruto.publicacao === "object") {
+    const { publicacao, links, nome, handle } = bruto;
+    return { nome, handle, links, ...publicacao };
+  }
+  return { ...bruto };
+}
+function acharConfig(de = process.cwd()) {
+  let d = resolve(de);
+  for (; ; ) {
+    for (const nome of ARQUIVOS_CONFIG) {
+      const f = join(d, nome);
+      if (existsSync(f)) return { raiz: d, arquivo: f, config: normalizarConfig(JSON.parse(readFileSync(f, "utf8"))) };
+    }
+    const p = dirname(d);
+    if (p === d) return null;
+    d = p;
+  }
+}
+
+// ../core/src/contexto.mjs
+function criarContexto({ config, raiz = process.cwd(), log = console.log, fetchFn = globalThis.fetch, segredos: segredos2 = segredos, agora = () => /* @__PURE__ */ new Date() } = {}) {
+  const h = () => configHospedagem(config);
+  return {
+    config,
+    raiz,
+    log,
+    fetchFn,
+    segredos: segredos2,
+    agora,
+    /** Sobe um arquivo para a hospedagem pública temporária (R2). Devolve { url, chave }. */
+    hospedar: async (arquivo, slug = "midia") => subir({ h: h(), slug, arquivo, cwd: raiz }),
+    removerHospedado: async (chave) => apagar({ h: h(), chave, cwd: raiz })
+  };
+}
+
+// ../core/src/index.mjs
+var PADRAO = {
+  utm: { instagram: ["instagram", "bio"], youtube: ["youtube", "short"], tiktok: ["tiktok", "bio"] },
+  limites: { youtubeTitulo: 100, youtubeDescricao: 5e3, instagram: 2200, tiktok: 2200, hashtagsInstagram: 30 },
+  hashtagsProibidas: [],
+  // marcas de texto escrito por IA (a skill copywriting do projeto proíbe)
+  marcasDeIA: [
+    { re: /\bnão é [^.!?]{1,45}, é\s/i, aviso: 'estrutura "n\xE3o \xE9 X, \xE9 Y"' },
+    { re: /\bsem [^,.!?]{1,25}, sem [^,.!?]{1,25}, sem\b/i, aviso: 'lista "sem X, sem Y, sem Z"' }
+  ]
+};
+function link(config, { plataforma, destino = "jogo", campanha, formato }) {
+  const base = config.links?.[destino];
+  if (!base) throw new Error(`links.${destino} n\xE3o definido na configura\xE7\xE3o (praeko.json)`);
+  const u = { ...PADRAO.utm, ...config.utm || {} };
+  let [fonte, midia] = u[plataforma] || [plataforma, "bio"];
+  if (plataforma === "youtube" && formato) midia = formato === "longo" ? "long" : formato;
+  const q = new URLSearchParams({ utm_source: fonte, utm_medium: midia });
+  if (campanha) q.set("utm_campaign", campanha);
+  return `${base}${base.includes("?") ? "&" : "?"}${q.toString()}`;
+}
+var tags = (l) => (l || []).join(" ");
+var mmss = (s) => {
+  const t = Math.round(s), h = Math.floor(t / 3600), m = Math.floor(t % 3600 / 60), x = t % 60;
+  return h ? `${h}:${String(m).padStart(2, "0")}:${String(x).padStart(2, "0")}` : `${m}:${String(x).padStart(2, "0")}`;
+};
+var capitulos = (lista) => lista.map((c) => `${mmss(c.t)} ${c.titulo}`).join("\n");
+function validarCapitulos(lista) {
+  const e = [];
+  if (!lista?.length) return e;
+  if (lista.length < 3) e.push(`${lista.length} cap\xEDtulo(s): o YouTube s\xF3 cria cap\xEDtulos com 3 ou mais`);
+  if (Math.round(lista[0].t) !== 0) e.push("o primeiro cap\xEDtulo precisa come\xE7ar em 0:00");
+  for (let i = 1; i < lista.length; i++) if (lista[i].t - lista[i - 1].t < 10) e.push(`cap\xEDtulo "${lista[i - 1].titulo}" dura ${(lista[i].t - lista[i - 1].t).toFixed(1)} s (m\xEDnimo 10 s)`);
+  return e;
+}
+function validar({ config, ep }) {
+  const L = { ...PADRAO.limites, ...config.limites || {} };
+  const proibidas = [...PADRAO.hashtagsProibidas, ...config.hashtags?.proibidas || []].map((h) => h.toLowerCase());
+  const permitidas = (config.hashtags?.permitidas || []).map((h) => h.toLowerCase());
+  const erros = [], avisos = [];
+  const yt = `${ep.yt?.descricao || ""}
+${ep.capitulos ? capitulos(ep.capitulos) : ""}
+${tags(ep.hashtags?.youtube)}`;
+  for (const x of validarCapitulos(ep.capitulos)) erros.push(`cap\xEDtulos: ${x}`);
+  if ((ep.titulo || "").length > L.youtubeTitulo) erros.push(`t\xEDtulo com ${ep.titulo.length} caracteres (limite ${L.youtubeTitulo})`);
+  if (yt.length > L.youtubeDescricao) erros.push(`descri\xE7\xE3o do YouTube com ${yt.length} caracteres (limite ${L.youtubeDescricao})`);
+  const ig = `${ep.ig?.legenda || ""}
+${tags(ep.hashtags?.instagram)}`;
+  if (ig.length > L.instagram) erros.push(`legenda do Instagram com ${ig.length} caracteres (limite ${L.instagram})`);
+  const tk = `${ep.tiktok?.legenda || ""}
+${tags(ep.hashtags?.tiktok)}`;
+  if (tk.length > L.tiktok) avisos.push(`legenda do TikTok com ${tk.length} caracteres (limite sugerido ${L.tiktok})`);
+  if ((ep.hashtags?.instagram || []).length > L.hashtagsInstagram) erros.push(`mais de ${L.hashtagsInstagram} hashtags no Instagram`);
+  for (const [pl, hs] of Object.entries(ep.hashtags || {})) for (const h of hs) {
+    if (proibidas.includes(h.toLowerCase())) erros.push(`hashtag proibida em ${pl}: ${h}`);
+    else if (permitidas.length && !permitidas.includes(h.toLowerCase())) avisos.push(`hashtag fora da lista permitida em ${pl}: ${h}`);
+  }
+  const tudo = [ep.titulo, ...ep.alternativas || [], ep.yt?.descricao, ep.ig?.legenda, ep.ig?.comentarioFixo, ep.tiktok?.legenda, ep.respostaComentario].filter(Boolean).join("\n");
+  for (const m of PADRAO.marcasDeIA) if (m.re.test(tudo)) avisos.push(`marca de texto de IA: ${m.aviso}`);
+  return { erros, avisos };
+}
+
+// ../core/src/buffer-api.mjs
+var ENDPOINT = "https://api.buffer.com";
+var ANTECEDENCIA_MIN_MS = 5 * 6e4;
+async function gql(consulta, variaveis, { chave, fetchFn = fetch } = {}) {
+  if (!chave) throw new Error("sem chave do Buffer (PRAEKO_KEY_BUFFER_PRINCIPAL, Chaveiro do macOS ou `praeko agendar --chave`)");
+  const r = await fetchFn(ENDPOINT, { method: "POST", headers: { "content-type": "application/json", authorization: `Bearer ${chave}` }, body: JSON.stringify({ query: consulta, variables: variaveis || {} }) });
+  const txt = await r.text();
+  let j;
+  try {
+    j = JSON.parse(txt);
+  } catch {
+    throw new Error(`Buffer respondeu ${r.status}: ${txt.slice(0, 200)}`);
+  }
+  if (!r.ok || j.errors?.length) throw new Error(`Buffer: ${(j.errors || []).map((e) => e.message).join("; ") || r.status}`);
+  return j.data;
+}
+var Q_CANAIS = `query { account { organizations { id name } } }`;
+var Q_CANAIS_ORG = `query($org: OrganizationId!) { channels(input: { organizationId: $org }) { id name displayName service avatar isQueuePaused } }`;
+async function listarCanais(op) {
+  const d = await gql(Q_CANAIS, {}, op);
+  const lista = [];
+  for (const o of d.account.organizations) {
+    const c = await gql(Q_CANAIS_ORG, { org: o.id }, op);
+    for (const x of c.channels) lista.push({ id: x.id, nome: x.displayName || x.name, servico: x.service, avatar: x.avatar || null, org: o.name, pausado: !!x.isQueuePaused });
+  }
+  return lista;
+}
+var M_CRIAR = `mutation($input: CreatePostInput!) { createPost(input: $input) { ... on PostActionSuccess { post { id dueAt } } ... on MutationError { message } } }`;
+var M_APAGAR = `mutation($id: PostId!) { deletePost(input: { id: $id }) { ... on DeletePostSuccess { __typename } ... on MutationError { message } } }`;
+async function criarPost(input, op) {
+  const d = await gql(M_CRIAR, { input }, op);
+  const r = d.createPost;
+  if (r.message) throw new Error(`Buffer recusou o post: ${r.message}`);
+  return r.post;
+}
+async function apagarPost(id, op) {
+  const d = await gql(M_APAGAR, { id }, op);
+  if (d.deletePost?.message) throw new Error(`Buffer n\xE3o apagou ${id}: ${d.deletePost.message}`);
+  return true;
+}
+
+// ../core/src/buffer.mjs
+var tags2 = (l) => (l || []).join(" ");
+function parseQuando(txt, { fuso = "-03:00", agora = /* @__PURE__ */ new Date() } = {}) {
+  const s = String(txt).trim();
+  let m = s.match(/^(\d{1,2})\/(\d{1,2})(?:\/(\d{4}))?[ T]+(\d{1,2}):(\d{2})$/);
+  let iso;
+  if (m) {
+    let ano = m[3] ? +m[3] : agora.getFullYear();
+    const mk = (a) => `${a}-${String(m[2]).padStart(2, "0")}-${String(m[1]).padStart(2, "0")}T${String(m[4]).padStart(2, "0")}:${m[5]}:00${fuso}`;
+    iso = mk(ano);
+    if (!m[3] && new Date(iso) < agora) iso = mk(ano + 1);
+  } else if (/^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(:\d{2})?$/.test(s)) iso = s.replace(" ", "T") + (s.length === 16 ? ":00" : "") + fuso;
+  else if (/^\d{4}-\d{2}-\d{2}T[\d:.]+(Z|[+-]\d{2}:\d{2})$/.test(s)) iso = s;
+  else throw new Error(`data inv\xE1lida: "${txt}" (use "06/11 17:30", "06/11/2026 17:30" ou "2026-11-06T17:30")`);
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) throw new Error(`data inv\xE1lida: "${txt}"`);
+  return d.toISOString();
+}
+var privacidadeBuffer = (modo, padrao) => modo === "privado" ? "private" : modo === "publico" || modo === "agendado" ? void 0 : padrao;
+function textosPorRede({ config, ep }) {
+  const lk = (plataforma) => link(config, { plataforma, campanha: ep.campanha, formato: ep.formato || "short" });
+  const longo = ep.formato === "longo";
+  const yt = [ep.yt?.descricao || ""];
+  if (ep.capitulos?.length) yt.push("", "\u23F1 Cap\xEDtulos", capitulos(ep.capitulos));
+  if (!longo && ep.artigo) yt.push("", `\u{1F4D6} Artigo completo: ${ep.artigo}`);
+  if (!longo && ep.videoCompleto) yt.push(`\u25B6\uFE0F Completo: ${ep.videoCompleto}`);
+  yt.push("", `\u{1F517} O jogo: ${lk("youtube")}`, "", tags2(ep.hashtags?.youtube));
+  return {
+    youtube: { titulo: ep.titulo, texto: yt.join("\n").trim(), comentarioFixo: ep.yt?.comentarioFixo },
+    instagram: { texto: `${ep.ig?.legenda || ""}${ep.hashtags?.instagram ? " " + tags2(ep.hashtags.instagram) : ""}`.trim(), comentarioFixo: ep.ig?.comentarioFixo },
+    tiktok: { texto: `${ep.tiktok?.legenda || ep.ig?.legenda || ""}${ep.hashtags?.tiktok ? " " + tags2(ep.hashtags.tiktok) : ""}`.trim() }
+  };
+}
+function montarPosts({ config, ep, textos, modos = {}, canais, videoUrl, quando, redes = ["youtube", "instagram", "tiktok"], lembrete = false, miniaturaMs }) {
+  const t = textos || textosPorRede({ config, ep });
+  const cfg = config.buffer || {};
+  const miniatura = miniaturaMs ?? cfg.miniaturaMs ?? 1e3;
+  const base = (rede) => ({
+    channelId: canais[rede],
+    schedulingType: lembrete ? "notification" : "automatic",
+    mode: "customScheduled",
+    dueAt: quando[rede] || quando.todas,
+    needsApproval: false,
+    source: "arauto",
+    assets: [{ video: { url: videoUrl, metadata: rede === "youtube" ? void 0 : { thumbnailOffset: miniatura } } }]
+  });
+  const out = [];
+  for (const rede of redes) {
+    if (!t[rede]) throw new Error(`rede desconhecida: ${rede}`);
+    const p = { ...base(rede), text: t[rede].texto };
+    if (rede === "youtube") {
+      p.metadata = { youtube: { title: t.youtube.titulo, madeForKids: false, notifySubscribers: cfg.youtube?.avisarInscritos ?? true, categoryId: String(cfg.youtube?.categoriaId ?? "28"), ...privacidadeBuffer(modos.youtube, cfg.youtube?.privacidade) ? { privacy: privacidadeBuffer(modos.youtube, cfg.youtube?.privacidade) } : {} } };
+    } else if (rede === "instagram") {
+      p.metadata = { instagram: { type: "reel", shouldShareToFeed: true, ...cfg.primeiroComentario && t.instagram.comentarioFixo ? { firstComment: t.instagram.comentarioFixo } : {} } };
+    } else p.metadata = { tiktok: {} };
+    if (!p.dueAt) throw new Error(`sem hor\xE1rio para ${rede}`);
+    out.push({ rede, input: JSON.parse(JSON.stringify(p)) });
+  }
+  return out;
+}
+function escolherCanais({ config, canais, redes }) {
+  const cfg = config.buffer?.canais || {};
+  const saida = {}, faltam = [];
+  for (const r of redes) {
+    if (cfg[r]) {
+      saida[r] = cfg[r];
+      continue;
+    }
+    const ach = canais.filter((c) => c.servico === r);
+    if (ach.length === 1) saida[r] = ach[0].id;
+    else faltam.push(ach.length ? `${r}: ${ach.length} canais (${ach.map((c) => `${c.nome}=${c.id}`).join(", ")}); fixe um em buffer.canais.${r} (praeko.json)` : `${r}: nenhum canal conectado no Buffer`);
+  }
+  return { canais: saida, faltam };
+}
+
+// ../core/src/adaptadores/buffer.mjs
+import { randomBytes as randomBytes2 } from "node:crypto";
+var REF_CHAVE = "buffer/principal";
+function criar({ config, ctx }) {
+  const arq = caminhoEstado(ctx.raiz, "buffer.json"), arqLeitura = () => caminhoLeitura(ctx.raiz, "buffer.json");
+  const ler = () => existsSync2(arqLeitura()) ? JSON.parse(readFileSync2(arqLeitura(), "utf8")) : { pedidos: {} };
+  const gravar = (r) => {
+    mkdirSync(pastaEstado(ctx.raiz), { recursive: true });
+    writeFileSync(arq, JSON.stringify(r, null, 2) + "\n");
+  };
+  const op = () => {
+    const chave = ctx.segredos.obter(REF_CHAVE);
+    if (!chave) throw new Error("sem chave do Buffer: `echo $CHAVE | praeko agendar --chave` (publish.buffer.com/settings/api)");
+    return { chave, fetchFn: ctx.fetchFn };
+  };
+  const cq = ctx.deps?.capaQuadro || capa_quadro_exports;
+  return {
+    nome: "buffer",
+    async publicar(pedido) {
+      const erros = validarPedido(pedido);
+      if (erros.length) throw new Error(`pedido inv\xE1lido: ${erros.join("; ")}`);
+      const sem = pedido.destinos.filter((d) => !d.quando).map((d) => d.rede);
+      if (sem.length) throw new Error(`o Buffer precisa de hor\xE1rio (falta em ${sem.join(", ")})`);
+      const id = pedido.id || `p${randomBytes2(3).toString("hex")}`, reg = ler();
+      const redes = pedido.destinos.map((d) => d.rede), quando = Object.fromEntries(pedido.destinos.map((d) => [d.rede, d.quando]));
+      const modos = Object.fromEntries(pedido.destinos.filter((d) => d.modo).map((d) => [d.rede, d.modo]));
+      const o = op();
+      const { canais, faltam } = escolherCanais({ config, canais: await listarCanais(o), redes });
+      if (faltam.length) throw new Error(faltam.join("\n"));
+      let videoUrl = pedido.opcoes?.videoUrl, chaveObjeto2, arquivo = pedido.midia.video, capaEmbutida = false;
+      const previo = reg.pedidos[id];
+      if (!videoUrl && previo?.videoUrl) {
+        videoUrl = previo.videoUrl;
+        chaveObjeto2 = previo.chaveObjeto;
+      }
+      if (!videoUrl) {
+        const capa = pedido.midia.capa;
+        if (capa && pedido.opcoes?.capaNoQuadro !== false && pedido.opcoes?.formato !== "longo") {
+          const v = cq.sondar(arquivo), c = cq.dimensoesImagem(capa);
+          if (cq.mesmaProporcao(c, v)) {
+            const saida = caminhoEstado(ctx.raiz, `${id}.capa.mp4`);
+            mkdirSync(pastaEstado(ctx.raiz), { recursive: true });
+            cq.embutirCapa({ video: arquivo, capa, saida });
+            arquivo = saida;
+            capaEmbutida = true;
+          }
+        }
+        const s = await ctx.hospedar(arquivo, id);
+        videoUrl = s.url;
+        chaveObjeto2 = s.chave;
+      }
+      const posts = montarPosts({ config, textos: pedido.textos, modos, canais, videoUrl, quando, redes, lembrete: !!pedido.opcoes?.lembrete, ...capaEmbutida ? { miniaturaMs: 0 } : {} });
+      const r = reg.pedidos[id] = { id, titulo: pedido.titulo, videoUrl, chaveObjeto: chaveObjeto2, criadoEm: (/* @__PURE__ */ new Date()).toISOString(), posts: previo?.posts || [] };
+      for (const x of posts) {
+        try {
+          const p = await criarPost(x.input, o);
+          r.posts.push({ rede: x.rede, id: p.id, dueAt: x.input.dueAt, canalId: x.input.channelId });
+          gravar(reg);
+        } catch (e) {
+          gravar(reg);
+          throw new Error(`${x.rede}: ${e.message} (j\xE1 criado: ${r.posts.map((q) => q.rede).join(", ") || "nada"})`);
+        }
+      }
+      return { id, itens: r.posts.map((p) => ({ rede: p.rede, id: p.id, estado: "agendado", quando: p.dueAt })) };
+    },
+    async status(id) {
+      const p = ler().pedidos[id];
+      if (!p) throw new Error(`pedido ${id} n\xE3o existe`);
+      return { id, itens: p.posts.map((x) => ({ rede: x.rede, id: x.id, estado: "agendado", quando: x.dueAt })) };
+    },
+    async cancelar(id, { redes } = {}) {
+      const reg = ler(), p = reg.pedidos[id];
+      if (!p) throw new Error(`pedido ${id} n\xE3o existe`);
+      const o = op(), cancelados = [], mantidos = [];
+      for (const x of p.posts) {
+        if (!redes || redes.includes(x.rede)) {
+          await apagarPost(x.id, o);
+          cancelados.push(x.id);
+        } else mantidos.push(x.id);
+      }
+      p.posts = p.posts.filter((x) => !cancelados.includes(x.id));
+      if (!p.posts.length) {
+        if (p.chaveObjeto && ctx.removerHospedado) await ctx.removerHospedado(p.chaveObjeto);
+        delete reg.pedidos[id];
+      }
+      gravar(reg);
+      return { cancelados, mantidos };
+    },
+    async canais() {
+      return (await listarCanais(op())).map((c) => ({ rede: c.servico, id: c.id, conectado: true, detalhe: `${c.nome} [${c.org}]${c.pausado ? " (fila pausada)" : ""}` }));
+    }
+  };
+}
+
+export {
+  parseQuando,
+  textosPorRede,
+  capa_quadro_exports,
+  normalizarConfig,
+  acharConfig,
+  criarContexto,
+  REF_CHAVE,
+  criar,
+  buffer_exports,
+  validar
+};