@praeko/cli 0.1.0 → 0.2.0

package/dist/praeko.mjs

@@ -1,11 +1,854 @@
 #!/usr/bin/env node
 import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
-import "./chunks/chunk-XQO6MI7C.mjs";
-import "./chunks/chunk-LLXYUCTT.mjs";
-import "./chunks/chunk-UK3UKRPR.mjs";
-import "./chunks/chunk-SAHLBARV.mjs";
-import "./chunks/chunk-IZEX746E.mjs";
-import "./chunks/chunk-6YARHJZ2.mjs";
-import "./chunks/chunk-QDZLRBTP.mjs";
-import "./chunks/chunk-Z325UM27.mjs";
+import {
+  trocarHashtags
+} from "./chunks/chunk-TDQGKU7I.mjs";
+import "./chunks/chunk-V3GB2IUZ.mjs";
+import {
+  acharConfig,
+  capa_quadro_exports,
+  criarContexto,
+  normalizarConfig,
+  parseQuando,
+  textosPorRede,
+  validar
+} from "./chunks/chunk-K5RD3QB7.mjs";
+import {
+  caminhoEstado,
+  cancelarItem,
+  criarPublicador,
+  executar,
+  lerFila,
+  liberarItem,
+  pastaEstado,
+  plistLaunchd
+} from "./chunks/chunk-SPELUAPP.mjs";
+import {
+  registro_exports
+} from "./chunks/chunk-SSYEOFS5.mjs";
+import {
+  Praeko,
+  migrar,
+  segredos
+} from "./chunks/chunk-FZ2EWUHA.mjs";
+import {
+  REDES,
+  validarPedido
+} from "./chunks/chunk-SL4UDIFM.mjs";
 import "./chunks/chunk-LCFK6X55.mjs";
+
+// src/main.ts
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { dirname, join as join3 } from "node:path";
+
+// src/cli.ts
+import { mkdirSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename as basename2, join as join2, resolve as resolve2 } from "node:path";
+import { execFileSync, spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+// ../core/src/chaves.ts
+var b64u = (u8) => {
+  let s = "";
+  for (const b of u8) s += String.fromCharCode(b);
+  return btoa(s).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+};
+var hex = (buf) => [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, "0")).join("");
+var PREFIXO_CHAVE = "praeko_";
+var FORMATO_CHAVE = /^(?:praeko|arauto)_[A-Za-z0-9_-]{20,}$/;
+var gerarChave = () => PREFIXO_CHAVE + b64u(crypto.getRandomValues(new Uint8Array(32)));
+var hashChave = async (chave2) => hex(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(chave2)));
+var prefixoChave = (chave2) => chave2.slice(0, 14);
+var idChave = () => "chv_" + hex(crypto.getRandomValues(new Uint8Array(8)));
+
+// src/pacote.ts
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+var ehDir = (p) => existsSync(p) && statSync(p).isDirectory();
+function acharPacote(arg, { raiz, config }) {
+  for (const c of [resolve(arg), join(raiz, config.pacotes || "pacotes", arg), config.pasta ? join(raiz, config.pasta, arg) : null]) if (c && ehDir(c)) return c;
+  throw new Error(`pacote "${arg}" n\xE3o encontrado (pasta com publicacao.json, v\xEDdeo e capa). Use um caminho ou --meta/--video/--capa`);
+}
+function lerPacote({ arg, flags: flags2, raiz, config }) {
+  const dir = arg ? acharPacote(arg, { raiz, config }) : null;
+  const metaArq = flags2.meta ? resolve(flags2.meta) : dir && join(dir, "publicacao.json");
+  if (!metaArq || !existsSync(metaArq)) throw new Error("sem publicacao.json (use uma pasta-pacote ou --meta arquivo.json)");
+  const meta = JSON.parse(readFileSync(metaArq, "utf8"));
+  const base = dir || resolve(metaArq, "..");
+  const achar = (nome, re) => {
+    if (nome && existsSync(join(base, nome))) return join(base, nome);
+    const l = readdirSync(base).filter((f) => re.test(f)).sort();
+    return l.length ? join(base, l[l.length - 1]) : null;
+  };
+  const video = flags2.video ? resolve(flags2.video) : achar(meta.arquivos?.video, /\.(mp4|mov)$/i);
+  const capa = flags2.cover ? resolve(flags2.cover) : achar(meta.arquivos?.capa, /(capa|cover|thumb).*\.(png|jpe?g)$/i);
+  if (!video || !existsSync(video)) throw new Error(`n\xE3o achei o v\xEDdeo (arquivos.video = ${meta.arquivos?.video || "?"}); use --video`);
+  return { dir: base, id: flags2.id || basename(base), meta, video, capa: capa && existsSync(capa) ? capa : null };
+}
+function montarPedido({ pacote, config, destinos, opcoes = {} }) {
+  const v = validar({ config, ep: pacote.meta });
+  const textos = textosPorRede({ config, ep: pacote.meta });
+  return {
+    erros: v.erros,
+    avisos: v.avisos,
+    pedido: { id: pacote.id, titulo: pacote.meta.titulo, midia: { video: pacote.video, capa: pacote.capa }, textos, destinos, opcoes: { ...opcoes, formato: pacote.meta.formato || "short" } }
+  };
+}
+
+// src/cli.ts
+var injetado = (extra) => extra?.praeko ?? extra?.arauto;
+var BIN = resolve2(fileURLToPath(import.meta.url), "..", "..", "bin", "praeko.mjs");
+var NOME = { youtube: "YouTube", instagram: "Instagram", tiktok: "TikTok" };
+var COM_VALOR = /* @__PURE__ */ new Set(["type", "sort", "direction", "limit", "when", "networks", "yt", "ig", "tt", "yt-mode", "tt-mode", "video", "cover", "meta", "instagram", "instagram-id", "id", "url", "via", "config", "minutes", "key", "server", "scope", "name", "timezone", "from", "to", "state", "tag", "channel", "max", "page", "title", "description-file", "swap-hashtags", "text", "buffer-id", "cover-media", "days", "day", "tt-privacy", "tt-frame", "code", "route", "method", "cursor", "key-id", "events", "idempotency-key"]);
+var FLAG_ALIAS = { quando: "when", redes: "networks", "modo-yt": "yt-mode", "modo-tt": "tt-mode", por: "via", enviar: "send", simular: "dry-run", etiqueta: "tag", estado: "state", canal: "channel", titulo: "title", "descricao-arquivo": "description-file", "trocar-hashtags": "swap-hashtags", texto: "text", "sem-resposta": "unanswered", ordem: "sort", direcao: "direction", limite: "limit", pagina: "page", comparar: "compare", dias: "days", dia: "day", servidor: "server", chave: "key", escopo: "scope", nome: "name", fuso: "timezone", de: "from", ate: "to", fila: "queue", rascunho: "draft", lembrete: "reminder", capa: "cover", "capa-midia": "cover-media", "privacidade-tt": "tt-privacy", "quadro-tt": "tt-frame", cancelar: "cancel", "sem-capa-no-quadro": "no-cover-in-frame", minutos: "minutes", tipo: "type", ajuda: "help" };
+var CMD_ALIAS = { postar: "post", agendar: "schedule", fila: "queue", conta: "account", canais: "channels", calendario: "calendar", vagas: "slots", "publicar-agora": "publish-now", "youtube-agendar": "youtube-schedule", "adotar-buffer": "adopt-buffer", importar: "import", conteudo: "content", seguidores: "followers", chave: "key", keys: "key", ajuda: "help" };
+var SUB_ALIAS = {
+  queue: { listar: "list", executar: "run", cancelar: "cancel", comentar: "comment", instalar: "install", remover: "remove" },
+  account: { conectar: "connect", desconectar: "disconnect", enviar: "send" },
+  youtube: { editar: "edit", comentarios: "comments", resolver: "resolve", reabrir: "reopen", responder: "reply" },
+  tiktok: { importar: "import", conectar: "connect", desconectar: "disconnect" },
+  key: { guardar: "store", criar: "create", listar: "list", revogar: "revoke", migrar: "migrate" }
+};
+var MODO_YT = { private: "privado", scheduled: "agendado", public: "publico" };
+var MODO_TT = { draft: "rascunho", direct: "direto" };
+var ESTADO = { fila: "queued", rascunho: "draft", enviado: "sent", erro: "error", cancelado: "canceled" };
+var ESCOPO = { leitura: "read", escrita: "write" };
+var ESCOPO_PT = { read: "leitura", write: "escrita" };
+var ORDEM = { recentes: "recent", reacoes: "reactions", comentarios: "comments", engajamento: "engagement", compartilhamentos: "shares", salvamentos: "saves", alcance: "reach", publicadoEm: "publishedAt" };
+var DIA = { dom: "sun", seg: "mon", ter: "tue", qua: "wed", qui: "thu", sex: "fri", sab: "sat" };
+var DIA_PT = Object.fromEntries(Object.entries(DIA).map(([k, v]) => [v, k]));
+var ESTADO_PT = { draft: "rascunho", scheduled: "agendado", sent: "enviado", error: "erro", canceled: "cancelado", private: "privado", queued: "fila" };
+var estadoPt = (e) => ESTADO_PT[e] ?? e;
+var AJUDA = `Praeko CLI (formerly "arauto"): personal publisher (YouTube, Instagram, TikTok)
+
+  post <folder|name> --when "06/11 17:30" [--networks yt,ig,tt] [--yt|--ig|--tt "time"]
+       [--yt-mode private|scheduled|public] [--tt-mode draft|direct] [--via local|buffer] [--send]
+       [--tt-privacy SELF_ONLY|PUBLIC_TO_EVERYONE|\u2026] [--tt-frame 1500]   (only with --server; direct public TikTok needs the app audit)
+                                  publishes through Praeko (queue + direct providers); without --send it only simulates
+  schedule <folder|name> \u2026        the same, through Buffer (--via buffer); schedule <name> --status | --cancel [--networks yt]
+                                  schedule --key: stores the Buffer key (echo $KEY | praeko schedule --key)
+  queue [list|run [--dry-run]|cancel <id>|comment <id>|install [--minutes N]|remove]     the local queue
+  account <youtube|instagram|tiktok> [connect|status]
+  channels [--via local|buffer]   what is connected
+
+Praeko service (Cloudflare; formerly Arauto), with --server https://praeko.app (or PRAEKO_SERVER, or "remoto": { "url" } in praeko.json) and the key in PRAEKO_KEY (ARAUTO_CHAVE still works):
+  post <package> --server URL [--queue | --when \u2026 | --draft] [--tag a,b] [--yt-mode \u2026] [--send]
+  posts [--state queued|draft|sent|error|canceled] [--channel yt] [--tag x] [--limit n]   lists the service posts
+  calendar [--from ISO] [--to ISO] [--channel yt]                          scheduled items and free slots
+  slots <network> [day time \u2026] [--timezone America/Sao_Paulo]              show or replace the weekly slots (e.g. slots youtube fri 17:30 sun 22:00)
+  publish-now <id> [--networks yt]                                         takes it out of the queue and publishes now
+  youtube videos [--max 20] | video <id>                                   the channel videos (private and scheduled included)
+  youtube edit <id> [--title T] [--description-file f.txt] [--swap-hashtags "#a #b"] [--send]
+                                                                           changes title/description (simulates; --send writes)
+  youtube comments [--video id] [--unanswered] [--max 20]                  comments still without your reply
+  youtube resolve|reopen <thread>                                          hides/restores a thread in the pending box (Praeko only)
+  youtube reply <thread> --text "\u2026" [--send]                               replies to a comment (simulates; --send writes)
+  adopt-buffer --id name --title "\u2026" --when "07/11 10:00" --buffer-id <Buffer post>   shows a Reel already scheduled in Buffer (does not call Buffer)
+  insights [--days 30] [--channel yt|ig] [--type reel|short|long] [--tag x] [--compare] [--sort views] [--posts] [--json]
+  insights 48h [--days 30]                                                 48 h reading per post, as a table for product-marketing.md
+  import [youtube|instagram|tiktok] [--dry-run]                            (admin) brings the history into Insights
+  content [--channel yt] [--limit 30] [--sort recent|views|reactions]      everything already published (Praeko + imported)
+  followers <instagram|tiktok> [value] [--day YYYY-MM-DD]                  lists followers; manual entry only for Instagram
+  tiktok import [--dry-run] | videos [--limit 30] [--sort views] | status | connect | disconnect
+  youtube-schedule <post> --when "07/11 10:00"                             schedules a video already uploaded to YouTube (private)
+  account <network> connect --server URL                                   returns (and opens) the authorization link
+  account tiktok connect|status|disconnect --server URL
+  account instagram connect --meta [--replace] [--instagram user] [--instagram-id ID] [--probe] --server URL   login da Meta (OAuth); --replace s\xF3 se j\xE1 houver conex\xE3o
+  account instagram send --server URL                                      sends the Meta token (Keychain) to the server, encrypted
+  key store                                                                stores the service key (echo $KEY | praeko key store)
+  key create --name bardo [--scope write] [--server URL]                   creates an API key (needs an admin key); scopes: read, write, admin
+  key create --name admin --scope admin --sql                              generates the first key and the SQL for D1 (docs/servidor.md)
+  key list | key revoke <id>
+  usage [--days 7] [--json]                                                API usage: calls, success rate, p95, peak per minute, per day and per key
+  usage log [--key-id id|session] [--code 4xx|404] [--route /v1/posts] [--method GET] [--days 30] [--limit 50] [--cursor c] [--json]   request log (30 days, metadata only)
+  webhook list | create --url https://\u2026 [--events post.sent,post.failed] | test <id> | deliveries <id> [--limit 20] | retry <id> <delivery>
+  webhook pause|resume|remove <id> | rotate-secret <id> | events <id> post.sent,post.failed      (admin) outgoing webhooks; the secret is printed once
+  keys migrate                                                             copies the Keychain items of the old service (arauto) to the new one (praeko); prints names only, never secrets
+  help
+
+Global flags: --server URL, --key, --config file, --help. --idempotency-key K (publish-now, webhook create): sends the Idempotency-Key header so a repeated command does not repeat the action (docs/idempotencia.md).
+The package folder has publicacao.json, the video and the cover (or use --meta/--video/--cover). Config: praeko.json (or the old arauto.json, or the
+publicacao section of a marca.json) in the current folder or above. Nothing is sent without --send. Human-readable output is in Portuguese.
+
+Deprecated aliases (Portuguese), still working: postar agendar fila conta canais calendario vagas publicar-agora youtube-agendar adotar-buffer importar conteudo seguidores chave ajuda;
+subcommands listar executar cancelar comentar instalar remover conectar desconectar enviar editar comentarios resolver reabrir responder importar guardar criar revogar;
+flags --quando --redes --modo-yt --modo-tt --por --enviar --simular --etiqueta --estado --canal --titulo --descricao-arquivo --trocar-hashtags --texto --sem-resposta --ordem --direcao --limite --pagina --comparar --dias --dia --servidor --chave --escopo --nome --fuso --de --ate --fila --rascunho --lembrete --capa --capa-midia --privacidade-tt --quadro-tt --cancelar --sem-capa-no-quadro --minutos --tipo --ajuda;
+old values (privado agendado publico rascunho direto fila enviado leitura escrita \u2026) are accepted too.
+`;
+function flags(a) {
+  const f = { _: [] };
+  for (let i = 0; i < a.length; i++) {
+    if (a[i].startsWith("--")) {
+      let k = a[i].slice(2);
+      k = FLAG_ALIAS[k] ?? k;
+      if (COM_VALOR.has(k) && a[i + 1] !== void 0 && !a[i + 1].startsWith("--")) f[k] = a[++i];
+      else f[k] = true;
+    } else f._.push(a[i]);
+  }
+  if (f["yt-mode"] && typeof f["yt-mode"] === "string") f["yt-mode"] = MODO_YT[f["yt-mode"]] ?? f["yt-mode"];
+  if (f["tt-mode"] && typeof f["tt-mode"] === "string") f["tt-mode"] = MODO_TT[f["tt-mode"]] ?? f["tt-mode"];
+  if (typeof f.state === "string") f.state = ESTADO[f.state] ?? f.state;
+  if (typeof f.scope === "string") f.scope = ESCOPO[f.scope] ?? f.scope;
+  if (typeof f.sort === "string") f.sort = ORDEM[f.sort] ?? f.sort;
+  if (f.type === "longo") f.type = "long";
+  return f;
+}
+var redesDe = (txt, padrao) => txt ? String(txt).split(",").map((x) => REDES[x.trim()] || (() => {
+  throw new Error(`rede desconhecida: ${x}`);
+})()) : padrao;
+var local = (iso) => new Date(iso).toLocaleString("pt-BR", { timeZone: "America/Sao_Paulo", dateStyle: "short", timeStyle: "short" });
+function carregar(f) {
+  const achado = f.config ? { raiz: resolve2(f.config, ".."), config: normalizarConfig(JSON.parse(readFileSync2(resolve2(f.config), "utf8"))) } : acharConfig();
+  if (!achado) throw new Error("n\xE3o achei praeko.json (nem arauto.json ou marca.json) na pasta atual ou acima");
+  return achado;
+}
+async function executarCli(argv, { log = console.log, erro = console.error, ctxExtra = {} } = {}) {
+  const [cmd0, ...resto] = argv;
+  const cmd = CMD_ALIAS[cmd0] ?? cmd0;
+  if (cmd === "--version" || cmd === "-v" || cmd === "version") {
+    log(false ? "dev" : "0.2.0");
+    return 0;
+  }
+  if (!cmd || cmd === "help" || cmd === "--help" || cmd === "--ajuda") {
+    log(AJUDA);
+    return 0;
+  }
+  const f = flags(resto);
+  if (!f.server && process.env.PRAEKO_SERVER) f.server = process.env.PRAEKO_SERVER;
+  const subs = SUB_ALIAS[cmd], idx = cmd === "account" ? 1 : 0;
+  if (subs && f._[idx]) f._[idx] = subs[f._[idx]] ?? f._[idx];
+  try {
+    if (cmd === "post" || cmd === "schedule") return await postar(cmd, f, log, ctxExtra);
+    if (cmd === "queue") return await fila(f, log, ctxExtra);
+    if (cmd === "account") return await conta(f, log, ctxExtra, resto);
+    if (cmd === "channels") return await canais(f, log, ctxExtra);
+    if (cmd === "posts") return await postsRemoto(f, log, ctxExtra);
+    if (cmd === "calendar") return await calendarioRemoto(f, log, ctxExtra);
+    if (cmd === "slots") return await vagasRemoto(f, log, ctxExtra);
+    if (cmd === "publish-now") return await publicarAgoraRemoto(f, log, ctxExtra);
+    if (cmd === "youtube-schedule") return await youtubeAgendarRemoto(f, log, ctxExtra);
+    if (cmd === "adopt-buffer") return await adotarBufferRemoto(f, log, ctxExtra);
+    if (cmd === "youtube") return await youtubeCmd(f, log, ctxExtra);
+    if (cmd === "tiktok") return await tiktokCmd(f, log, ctxExtra);
+    if (cmd === "insights") return await insightsCmd(f, log, ctxExtra);
+    if (cmd === "import") return await importarCmd(f, log, ctxExtra);
+    if (cmd === "followers") return await seguidoresCmd(f, log, ctxExtra);
+    if (cmd === "content") return await conteudoCmd(f, log, ctxExtra);
+    if (cmd === "key") return await chave(f, log, ctxExtra);
+    if (cmd === "usage") return await usoCmd(f, log, ctxExtra);
+    if (cmd === "webhook" || cmd === "webhooks") return await webhookCmd(f, log, ctxExtra);
+    log(AJUDA);
+    return 2;
+  } catch (e) {
+    erro("erro: " + e.message);
+    return 1;
+  }
+}
+async function postar(cmd, f, log, extra) {
+  if (cmd === "schedule" && f.key !== void 0) {
+    let k = typeof f.key === "string" ? f.key : "";
+    if (!k) {
+      const ch = [];
+      for await (const c of process.stdin) ch.push(c);
+      k = Buffer.concat(ch).toString().trim();
+    }
+    if (!k) throw new Error("uso: echo $KEY | praeko schedule --key   (publish.buffer.com/settings/api)");
+    log(`chave do Buffer guardada (${segredos.guardar("buffer/principal", k)})`);
+    return 0;
+  }
+  const { raiz, config: config0 } = carregar(f);
+  const config = f.server ? { ...config0, remoto: { ...config0.remoto || {}, url: f.server } } : config0, ctx = criarContexto({ config, raiz, log, ...extra });
+  const provedor = f.server ? "remoto" : f.via || (cmd === "schedule" ? "buffer" : config.provedor && config.provedor !== "buffer" ? config.provedor : "local");
+  const arg = f._[0];
+  const pub = await criarPublicador({ config, provedor, ctx: provedor === "remoto" && injetado(extra) ? { ...ctx, praeko: injetado(extra) } : ctx });
+  if (f.status || f.cancel) {
+    if (!arg) throw new Error("diga o pacote: praeko schedule <name> --status");
+    const id = f.id || basename2(resolve2(arg));
+    if (f.status) {
+      for (const i of (await pub.status(id)).itens) log(`${NOME[i.rede].padEnd(10)} ${i.estado.padEnd(10)} ${i.quando ? local(i.quando) : ""}  ${i.id}`);
+      return 0;
+    }
+    const r2 = await pub.cancelar(id, { redes: f.networks ? redesDe(f.networks) : void 0 });
+    log(`\u2713 cancelados: ${r2.cancelados.join(", ") || "nenhum"}${r2.mantidos.length ? `; mantidos: ${r2.mantidos.join(", ")}` : ""}`);
+    return 0;
+  }
+  if (!arg && !f.meta) throw new Error(`uso: praeko ${cmd} <package-folder> --when "06/11 17:30" [--send]`);
+  const pacote = lerPacote({ arg, flags: f, raiz, config });
+  const padraoRedes = Array.isArray(config.redes) ? config.redes.map((x) => REDES[x]) : pacote.meta.formato === "longo" ? ["youtube", "instagram"] : ["youtube", "instagram", "tiktok"];
+  const redes = redesDe(f.networks, padraoRedes);
+  const fuso = config.fusoOffset || "-03:00", chaveRede = { youtube: "yt", instagram: "ig", tiktok: "tt" };
+  const destinos = redes.map((r2) => {
+    const q = f[chaveRede[r2]] || f.when;
+    const modo = r2 === "youtube" ? f["yt-mode"] : r2 === "tiktok" ? f["tt-mode"] : void 0;
+    const quando = q ? parseQuando(q, { fuso }) : null;
+    if (quando && Date.parse(quando) < Date.now() + 5 * 6e4 && provedor === "buffer") throw new Error(`${NOME[r2]}: ${local(quando)} \xE9 daqui a menos de 5 minutos ou j\xE1 passou`);
+    return { rede: r2, quando, ...modo ? { modo } : {}, ...f.queue && !quando ? { fila: true } : {}, ...f.draft ? { rascunho: true } : {} };
+  });
+  const { pedido, erros, avisos } = montarPedido({ pacote, config, destinos, opcoes: { lembrete: !!f.reminder, ...f["no-cover-in-frame"] ? { capaNoQuadro: false } : {}, ...f.url ? { videoUrl: f.url } : {} } });
+  if (provedor === "remoto" && destinos.some((d) => d.rede === "tiktok")) {
+    const o = { ...config.tiktok?.privacidade ? { privacidade: config.tiktok.privacidade } : {}, ...config.tiktok?.capaMs != null ? { miniaturaMs: config.tiktok.capaMs } : {}, ...f["tt-privacy"] ? { privacidade: f["tt-privacy"] } : {}, ...f["tt-frame"] ? { miniaturaMs: Number(f["tt-frame"]) } : {} };
+    if (Object.keys(o).length) pedido.opcoes.tiktok = o;
+    const direto = pedido.destinos.find((d) => d.rede === "tiktok")?.modo === "direto";
+    avisos.push(direto ? "TikTok direto: enquanto o app n\xE3o for auditado pelo TikTok, s\xF3 vale SELF_ONLY (privado) e s\xF3 contas de teste; p\xFAblico exige auditoria (docs/tiktok.md)" : "TikTok rascunho: o v\xEDdeo chega \xE0 caixa de entrada do app; legenda e capa voc\xEA ajusta no app (a API da caixa de entrada n\xE3o leva as duas)");
+    if (pacote.capa) avisos.push("TikTok: a capa em imagem n\xE3o \xE9 usada (o TikTok s\xF3 aceita um quadro do v\xEDdeo: --tt-frame <ms>)");
+  }
+  if (provedor === "remoto") {
+    pedido.id = String(pedido.id).replace(/[^A-Za-z0-9_-]+/g, "-").slice(0, 64);
+    if (f.tag) pedido.etiquetas = String(f.tag).split(",").map((x) => x.trim()).filter(Boolean);
+  }
+  erros.forEach((e) => log("  \u2717 " + e));
+  if (erros.length) return 1;
+  const errosPedido = validarPedido(pedido);
+  if (errosPedido.length) {
+    errosPedido.forEach((e) => log("  \u2717 " + e));
+    return 1;
+  }
+  const enviar = !!f.send;
+  if (provedor === "remoto") await capaNosQuadrosInstagram({ pedido, pacote, f, raiz, enviar, log, avisos });
+  log(`${enviar ? "PUBLICANDO" : "SIMULA\xC7\xC3O (nada ser\xE1 enviado; use --send)"} [${provedor}]: ${pedido.titulo}`);
+  log(`pacote: ${pacote.dir}
+v\xEDdeo: ${basename2(pacote.video)}${pacote.capa ? `  capa: ${basename2(pacote.capa)}` : "  (sem capa)"}`);
+  for (const d of pedido.destinos) log(`  ${NOME[d.rede].padEnd(10)} ${d.fila ? "pr\xF3xima vaga da fila" : d.rascunho ? "rascunho" : !d.quando || provedor === "local" && d.rede === "youtube" && (d.modo || config.youtube?.modo || "privado") !== "agendado" ? "agora" : local(d.quando)}${d.modo ? `  modo ${d.modo}` : ""}  texto ${pedido.textos[d.rede].texto.length} caract.`);
+  if (provedor === "local") {
+    const todos = await registro_exports.carregarTodos();
+    for (const d of pedido.destinos) for (const l of await todos[d.rede]?.planejar?.({ item: { slug: pedido.id, rede: d.rede, quando: d.quando || (/* @__PURE__ */ new Date()).toISOString(), video: pacote.video, capa: pacote.capa, textos: pedido.textos[d.rede], opcoes: { ...config[d.rede] || {}, modo: d.modo || config[d.rede]?.modo }, titulo: pedido.titulo }, ctx }) || []) log("     " + l);
+  }
+  avisos.forEach((x) => log("  \u26A0 " + x));
+  (pacote.meta.antesDePublicar || []).forEach((x) => log("  \u2610 " + x));
+  if (!enviar) return 0;
+  const r = await pub.publicar(pedido);
+  for (const i of r.itens) log(`${i.estado === "erro" ? "\u2717" : "\u2713"} ${NOME[i.rede]} ${i.estado}${i.quando && i.estado === "agendado" ? " para " + local(i.quando) : ""}${i.url ? "  " + i.url : ""}${i.studio ? "  (" + i.studio + ")" : ""}${i.aviso ? "  " + i.aviso : ""}`);
+  return r.itens.some((i) => i.estado === "erro") ? 1 : 0;
+}
+async function capaNosQuadrosInstagram({ pedido, pacote, f, raiz, enviar, log, avisos }) {
+  const d = pedido.destinos.find((x) => x.rede === "instagram");
+  if (!d || f["no-cover-in-frame"] || d.midia) return;
+  if (!pacote.capa) {
+    avisos.push("Instagram: sem capa, a miniatura ser\xE1 um quadro do v\xEDdeo");
+    return;
+  }
+  if (pedido.opcoes?.formato === "longo") {
+    avisos.push("Instagram: capa n\xE3o colada no v\xEDdeo longo (a capa 16:9 n\xE3o serve de miniatura de Reel)");
+    return;
+  }
+  let v, c;
+  try {
+    v = capa_quadro_exports.sondar(pacote.video);
+    c = capa_quadro_exports.dimensoesImagem(pacote.capa);
+  } catch (e) {
+    avisos.push(`Instagram: n\xE3o consegui conferir a capa (${e.message}); sem capa nos quadros`);
+    return;
+  }
+  if (!capa_quadro_exports.mesmaProporcao(c, v)) {
+    avisos.push(`Instagram: a capa ${c.largura}x${c.altura} n\xE3o tem a propor\xE7\xE3o do v\xEDdeo ${v.largura}x${v.altura}; n\xE3o colei nos quadros`);
+    return;
+  }
+  if (!enviar) {
+    log(`  Instagram: capa nos 2 primeiros quadros (${basename2(pacote.capa)}); a c\xF3pia \xE9 gerada no --send`);
+    return;
+  }
+  const dir = pastaEstado(raiz);
+  mkdirSync(dir, { recursive: true });
+  const saida = join2(dir, `${pedido.id}-instagram.mp4`);
+  capa_quadro_exports.embutirCapa({ video: pacote.video, capa: pacote.capa, saida });
+  d.midia = { video: saida };
+  log(`  \u2713 capa colada nos 2 primeiros quadros do v\xEDdeo do Instagram: ${basename2(saida)}`);
+}
+async function fila(f, log, extra) {
+  const { raiz, config } = carregar(f), sub = f._[0] || "list", ctx = criarContexto({ config, raiz, log, ...extra });
+  if (sub === "list") {
+    const itens = lerFila(raiz).itens;
+    if (!itens.length) {
+      log("fila vazia");
+      return 0;
+    }
+    for (const it of itens) log(`${it.id}  ${it.estado.padEnd(10)} ${NOME[it.rede].padEnd(9)} ${it.quando ? local(it.quando) : "manual   "}  ${it.slug}${it.acao ? ` [${it.acao}${it.manual ? ", manual" : ""}]` : ""}${it.erro ? `  \u2717 ${it.erro.slice(0, 80)}` : ""}${it.resultado?.url ? "  " + it.resultado.url : ""}`);
+    return 0;
+  }
+  if (sub === "run") {
+    const r = await executar({ raiz, provedores: await registro_exports.carregarTodos(), ctx, simular: !!f["dry-run"], log });
+    if (!r.feitos.length && !f["dry-run"]) log("nada a fazer agora");
+    return 0;
+  }
+  if (sub === "cancel") {
+    const it = cancelarItem(raiz, f._[1]);
+    log(`\u2713 cancelado ${it.id} (${NOME[it.rede]}, ${it.slug})`);
+    return 0;
+  }
+  if (sub === "comment") {
+    const it = liberarItem(raiz, f._[1]);
+    await executar({ raiz, provedores: await registro_exports.carregarTodos(), ctx, soIds: [it.id], log });
+    const novo = lerFila(raiz).itens.find((x) => x.id === it.id);
+    log(novo.estado === "enviado" ? `\u2713 coment\xE1rio feito${novo.resultado?.lembrete ? " (" + novo.resultado.lembrete + ")" : ""}` : `\u2717 ${novo.erro}`);
+    return novo.estado === "enviado" ? 0 : 1;
+  }
+  const agentes = join2(homedir(), "Library", "LaunchAgents"), plist = join2(agentes, "br.praeko.fila.plist"), plistAntigo = join2(agentes, "br.arauto.fila.plist");
+  const pararAntigo = () => {
+    try {
+      execFileSync("launchctl", ["bootout", `gui/${process.getuid()}`, plistAntigo], { stdio: "ignore" });
+    } catch {
+    }
+    rmSync(plistAntigo, { force: true });
+  };
+  if (sub === "install") {
+    mkdirSync(agentes, { recursive: true });
+    pararAntigo();
+    writeFileSync(plist, plistLaunchd({ node: process.execPath, praeko: BIN, cwd: raiz, minutos: +f.minutes || 5, log: caminhoEstado(raiz, "fila.log") }));
+    try {
+      execFileSync("launchctl", ["bootout", `gui/${process.getuid()}`, plist], { stdio: "ignore" });
+    } catch {
+    }
+    execFileSync("launchctl", ["bootstrap", `gui/${process.getuid()}`, plist]);
+    log(`\u2713 executor instalado; roda a cada ${+f.minutes || 5} min com o Mac ligado. Log: .praeko/fila.log`);
+    return 0;
+  }
+  if (sub === "remove") {
+    try {
+      execFileSync("launchctl", ["bootout", `gui/${process.getuid()}`, plist], { stdio: "ignore" });
+    } catch {
+    }
+    pararAntigo();
+    log("\u2713 executor removido");
+    return 0;
+  }
+  throw new Error("uso: praeko queue [list|run [--dry-run]|cancel <id>|comment <id>|install|remove]");
+}
+async function conta(f, log, extra, resto = []) {
+  const rede = REDES[f._[0]], acao = f._[1] || "status";
+  if (!rede) throw new Error("uso: praeko account <youtube|instagram|tiktok> [connect|status]");
+  if (rede === "instagram" && acao === "send") {
+    const bruto = extra.segredos ? extra.segredos.obter("instagram/token") : segredos.obter("instagram/token");
+    if (!bruto) throw new Error("n\xE3o achei o token do Instagram no Chaveiro: rode antes `praeko account instagram connect --user-id <id>`");
+    const t = JSON.parse(bruto), a = clienteRemoto(f, carregarSeHouver(f).config, extra);
+    const r = await a.channels.sendInstagramToken({ token: t.token, userId: t.userId, username: t.username, type: t.tipo, host: t.host });
+    log(`\u2713 token da Meta enviado ao servidor: @${r.username} (${r.followers ?? "?"} seguidores, ${r.mediaItems ?? "?"} m\xEDdias)`);
+    return 0;
+  }
+  if (acao === "connect" && (f.server || injetado(extra))) {
+    const meta = rede === "instagram" && f.meta, a = clienteRemoto(f, carregarSeHouver(f).config, extra);
+    if (meta && f.replace) log("ATEN\xC7\xC3O: --replace troca o token de publica\xE7\xE3o do Instagram por este login da Meta.");
+    const r = await a.channels.connect(meta ? "meta" : rede, meta ? { replace: !!f.replace, instagram: typeof f.instagram === "string" ? f.instagram : void 0, instagramId: typeof f["instagram-id"] === "string" ? f["instagram-id"] : void 0, probe: !!f.probe } : {});
+    log(`Abra este endere\xE7o no navegador e autorize:
+${r.url}`);
+    if (!injetado(extra)) {
+      try {
+        spawn("open", [r.url], { stdio: "ignore", detached: true }).unref();
+      } catch {
+      }
+    }
+    return 0;
+  }
+  if (rede === "tiktok" && (acao === "status" || acao === "disconnect") && (f.server || injetado(extra))) return tiktokCmd({ ...f, _: [acao] }, log, extra);
+  let achado;
+  try {
+    achado = carregar(f);
+  } catch {
+    achado = { raiz: process.cwd(), config: normalizarConfig({}) };
+  }
+  const { raiz, config } = achado, ctx = criarContexto({ config, raiz, log, ...extra });
+  const prov = await registro_exports.carregar(rede);
+  if (acao === "connect") return await prov.conectar({ ctx, args: resto.slice(Math.max(resto.indexOf("connect"), resto.indexOf("conectar")) + 1) }) ?? 0;
+  const s = await prov.status({ ctx });
+  log(`${NOME[rede]}: ${s.conectado ? "conectado" : "N\xC3O conectado"}${s.detalhe ? ` (${s.detalhe})` : ""}`);
+  return s.conectado ? 0 : 1;
+}
+async function canais(f, log, extra) {
+  const { raiz, config } = carregar(f), ctx = criarContexto({ config, raiz, log, ...extra });
+  const pub = await criarPublicador({ config, provedor: f.via || "local", ctx });
+  for (const c of await pub.canais()) log(`${(NOME[c.rede] || c.rede).padEnd(10)} ${c.conectado ? "conectado " : "N\xC3O conectado"} ${c.id ? c.id + "  " : ""}${c.detalhe || ""}`);
+  return 0;
+}
+var carregarSeHouver = (f) => {
+  try {
+    return carregar(f);
+  } catch {
+    return { raiz: process.cwd(), config: {} };
+  }
+};
+function clienteRemoto(f, config, extra = {}) {
+  if (injetado(extra)) return injetado(extra);
+  const url = f.server || config?.remoto?.url, chave2 = process.env.PRAEKO_KEY || process.env.ARAUTO_CHAVE || segredos.obter("praeko/chave");
+  if (!url) throw new Error('falta o endere\xE7o do servi\xE7o: --server https://\u2026 (ou "remoto": { "url" } no praeko.json)');
+  if (!chave2) throw new Error("falta a chave do servi\xE7o: PRAEKO_KEY (ou ARAUTO_CHAVE) ou `echo $CHAVE | praeko chave guardar`");
+  return new Praeko({ url, key: chave2 });
+}
+var hora = (iso, fuso = "America/Sao_Paulo") => iso ? new Date(iso).toLocaleString("pt-BR", { timeZone: fuso, dateStyle: "short", timeStyle: "short" }) : "\u2014";
+async function postsRemoto(f, log, extra) {
+  const a = clienteRemoto(f, carregarSeHouver(f).config, extra);
+  const r = await a.posts.list({ state: f.state, channel: f.channel ? REDES[f.channel] || f.channel : void 0, tag: f.tag, limit: f.limit });
+  if (!r.posts.length) {
+    log("nenhum post");
+    return 0;
+  }
+  for (const p of r.posts) log(`${p.id.padEnd(28)} ${estadoPt(p.state).padEnd(9)} ${p.title.slice(0, 40).padEnd(40)} ${p.items.map((i) => `${i.network}:${estadoPt(i.state)}${i.scheduledFor ? " " + hora(i.scheduledFor) : ""}`).join(" \xB7 ")}${p.tags.length ? "  #" + p.tags.join(" #") : ""}`);
+  log(`${r.posts.length} de ${r.total}`);
+  return 0;
+}
+async function calendarioRemoto(f, log, extra) {
+  const a = clienteRemoto(f, carregarSeHouver(f).config, extra), c = await a.calendar({ from: f.from, to: f.to, channel: f.channel ? REDES[f.channel] || f.channel : void 0, tag: f.tag });
+  const linhas = [...c.items.map((i) => ({ q: i.scheduledFor, t: `${NOME[i.network]} ${estadoPt(i.state)}${i.custom ? " (Custom)" : ""}  ${i.title}` })), ...c.freeSlots.map((v) => ({ q: v.scheduledFor, t: `${NOME[v.network]} vaga livre` }))].sort((x, y) => x.q.localeCompare(y.q));
+  if (!linhas.length) {
+    log("nada no per\xEDodo");
+    return 0;
+  }
+  for (const l of linhas) log(`${hora(l.q).padEnd(18)} ${l.t}`);
+  return 0;
+}
+async function vagasRemoto(f, log, extra) {
+  const rede = REDES[f._[0]];
+  if (!rede) throw new Error("uso: praeko slots <youtube|instagram|tiktok> [fri 17:30 sun 22:00] [--timezone America/Sao_Paulo]");
+  const a = clienteRemoto(f, carregarSeHouver(f).config, extra), pares = f._.slice(1);
+  const dia = (d) => DIA[String(d).toLowerCase()] ?? d, mostra = (d) => DIA_PT[d] ?? d;
+  if (pares.length) {
+    if (pares.length % 2) throw new Error("as vagas v\xEAm em pares: dia hora (ex.: slots youtube fri 17:30 sun 22:00)");
+    const vagas = [];
+    for (let i = 0; i < pares.length; i += 2) vagas.push(`${dia(pares[i])} ${pares[i + 1]}`);
+    const r2 = await a.channels.setSlots(rede, vagas, { timezone: f.timezone });
+    log(`\u2713 vagas de ${NOME[rede]} (${r2.timezone}): ${r2.slots.map((v) => `${mostra(v.day)} ${v.time}`).join(", ") || "nenhuma"}${r2.rescheduled.length ? `; ${r2.rescheduled.length} item(ns) da fila reorganizado(s)` : ""}`);
+    return 0;
+  }
+  const r = await a.channels.slots(rede);
+  log(`${NOME[rede]} (${r.timezone}): ${r.slots.map((v) => `${mostra(v.day)} ${v.time}`).join(", ") || "sem vagas"}`);
+  return 0;
+}
+async function publicarAgoraRemoto(f, log, extra) {
+  if (!f._[0]) throw new Error("uso: praeko publish-now <id> [--networks yt]");
+  const a = clienteRemoto(f, carregarSeHouver(f).config, extra), r = await a.posts.publishNow(f._[0], { network: f.networks ? REDES[f.networks] : void 0, ...f["idempotency-key"] ? { idempotencyKey: f["idempotency-key"] } : {} });
+  for (const i of r.items) log(`${NOME[i.network].padEnd(10)} ${estadoPt(i.state)}`);
+  return 0;
+}
+async function usoCmd(f, log, extra) {
+  const a = clienteRemoto(f, carregarSeHouver(f).config, extra);
+  const num = (x) => x == null ? "\u2014" : Number(x).toLocaleString("pt-BR");
+  if (f._[0] === "log") {
+    const r2 = await a.usage.log({ key: typeof f["key-id"] === "string" ? f["key-id"] : void 0, status: typeof f.code === "string" ? f.code : void 0, route: f.route, method: f.method, days: f.days, limit: f.limit, cursor: f.cursor });
+    if (f.json) {
+      log(JSON.stringify(r2, null, 2));
+      return 0;
+    }
+    if (!r2.records.length) {
+      log("(nenhuma chamada com esses filtros)");
+      return 0;
+    }
+    for (const x of r2.records) log(`${local(x.createdAt)}  ${x.method.padEnd(6)} ${String(x.status).padEnd(3)} ${String(x.durationMs).padStart(5)} ms  ${x.route.padEnd(36)} ${x.keyName}`);
+    if (r2.next) log(`(mais: --cursor ${r2.next})`);
+    return 0;
+  }
+  if (f._[0] !== void 0) throw new Error(`subcomando desconhecido: usage ${f._[0]} (use: usage | usage log)`);
+  const r = await a.usage.get({ days: f.days });
+  if (f.json) {
+    log(JSON.stringify(r, null, 2));
+    return 0;
+  }
+  const pct = r.total ? `${String(Math.round(r.succeeded / r.total * 1e3) / 10).replace(".", ",")}%` : "\u2014";
+  log(`Uso da API \xB7 ${r.days === 1 ? "\xFAltimas 24 horas" : `\xFAltimos ${r.days} dias`}`);
+  log(`  chamadas ${num(r.total)} \xB7 sucesso ${pct} \xB7 erros ${num(r.errors)} \xB7 p95 ${r.p95Ms == null ? "\u2014" : r.p95Ms + " ms"} \xB7 pico ${num(r.peakPerMinute)}/min (limite ${num(r.limitPerMinute)}/min)`);
+  for (const d of r.byDay) if (d.total) log(`  ${d.day}  ${String(d.total).padStart(6)} chamadas${d.errors ? ` \xB7 ${d.errors} erros` : ""}`);
+  if (r.byKey.length) {
+    log("Por chave:");
+    for (const k of r.byKey) log(`  ${k.name.padEnd(24)} ${String(k.total).padStart(6)} chamadas${k.errors ? ` \xB7 ${k.errors} erros` : ""} \xB7 \xFAltima ${local(k.lastAt)}`);
+  }
+  return 0;
+}
+async function webhookCmd(f, log, extra) {
+  const a = clienteRemoto(f, carregarSeHouver(f).config, extra), [sub = "list", id, outro] = f._;
+  const linha = (w) => `${w.id}  ${w.active ? "ativo  " : "pausado"}  ${w.url}  [${w.events.join(", ")}]${w.disabledReason ? `  (${w.disabledReason})` : ""}`;
+  const entrega = (e) => `${e.createdAt ? local(e.createdAt) : ""}  ${e.event.padEnd(19)} ${e.state.padEnd(9)} ${e.lastStatus ?? "\u2014"}  ${e.attempts}x${e.lastError ? `  ${e.lastError}` : ""}  ${e.id}`;
+  const precisa = () => {
+    if (!id) throw new Error(`diga o webhook: praeko webhook ${sub} <id>`);
+    return id;
+  };
+  if (sub === "list") {
+    const r = await a.webhooks.list();
+    if (!r.webhooks.length) log("(nenhum webhook)");
+    for (const w of r.webhooks) log(linha(w));
+    return 0;
+  }
+  if (sub === "create") {
+    if (typeof f.url !== "string") throw new Error("falta --url https://\u2026");
+    const w = await a.webhooks.create({ url: f.url, events: typeof f.events === "string" ? f.events.split(",").map((x) => x.trim()).filter(Boolean) : void 0, ...f["idempotency-key"] ? { idempotencyKey: f["idempotency-key"] } : {} });
+    log(`\u2713 ${linha(w)}`);
+    log(`Segredo de assinatura (aparece s\xF3 agora): ${w.secret}`);
+    return 0;
+  }
+  if (sub === "rotate-secret") {
+    const r = await a.webhooks.rotateSecret(precisa());
+    log(`\u2713 novo segredo (aparece s\xF3 agora; o anterior deixou de valer): ${r.secret}`);
+    return 0;
+  }
+  if (sub === "test") {
+    const r = await a.webhooks.test(precisa());
+    log(entrega(r.delivery));
+    return r.delivery.state === "delivered" ? 0 : 1;
+  }
+  if (sub === "deliveries") {
+    const r = await a.webhooks.deliveries(precisa(), { limit: f.limit });
+    if (!r.deliveries.length) log("(nenhuma entrega)");
+    for (const e of r.deliveries) log(entrega(e));
+    return 0;
+  }
+  if (sub === "retry") {
+    if (!outro) throw new Error("diga a entrega: praeko webhook retry <id> <entrega>");
+    const r = await a.webhooks.redeliver(precisa(), outro);
+    log(entrega(r.delivery));
+    return r.delivery.state === "delivered" ? 0 : 1;
+  }
+  if (sub === "pause" || sub === "resume") {
+    const w = await a.webhooks.update(precisa(), { active: sub === "resume" });
+    log(`\u2713 ${linha(w)}`);
+    return 0;
+  }
+  if (sub === "events") {
+    if (!outro) throw new Error("diga os eventos: praeko webhook events <id> post.sent,post.failed");
+    const w = await a.webhooks.update(precisa(), { events: outro.split(",").map((x) => x.trim()).filter(Boolean) });
+    log(`\u2713 ${linha(w)}`);
+    return 0;
+  }
+  if (sub === "remove") {
+    await a.webhooks.remove(precisa());
+    log(`\u2713 webhook ${id} apagado`);
+    return 0;
+  }
+  throw new Error(`subcomando desconhecido: webhook ${sub}`);
+}
+var curto = (t, n = 110) => {
+  const x = String(t ?? "").replace(/\s+/g, " ").trim();
+  return x.length > n ? x.slice(0, n - 1) + "\u2026" : x;
+};
+async function insightsCmd(f, log, extra) {
+  const a = clienteRemoto(f, carregarSeHouver(f).config, extra), dias = Math.max(1, Number(f.days) || 30), ate = Date.now();
+  const canal = f.channel ? REDES[f.channel] || f.channel : void 0;
+  const r = await a.insights.get({ from: new Date(ate - dias * 864e5).toISOString(), to: new Date(ate).toISOString(), channel: canal, tag: f.tag, type: f.type, compare: !!(f.compare || f.posts), sort: f.sort, direction: f.direction, limit: f.limit });
+  if (f.json) {
+    log(JSON.stringify(r, null, 2));
+    return 0;
+  }
+  if (f._[0] === "48h") {
+    log(r.reading48hText);
+    if (!r.reading48h.length) log(`(nenhum post publicado h\xE1 48 h ou mais nos \xFAltimos ${dias} dias)`);
+    return 0;
+  }
+  const k = r.cards, n = (x) => x == null ? "\u2014" : String(x), pct = (x) => x == null ? "\u2014" : `${String(x).replace(".", ",")}%`;
+  log(`\xDAltimos ${dias} dias${canal ? ` \xB7 ${NOME[canal] || canal}` : ""}${f.tag ? ` \xB7 etiqueta ${f.tag}` : ""}`);
+  log(`  posts ${n(k.posts)} \xB7 views ${n(k.views)} \xB7 rea\xE7\xF5es ${n(k.reactions)} \xB7 coment\xE1rios ${n(k.comments)} \xB7 engajamento ${pct(k.engagement)} \xB7 seguidores ${n(k.followers)}${k.followersChange != null ? ` (${k.followersChange > 0 ? "+" : ""}${k.followersChange})` : ""}`);
+  const maisCartoes = [["shares", "compart."], ["saves", "salvos"], ["reach", "alcance"], ["watchTimeMin", "min assistidos"], ["avgWatchTimeSec", "s m\xE9dios"], ["followersGained", "seguidores ganhos"]].filter(([x]) => k[x] != null).map(([x, t]) => `${t} ${k[x]}${k.change?.[x]?.pct != null ? ` (${k.change[x].pct > 0 ? "+" : ""}${String(k.change[x].pct).replace(".", ",")}%)` : ""}`);
+  if (maisCartoes.length) log(`  ${maisCartoes.join(" \xB7 ")}`);
+  if (r.sources?.bufferAggregate) log("  (n\xFAmeros do agregado do Buffer: " + Object.keys(r.sources.current).join(", ") + ")");
+  if (f.posts && r.posts?.items?.length) {
+    log(`Posts do per\xEDodo (${r.posts.total}, ordem ${r.posts.sort} ${r.posts.direction}):`);
+    r.posts.items.forEach((p, i) => log(`  ${String(i + 1).padStart(2)}. ${curto(p.title, 55)}  [${NOME[p.network] || p.network}${p.type ? ` \xB7 ${p.type}` : ""}]  ${p.reactions} rea\xE7\xF5es \xB7 ${p.comments} coment. \xB7 ${p.views} views \xB7 ${p.engagement == null ? "\u2014" : String(p.engagement).replace(".", ",") + "%"}`));
+  }
+  if (r.topPosts.length) {
+    log("Top posts (rea\xE7\xF5es):");
+    r.topPosts.forEach((p, i) => log(`  ${i + 1}. ${curto(p.title, 60)}  [${NOME[p.network] || p.network}]  ${p.reactions} rea\xE7\xF5es \xB7 ${p.comments} coment. \xB7 ${p.views} views${p.noMetrics ? "  (sem m\xE9tricas ainda)" : ""}`));
+  }
+  for (const c of r.channels) log(`  ${(NOME[c.network] || c.network).padEnd(10)} posts ${String(c.posts).padStart(3)} \xB7 rea\xE7\xF5es ${String(c.reactions).padStart(5)} \xB7 coment. ${String(c.comments).padStart(4)} \xB7 engajamento ${pct(c.engagement)}`);
+  for (const x of r.summary) log(`\u2022 ${x.title}: ${x.text}`);
+  if (r.collection.collecting) log("(a coleta de m\xE9tricas ainda n\xE3o rodou para estes posts: 1 h, 6 h, 24 h, 48 h e 7 dias depois de cada publica\xE7\xE3o)");
+  return 0;
+}
+async function importarCmd(f, log, extra) {
+  const a = clienteRemoto(f, carregarSeHouver(f).config, extra), rede = f._[0] ? REDES[f._[0]] || f._[0] : "all";
+  const r = await a.insights.import({ network: rede, dryRun: !!f["dry-run"] });
+  for (const x of r.imported) {
+    if (x.error) log(`${NOME[x.network]}: \u2717 ${x.error}`);
+    else if (x.skipped) log(`${NOME[x.network]}: ignorado (${x.reason})`);
+    else log(`${NOME[x.network]}${x.simulated ? " (simula\xE7\xE3o)" : ""}: ${x.found} encontrados \xB7 ${x.created} novos \xB7 ${x.updated} atualizados \xB7 ${x.views} views \xB7 ${x.likes} rea\xE7\xF5es \xB7 ${x.comments} coment\xE1rios`);
+  }
+  return r.imported.some((x) => x.error) ? 1 : 0;
+}
+async function tiktokCmd(f, log, extra) {
+  const sub = f._[0], a = clienteRemoto(f, carregarSeHouver(f).config, extra);
+  if (sub === "import") return importarCmd({ ...f, _: ["tiktok"] }, log, extra);
+  if (sub === "videos") return conteudoCmd({ ...f, channel: "tiktok" }, log, extra);
+  if (sub === "connect") {
+    const r = await a.channels.connect("tiktok");
+    log(`Abra este endere\xE7o no navegador e autorize:
+${r.url}`);
+    return 0;
+  }
+  if (sub === "disconnect") {
+    const r = await a.channels.disconnect("tiktok");
+    log(`\u2713 TikTok desconectado${r.revokedAtTiktok ? " (acesso revogado no TikTok)" : ""}`);
+    return 0;
+  }
+  if (sub === "status") {
+    const c = (await a.channels.list({ verify: true })).channels.find((x) => x.network === "tiktok");
+    log(`TikTok: ${c?.connected ? "conectado" : "N\xC3O conectado"}${c?.detail ? ` (${c.detail})` : ""}`);
+    if (c?.connected) log("  rascunho: o v\xEDdeo vai para a caixa de entrada do app \xB7 direto: privado (SELF_ONLY) at\xE9 o app ser auditado (docs/tiktok.md)");
+    return c?.connected ? 0 : 1;
+  }
+  throw new Error("uso: praeko tiktok import [--dry-run] | videos [--limit 30] | status | connect | disconnect");
+}
+async function seguidoresCmd(f, log, extra) {
+  const rede = REDES[f._[0]], a = clienteRemoto(f, carregarSeHouver(f).config, extra);
+  if (!rede) throw new Error("uso: praeko followers <instagram|tiktok> [<value>] [--day YYYY-MM-DD]");
+  if (f._[1] === void 0) {
+    for (const x of (await a.channels.followers(rede)).records.slice(0, 15)) log(`${x.day}  ${String(x.followers).padStart(7)}  ${x.source}`);
+    return 0;
+  }
+  const valor = Number(f._[1]);
+  if (!Number.isInteger(valor)) throw new Error("o valor precisa ser um n\xFAmero inteiro");
+  const r = await a.channels.setFollowers(rede, valor, { day: f.day });
+  log(`\u2713 ${NOME[rede]}: ${r.followers} seguidores em ${r.day} (manual)`);
+  return 0;
+}
+async function conteudoCmd(f, log, extra) {
+  const a = clienteRemoto(f, carregarSeHouver(f).config, extra), r = await a.content.list({ network: f.channel ? REDES[f.channel] || f.channel : void 0, limit: f.limit || 30, sort: f.sort });
+  for (const i of r.items) log(`${hora(i.publishedAt).padEnd(15)} ${(NOME[i.network] || i.network).padEnd(9)} ${String(i.views ?? "\u2014").padStart(6)} views ${String(i.reactions ?? "\u2014").padStart(4)} rea\xE7\xF5es  ${curto(i.title, 70)}`);
+  log(`(${r.items.length} de ${r.total})`);
+  return 0;
+}
+async function youtubeCmd(f, log, extra) {
+  const sub = f._[0], a = clienteRemoto(f, carregarSeHouver(f).config, extra);
+  if (sub === "videos") {
+    const r = await a.youtube.listVideos({ max: f.max, page: f.page });
+    for (const v of r.videos) log(`${v.id}  ${hora(v.publishedAt).padEnd(15)} ${(v.privacy + (v.publishAt ? " \u2192 " + hora(v.publishAt) : "")).padEnd(30)} ${String(v.viewCount ?? "\u2014").padStart(6)} views  ${curto(v.title, 70)}`);
+    if (r.next) log(`(mais: --page ${r.next})`);
+    return 0;
+  }
+  if (sub === "video") {
+    if (!f._[1]) throw new Error("uso: praeko youtube video <id>");
+    const { video: v } = await a.youtube.getVideo(f._[1]);
+    log(`${v.title}
+${v.url}  ${v.privacy}${v.publishAt ? " \u2192 " + hora(v.publishAt) : ""}  publicado ${hora(v.publishedAt)}
+${v.viewCount ?? "\u2014"} views \xB7 ${v.likes ?? "\u2014"} curtidas \xB7 ${v.comments ?? "\u2014"} coment\xE1rios
+
+${v.description}`);
+    return 0;
+  }
+  if (sub === "edit") {
+    const id = f._[1];
+    if (!id) throw new Error('uso: praeko youtube edit <id> [--title T] [--description-file f.txt] [--swap-hashtags "#a #b"] [--send]');
+    const m = {};
+    if (f.title) m.title = f.title;
+    if (f["description-file"]) m.description = readFileSync2(resolve2(f["description-file"]), "utf8").replace(/\s+$/, "");
+    if (f["swap-hashtags"]) {
+      const { video: v } = await a.youtube.getVideo(id);
+      m.description = trocarHashtags(m.description ?? v.description, f["swap-hashtags"]);
+    }
+    if (!Object.keys(m).length) throw new Error("nada para mudar: use --title, --description-file ou --swap-hashtags");
+    const r = await a.youtube.editVideo(id, { ...m, dryRun: !f.send });
+    log(`${f.send ? "EDITANDO" : "SIMULA\xC7\xC3O (use --send)"}: ${id}`);
+    if (r.before.title !== r.after.title) log(`  t\xEDtulo: ${r.before.title}
+       \u2192 ${r.after.title}`);
+    if (r.before.description !== r.after.description) {
+      const u = (d) => String(d || "").split("\n").filter((x) => x.trim()).slice(-2).join(" | ");
+      log(`  descri\xE7\xE3o (final): ${curto(u(r.before.description), 140)}
+              \u2192 ${curto(u(r.after.description), 140)}`);
+    }
+    if (!r.changed) log("  (nada muda)");
+    else if (r.written) log("\u2713 escrito no YouTube");
+    return 0;
+  }
+  if (sub === "comments") {
+    const r = await a.youtube.comments({ video: f.video, unanswered: !!f.unanswered, max: f.max, page: f.page });
+    if (!r.comments.length) log("nenhum coment\xE1rio" + (f.unanswered ? " sem resposta" : ""));
+    for (const c of r.comments) log(`${c.id}  ${hora(c.publishedAt).padEnd(15)} ${c.videoId ?? ""}  ${c.fromOwner ? "(voc\xEA)" : c.answered ? "respondido" : "SEM RESPOSTA"}  ${c.author}: ${curto(c.text)}`);
+    if (r.next) log(`(mais: --page ${r.next})`);
+    return 0;
+  }
+  if (sub === "resolve" || sub === "reopen") {
+    const id = f._[1];
+    if (!id) throw new Error(`uso: praeko youtube ${sub} <thread>`);
+    await (sub === "resolve" ? a.youtube.resolve(id) : a.youtube.reopen(id));
+    log(`\u2713 ${sub === "resolve" ? "resolvido" : "reaberto"}: ${id}`);
+    return 0;
+  }
+  if (sub === "reply") {
+    const id = f._[1];
+    if (!id || !f.text) throw new Error('uso: praeko youtube reply <thread> --text "\u2026" [--send]');
+    if (!f.send) {
+      log(`SIMULA\xC7\xC3O (use --send): responderia ao coment\xE1rio ${id} com:
+  ${f.text}`);
+      return 0;
+    }
+    const r = await a.youtube.reply(id, f.text);
+    log(`\u2713 respondido (${r.id})`);
+    return 0;
+  }
+  throw new Error("uso: praeko youtube videos | video <id> | edit <id> \u2026 | comments \u2026 | resolve|reopen <thread> | reply <thread> --text \u2026");
+}
+async function adotarBufferRemoto(f, log, extra) {
+  if (!f.title || !f.when || !f["buffer-id"]) throw new Error('uso: praeko adopt-buffer --id <name> --title "\u2026" --when "07/11 10:00" --buffer-id <Buffer post id> [--text "caption"] [--cover-media <id>]  (registra no painel um Reel que j\xE1 est\xE1 agendado no Buffer; n\xE3o chama o Buffer)');
+  const quando = parseQuando(f.when, { fuso: carregarSeHouver(f).config?.fusoOffset || "-03:00" });
+  const a = clienteRemoto(f, carregarSeHouver(f).config, extra);
+  const p = await a.posts.adopt({ ...f.id ? { id: f.id } : {}, title: f.title, network: "instagram", scheduledFor: quando, external: { provider: "buffer", id: f["buffer-id"] }, ...f.text ? { texts: { instagram: { text: f.text } } } : {}, ...f["cover-media"] ? { media: { cover: f["cover-media"] } } : {} });
+  log(`\u2713 adotado: ${p.id} (Instagram, ${estadoPt(p.items[0]?.state)}, ${p.items[0]?.scheduledFor})`);
+  return 0;
+}
+async function youtubeAgendarRemoto(f, log, extra) {
+  if (!f._[0] || !f.when) throw new Error('uso: praeko youtube-schedule <post> --when "07/11 10:00" (o v\xEDdeo j\xE1 est\xE1 no YouTube, privado)');
+  const quando = parseQuando(f.when, { fuso: carregarSeHouver(f).config?.fusoOffset || "-03:00" });
+  const a = clienteRemoto(f, carregarSeHouver(f).config, extra), r = await a.posts.scheduleYoutube(f._[0], quando);
+  log(`\u2713 ${r.url} agendado para ${new Date(r.publishAt).toLocaleString("pt-BR", { timeZone: "America/Sao_Paulo", dateStyle: "short", timeStyle: "short" })} (privado at\xE9 l\xE1)`);
+  return 0;
+}
+async function chave(f, log, extra) {
+  const sub = f._[0];
+  if (sub === "store") {
+    let k = "";
+    for await (const c of process.stdin) k += c;
+    k = k.trim();
+    if (!FORMATO_CHAVE.test(k)) throw new Error("a chave do servi\xE7o come\xE7a com praeko_ (ou arauto_, as chaves antigas) (uso: echo $KEY | praeko key store)");
+    log(`chave guardada (${segredos.guardar("praeko/chave", k)})`);
+    return 0;
+  }
+  if (sub === "migrate") {
+    const r = migrar(extra.segredos ?? segredos);
+    for (const ref of r.copiados) log(`\u2713 ${ref}: copiado para o Chaveiro novo (servi\xE7o praeko)`);
+    for (const ref of r.jaNoNovo) log(`\u2022 ${ref}: j\xE1 existe no novo; nada a copiar`);
+    for (const ref of r.ausentes) log(`\xB7 ${ref}: n\xE3o havia no antigo`);
+    log(r.copiados.length ? `${r.copiados.length} item(ns) copiado(s). Os antigos continuam onde estavam (apague-os \xE0 m\xE3o quando quiser).` : "nada a copiar.");
+    return 0;
+  }
+  if (sub === "create" && f.sql) {
+    if (!f.name) throw new Error("diga o nome: praeko key create --name admin --scope admin --sql");
+    const escopo = f.scope || "admin", k = gerarChave(), id = idChave(), h = await hashChave(k);
+    if (!["read", "write", "admin"].includes(escopo)) throw new Error("scope: read, write or admin");
+    const escopoBanco = ESCOPO_PT[escopo] ?? escopo;
+    const nomeSql = String(f.name).replace(/'/g, "''");
+    log(`Chave (guarde agora, ela n\xE3o aparece de novo):
+  ${k}
+
+Execute no D1 (veja docs/servidor.md; use --local para o wrangler dev):
+  npx wrangler d1 execute arauto --remote --command "INSERT INTO chaves_api (id, nome, hash, prefixo, escopo, criado_em) VALUES ('${id}', '${nomeSql}', '${h}', '${prefixoChave(k)}', '${escopoBanco}', '${(/* @__PURE__ */ new Date()).toISOString()}')"`);
+    return 0;
+  }
+  const a = clienteRemoto(f, carregarSeHouver(f).config, extra);
+  if (sub === "create") {
+    if (!f.name) throw new Error("diga o nome: praeko key create --name bardo [--scope write]");
+    const r = await a.apiKeys.create(f.name, f.scope || "write");
+    log(`\u2713 chave ${r.id} (${r.scope}) criada. Guarde agora, ela n\xE3o aparece de novo:
+  ${r.key}`);
+    return 0;
+  }
+  if (sub === "list") {
+    for (const k of (await a.apiKeys.list()).keys) log(`${k.id}  ${k.scope.padEnd(8)} ${k.name.padEnd(16)} ${k.prefix}\u2026  ${k.revoked ? "REVOGADA" : k.lastUsedAt ? "\xFAltimo uso " + hora(k.lastUsedAt) : "nunca usada"}`);
+    return 0;
+  }
+  if (sub === "revoke") {
+    if (!f._[1]) throw new Error("uso: praeko key revoke <id>");
+    await a.apiKeys.revoke(f._[1]);
+    log(`\u2713 chave ${f._[1]} revogada`);
+    return 0;
+  }
+  throw new Error("uso: praeko key store | create --name N [--scope S] [--sql] | list | revoke <id> | migrate");
+}
+
+// src/main.ts
+var args = process.argv.slice(2);
+if (args[0] === "studio") {
+  let bin;
+  try {
+    bin = join3(dirname(createRequire(import.meta.url).resolve("@praeko/studio-cli/package.json")), "bin", "bardo.mjs");
+  } catch {
+    console.error("praeko studio: o Praeko Studio ainda n\xE3o \xE9 distribu\xEDdo pelo npm (s\xF3 no reposit\xF3rio do Praeko). Os demais comandos funcionam normalmente.");
+    process.exit(1);
+  }
+  const r = spawnSync(process.execPath, [bin, ...args.slice(1)], { stdio: "inherit", env: { ...process.env, PRAEKO_STUDIO: "1" } });
+  process.exit(r.status ?? 1);
+}
+process.exit(await executarCli(args));