@praeko/cli 0.0.0-stage → 0.1.0

package/dist/chunks/chunk-QDZLRBTP.mjs

@@ -0,0 +1,1125 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  validarPedido
+} from "./chunk-Z325UM27.mjs";
+import {
+  __export
+} from "./chunk-LCFK6X55.mjs";
+
+// ../core/src/adaptadores/remoto.mjs
+var remoto_exports = {};
+__export(remoto_exports, {
+  REF_CHAVE: () => REF_CHAVE,
+  criar: () => criar,
+  itemDoContrato: () => itemDoContrato
+});
+
+// ../sdk/src/legacy.mjs
+var enc = (x) => encodeURIComponent(x);
+function fonte(x) {
+  if (x && typeof x.read === "function" && typeof x.size === "number") return x;
+  if (x && typeof x.ler === "function" && typeof x.tamanho === "number") return { size: x.tamanho, read: (i, n) => x.ler(i, n) };
+  if (typeof Blob !== "undefined" && x instanceof Blob) return { size: x.size, read: async (i, n) => new Uint8Array(await x.slice(i, i + n).arrayBuffer()) };
+  const u8 = x instanceof Uint8Array ? x : x instanceof ArrayBuffer ? new Uint8Array(x) : null;
+  if (!u8) throw new TypeError("fonte inv\xE1lida: use Uint8Array, ArrayBuffer, Blob ou { tamanho, ler(inicio, n) }");
+  return { size: u8.length, read: async (i, n) => u8.subarray(i, i + n) };
+}
+function addLegacy(a) {
+  const L = (method, path, { corpo, bytes, consulta, repetir, semChave } = {}) => a._req(method, path, { body: corpo, bytes, query: consulta, retry: repetir ?? method === "GET", noKey: semChave, legacy: true });
+  a.midia = {
+    iniciar: (meta) => L("POST", "/v1/midia", { corpo: meta }),
+    enviarParte: (id, n, bytes) => L("PUT", `/v1/midia/${id}/partes/${n}`, { bytes, repetir: true }),
+    enviarConteudo: (id, bytes) => L("PUT", `/v1/midia/${id}/conteudo`, { bytes, repetir: true }),
+    completar: (id) => L("POST", `/v1/midia/${id}/completar`),
+    obter: (id) => L("GET", `/v1/midia/${id}`),
+    listar: (tipo) => L("GET", "/v1/midia", { consulta: { tipo } }),
+    remover: (id) => L("DELETE", `/v1/midia/${id}`),
+    /** Uploads a whole media (legacy shapes: { id, … } with Portuguese fields). Prefer media.upload. */
+    enviar: async (origem, { tipo, nome, mime, parte = 16 * 1024 * 1024, aoProgredir } = {}) => {
+      const s = fonte(origem);
+      if (!tipo || !nome || !mime) throw new Error("midia.enviar: informe tipo, nome e mime");
+      if (s.size <= 32 * 1024 * 1024) {
+        const m2 = await a.midia.iniciar({ tipo, nome, mime, tamanho: s.size, simples: true });
+        const r = await a.midia.enviarConteudo(m2.id, await s.read(0, s.size));
+        aoProgredir?.(s.size, s.size);
+        return r;
+      }
+      const m = await a.midia.iniciar({ tipo, nome, mime, tamanho: s.size });
+      const tam = Math.max(m.parteMinima || 0, Math.min(parte, m.parteMaxima || parte));
+      for (let n = 1, pos = 0; pos < s.size; n++, pos += tam) {
+        await a.midia.enviarParte(m.id, n, await s.read(pos, tam));
+        aoProgredir?.(Math.min(pos + tam, s.size), s.size);
+      }
+      return a.midia.completar(m.id);
+    }
+  };
+  Object.assign(a.posts, {
+    criar: (pedido) => L("POST", "/v1/posts", { corpo: pedido }),
+    listar: (filtros = {}) => L("GET", "/v1/posts", { consulta: filtros }),
+    obter: (id) => L("GET", `/v1/posts/${enc(id)}`),
+    adotar: (corpo) => L("POST", "/v1/posts/adotar", { corpo }),
+    agendarYoutube: (id, quando) => L("POST", `/v1/posts/${enc(id)}/youtube/agendar`, { corpo: { quando } }),
+    editar: (id, mudancas) => L("PATCH", `/v1/posts/${enc(id)}`, { corpo: mudancas }),
+    publicarAgora: (id, { rede } = {}) => L("POST", `/v1/posts/${enc(id)}/publicar-agora`, { consulta: { rede } }),
+    cancelar: (id) => L("DELETE", `/v1/posts/${enc(id)}`),
+    comentar: (id, itemId) => L("POST", `/v1/posts/${enc(id)}/itens/${itemId}/comentar`)
+  });
+  a.canais = {
+    listar: ({ verificar } = {}) => L("GET", "/v1/canais", { consulta: { verificar: verificar ? 1 : void 0 } }),
+    vagas: (rede) => L("GET", `/v1/canais/${rede}/vagas`),
+    informarSeguidores: (rede, valor, { dia } = {}) => L("PUT", `/v1/canais/${rede}/seguidores`, { corpo: { valor, ...dia ? { dia } : {} } }),
+    seguidores: (rede) => L("GET", `/v1/canais/${rede}/seguidores`),
+    definirVagas: (rede, vagas, { fuso } = {}) => L("PUT", `/v1/canais/${rede}/vagas`, { corpo: { vagas, ...fuso ? { fuso } : {} } }),
+    conectar: (rede) => L("GET", `/v1/conexoes/${rede}/iniciar`),
+    desconectar: (rede) => L("DELETE", `/v1/conexoes/${rede}`),
+    enviarTokenInstagram: (corpo) => L("PUT", "/v1/conexoes/instagram/token", { corpo })
+  };
+  Object.assign(a.instagram, {
+    midias: ({ max, pagina } = {}) => L("GET", "/v1/instagram/midias", { consulta: { max, pagina } }),
+    comentarios: ({ midia, semResposta, ordem, max } = {}) => L("GET", "/v1/instagram/comentarios", { consulta: { midia, semResposta: semResposta ? 1 : void 0, ordem, max } }),
+    responder: (comentarioId, texto) => L("POST", `/v1/instagram/comentarios/${enc(comentarioId)}/responder`, { corpo: { texto } }),
+    ocultar: (comentarioId, ocultar = true) => L("POST", `/v1/instagram/comentarios/${enc(comentarioId)}/ocultar`, { corpo: { ocultar } }),
+    resolver: (comentarioId) => L("POST", `/v1/instagram/comentarios/${enc(comentarioId)}/resolver`),
+    reabrir: (comentarioId) => L("DELETE", `/v1/instagram/comentarios/${enc(comentarioId)}/resolver`)
+  });
+  a.comunidade = { comentarios: ({ rede, semResposta, ordem, max } = {}) => L("GET", "/v1/comentarios", { consulta: { rede, semResposta: semResposta ? 1 : void 0, ordem, max } }) };
+  Object.assign(a.youtube, {
+    lerVideo: (id) => L("GET", `/v1/youtube/videos/${enc(id)}`),
+    editarVideo: (id, { titulo, descricao, tags, simular } = {}) => L("PATCH", `/v1/youtube/videos/${enc(id)}`, { corpo: { titulo, descricao, tags, simular } }),
+    comentarios: ({ video, semResposta, ordem, max, pagina } = {}) => L("GET", "/v1/youtube/comentarios", { consulta: { video, semResposta: semResposta ? 1 : void 0, ordem, max, pagina } }),
+    resolver: (threadId) => L("POST", `/v1/youtube/comentarios/${enc(threadId)}/resolver`),
+    reabrir: (threadId) => L("DELETE", `/v1/youtube/comentarios/${enc(threadId)}/resolver`),
+    responder: (threadId, texto) => L("POST", `/v1/youtube/comentarios/${enc(threadId)}/responder`, { corpo: { texto } })
+  });
+  a.youtube.videos = ({ max, pagina } = {}) => L("GET", "/v1/youtube/videos", { consulta: { max, pagina } });
+  a.insights.obter = ({ de, ate, canal, etiqueta, tipo, comparar, ordem, direcao, pagina, limite } = {}) => L("GET", "/v1/insights", { consulta: { de, ate, canal, etiqueta, tipo, comparar: comparar ? 1 : void 0, ordem, direcao, pagina, limite } });
+  a.insights.importar = ({ rede = "tudo", simular } = {}) => L("POST", "/v1/insights/importar", { consulta: { rede, simular: simular ? 1 : void 0 } });
+  a.conteudo = { listar: ({ rede, tipo, de, ate, ordem, limite, deslocamento } = {}) => L("GET", "/v1/conteudo", { consulta: { rede, tipo, de, ate, ordem, limite, deslocamento } }) };
+  a.mencoes = ({ rede } = {}) => L("GET", "/v1/mencoes", { consulta: { rede } });
+  a.chaves = {
+    listar: () => L("GET", "/v1/chaves"),
+    criar: (nome, escopo = "escrita") => L("POST", "/v1/chaves", { corpo: { nome, escopo } }),
+    revogar: (id) => L("DELETE", `/v1/chaves/${id}`)
+  };
+  a.calendario = ({ de, ate, canal, etiqueta } = {}) => L("GET", "/v1/calendario", { consulta: { de, ate, canal, etiqueta } });
+  a.saude = () => L("GET", "/saude", { semChave: true });
+}
+
+// ../sdk/src/index.mjs
+var PraekoError = class extends Error {
+  constructor(status, code, message, details) {
+    super(message);
+    this.name = "PraekoError";
+    this.status = status;
+    this.code = code;
+    this.details = details;
+  }
+  /** @deprecated use `code` */
+  get codigo() {
+    return this.code;
+  }
+  /** @deprecated use `details` */
+  get detalhes() {
+    return this.details;
+  }
+  /** @deprecated use `message` */
+  get mensagem() {
+    return this.message;
+  }
+};
+var SIMPLE_MAX = 32 * 1024 * 1024;
+var DEFAULT_PART = 16 * 1024 * 1024;
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function asSource(x) {
+  if (x && typeof x.read === "function" && typeof x.size === "number") return x;
+  if (x && typeof x.ler === "function" && typeof x.tamanho === "number") return { size: x.tamanho, read: (i, n) => x.ler(i, n) };
+  if (typeof Blob !== "undefined" && x instanceof Blob) return { size: x.size, read: async (i, n) => new Uint8Array(await x.slice(i, i + n).arrayBuffer()) };
+  const u8 = x instanceof Uint8Array ? x : x instanceof ArrayBuffer ? new Uint8Array(x) : null;
+  if (!u8) throw new TypeError("invalid source: use Uint8Array, ArrayBuffer, Blob or { size, read(start, n) }");
+  return { size: u8.length, read: async (i, n) => u8.subarray(i, i + n) };
+}
+var ref = (id) => encodeURIComponent(id);
+var idem = (o) => o && o.idempotencyKey ? { idempotencyKey: o.idempotencyKey } : {};
+var uuid = () => globalThis.crypto?.randomUUID ? globalThis.crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}-${Math.random().toString(36).slice(2)}`;
+var Praeko = class {
+  // `cookies: true` (browser, same origin): no key; the panel session cookie authenticates.
+  /** @param {{ url: string, key?: string, cookies?: boolean, chave?: string, fetch?: typeof fetch, retries?: number, wait?: (ms:number)=>Promise<void> }} o  (`chave`, `tentativas`, `espera`: deprecated names) */
+  constructor(o = {}) {
+    const { url, key = o.chave, cookies = false, fetch: f = globalThis.fetch, retries = o.tentativas ?? 3, wait = o.espera ?? sleep } = o;
+    if (!url) throw new Error("Praeko: missing service url (falta a url do servi\xE7o)");
+    if (!key && !cookies) throw new Error("Praeko: missing API key praeko_\u2026 (falta a chave)");
+    this.url = String(url).replace(/\/+$/, "");
+    this._key = key;
+    this._cookies = !key && cookies;
+    this._fetch = f;
+    this._retries = retries;
+    this._wait = wait;
+    const a = this;
+    this.media = {
+      create: (meta, o2) => a._req("POST", "/v1/media", { body: meta, ...idem(o2) }),
+      uploadPart: (id, n, bytes) => a._req("PUT", `/v1/media/${ref(id)}/parts/${n}`, { bytes, retry: true }),
+      uploadContent: (id, bytes) => a._req("PUT", `/v1/media/${ref(id)}/content`, { bytes, retry: true }),
+      complete: (id, o2) => a._req("POST", `/v1/media/${ref(id)}/complete`, idem(o2)),
+      get: (id) => a._req("GET", `/v1/media/${ref(id)}`),
+      list: (type) => a._req("GET", "/v1/media", { query: { type } }),
+      remove: (id) => a._req("DELETE", `/v1/media/${ref(id)}`),
+      /** Uploads a whole file (one PUT or parts, depending on size). Returns the ready media { id, … }. */
+      upload: async (source, { type, name, mime, part = DEFAULT_PART, onProgress } = {}) => {
+        const f2 = asSource(source);
+        if (!type || !name || !mime) throw new Error("media.upload: provide type, name and mime");
+        if (f2.size <= SIMPLE_MAX) {
+          const m2 = await a.media.create({ type, name, mime, size: f2.size, simple: true });
+          const r = await a.media.uploadContent(m2.id, await f2.read(0, f2.size));
+          onProgress?.(f2.size, f2.size);
+          return r;
+        }
+        const m = await a.media.create({ type, name, mime, size: f2.size });
+        const size = Math.max(m.minPartSize || 0, Math.min(part, m.maxPartSize || part));
+        for (let n = 1, pos = 0; pos < f2.size; n++, pos += size) {
+          await a.media.uploadPart(m.id, n, await f2.read(pos, size));
+          onProgress?.(Math.min(pos + size, f2.size), f2.size);
+        }
+        return a.media.complete(m.id);
+      }
+    };
+    this.posts = {
+      /** `o.idempotencyKey`: a string (or `true` for a fresh UUID) makes the call safe to retry: the server replays the first response instead of creating a second post (see docs/idempotencia.md). */
+      create: (request, o2) => a._req("POST", "/v1/posts", { body: request, ...idem(o2) }),
+      list: (filters = {}) => a._req("GET", "/v1/posts", { query: filters }),
+      get: (id) => a._req("GET", `/v1/posts/${ref(id)}`),
+      /** Registers a Reel already scheduled in Buffer ({ id, title, network: "instagram", scheduledFor, external: { provider: "buffer", id } }); does not call Buffer. */
+      adopt: (body, o2) => a._req("POST", "/v1/posts/adopt", { body, ...idem(o2) }),
+      scheduleYoutube: (id, scheduledFor, o2) => a._req("POST", `/v1/posts/${ref(id)}/youtube/schedule`, { body: { scheduledFor }, ...idem(o2) }),
+      update: (id, changes, o2) => a._req("PATCH", `/v1/posts/${ref(id)}`, { body: changes, ...idem(o2) }),
+      publishNow: (id, { network, idempotencyKey } = {}) => a._req("POST", `/v1/posts/${ref(id)}/publish-now`, { query: { network }, ...idem({ idempotencyKey }) }),
+      cancel: (id, o2) => a._req("DELETE", `/v1/posts/${ref(id)}`, idem(o2)),
+      comment: (id, itemId) => a._req("POST", `/v1/posts/${ref(id)}/items/${ref(itemId)}/comment`)
+    };
+    this.channels = {
+      list: ({ verify } = {}) => a._req("GET", "/v1/channels", { query: { verify: verify ? 1 : void 0 } }),
+      /** `channel`: id of one account when the network has several (GET /v1/channels lists them); without it the default channel. */
+      slots: (network, { channel } = {}) => a._req("GET", `/v1/channels/${network}/slots`, { query: { channel } }),
+      setSlots: (network, slots, { timezone, channel } = {}) => a._req("PUT", `/v1/channels/${network}/slots`, { query: { channel }, body: { slots, ...timezone ? { timezone } : {} } }),
+      /** Manual follower count (Instagram only; TikTok comes from the API): PUT { value, day? }; the latest records: GET. */
+      setFollowers: (network, value, { day, channel } = {}) => a._req("PUT", `/v1/channels/${network}/followers`, { query: { channel }, body: { value, ...day ? { day } : {} } }),
+      followers: (network, { channel } = {}) => a._req("GET", `/v1/channels/${network}/followers`, { query: { channel } }),
+      /** `network`: youtube | tiktok | meta (Instagram login). For `meta`, `replace: true` is REQUIRED to replace an existing connection; `instagram` picks the account by username when the login reaches several. */
+      connect: (network, { replace, add, instagram, instagramId, probe } = {}) => a._req("GET", `/v1/connections/${network}/start`, { query: { replace: replace ? "true" : void 0, add: add ? "true" : void 0, instagram, instagram_id: instagramId, probe: probe ? "true" : void 0 } }),
+      /** Makes one account the default of its network (the one used when a network route has no `channel`). */
+      setDefault: (channel) => a._req("PUT", `/v1/channels/${encodeURIComponent(channel)}/default`),
+      /** Removes a DISCONNECTED account from the list (history stays). */
+      remove: (channel) => a._req("DELETE", `/v1/channels/${encodeURIComponent(channel)}`),
+      /** Disconnects ONE account of youtube | tiktok | instagram (Meta token only): revokes the token (best effort) and deletes what the server stored. The channel and its history stay; if it was the default, another connected account takes over. */
+      disconnect: (network, { channel } = {}) => a._req("DELETE", `/v1/connections/${network}`, { query: { channel } }),
+      /** (admin) Sends the Meta API token for Instagram: { token, userId, username?, type?, host? }. The server validates it with Meta and stores it encrypted. */
+      sendInstagramToken: (body) => a._req("PUT", "/v1/connections/instagram/token", { body })
+    };
+    this.tiktok = { creator: ({ channel } = {}) => a._req("GET", "/v1/tiktok/creator", { query: { channel } }) };
+    this.instagram = {
+      media: ({ max, page } = {}) => a._req("GET", "/v1/instagram/media", { query: { max, page } }),
+      /** `sort`: recent | comments | views. Returns { comments, mediaItems, pending, next }. */
+      comments: ({ media, unanswered, sort, max } = {}) => a._req("GET", "/v1/instagram/comments", { query: { media, unanswered: unanswered ? 1 : void 0, sort, max } }),
+      reply: (commentId, text, o2) => a._req("POST", `/v1/instagram/comments/${ref(commentId)}/reply`, { body: { text }, ...idem(o2) }),
+      hide: (commentId, hide = true) => a._req("POST", `/v1/instagram/comments/${ref(commentId)}/hide`, { body: { hide } }),
+      resolve: (commentId) => a._req("POST", `/v1/instagram/comments/${ref(commentId)}/resolve`),
+      reopen: (commentId) => a._req("DELETE", `/v1/instagram/comments/${ref(commentId)}/resolve`)
+    };
+    this.community = { comments: ({ network, unanswered, sort, max } = {}) => a._req("GET", "/v1/comments", { query: { network, unanswered: unanswered ? 1 : void 0, sort, max } }) };
+    this.youtube = {
+      listVideos: ({ max, page } = {}) => a._req("GET", "/v1/youtube/videos", { query: { max, page } }),
+      getVideo: (id) => a._req("GET", `/v1/youtube/videos/${ref(id)}`),
+      /** `dryRun: true` returns { before, after } without writing. */
+      editVideo: (id, { title, description, tags, dryRun } = {}) => a._req("PATCH", `/v1/youtube/videos/${ref(id)}`, { body: { title, description, tags, dryRun } }),
+      /** `sort`: recent | comments | views. Returns { comments, next, pending } with `resolved` on each thread. */
+      comments: ({ video, unanswered, sort, max, page } = {}) => a._req("GET", "/v1/youtube/comments", { query: { video, unanswered: unanswered ? 1 : void 0, sort, max, page } }),
+      resolve: (threadId) => a._req("POST", `/v1/youtube/comments/${ref(threadId)}/resolve`),
+      reopen: (threadId) => a._req("DELETE", `/v1/youtube/comments/${ref(threadId)}/resolve`),
+      reply: (threadId, text, o2) => a._req("POST", `/v1/youtube/comments/${ref(threadId)}/reply`, { body: { text }, ...idem(o2) })
+    };
+    this.insights = {
+      /** Cards, top 5, channels, summary and the 48 h reading of the period (ISO). Server default: the last 30 days. */
+      get: ({ from, to, channel, tag, type, compare, sort, direction, page, limit } = {}) => a._req("GET", "/v1/insights", { query: { from, to, channel, tag, type, compare: compare ? 1 : void 0, sort, direction, page, limit } }),
+      /** (admin) Imports the history of YouTube, Instagram (via Buffer) and TikTok. `network`: all | youtube | instagram | tiktok; `dryRun` only counts. */
+      import: ({ network = "all", dryRun } = {}) => a._req("POST", "/v1/insights/import", { query: { network, dryRun: dryRun ? 1 : void 0 } })
+    };
+    this.content = { list: ({ network, type, from, to, sort, limit, offset } = {}) => a._req("GET", "/v1/content", { query: { network, type, from, to, sort, limit, offset } }) };
+    this.apiKeys = {
+      list: () => a._req("GET", "/v1/api-keys"),
+      create: (name, scope = "write", expiresInDays, o2) => a._req("POST", "/v1/api-keys", { body: { name, scope, ...expiresInDays ? { expiresInDays } : {} }, ...idem(o2) }),
+      revoke: (id) => a._req("DELETE", `/v1/api-keys/${ref(id)}`)
+    };
+    this.usage = {
+      /** Totals of the last `days` (1-30, default 7): { total, succeeded, errors, p95Ms, peakPerMinute, limitPerMinute, byDay, byHour (days=1), byKey }. */
+      get: ({ days } = {}) => a._req("GET", "/v1/usage", { query: { days } }),
+      /** Newest first: { records, next }. `status`: 2xx|3xx|4xx|5xx or a code; `key`: key id or "session"; `route`: substring; pass `next` as `cursor`. */
+      log: ({ key: key2, status, route, method, days, limit, cursor } = {}) => a._req("GET", "/v1/usage/log", { query: { key: key2, status, route, method, days, limit, cursor } })
+    };
+    this.preferences = {
+      get: () => a._req("GET", "/v1/preferences"),
+      put: ({ theme, language, notifications } = {}) => a._req("PUT", "/v1/preferences", { body: { theme, language, notifications } })
+    };
+    this.webhooks = {
+      list: () => a._req("GET", "/v1/webhooks"),
+      create: ({ url: url2, events, active, idempotencyKey } = {}) => a._req("POST", "/v1/webhooks", { body: { url: url2, events, active }, ...idem({ idempotencyKey }) }),
+      get: (id) => a._req("GET", `/v1/webhooks/${ref(id)}`),
+      update: (id, { url: url2, events, active } = {}) => a._req("PATCH", `/v1/webhooks/${ref(id)}`, { body: { url: url2, events, active } }),
+      remove: (id) => a._req("DELETE", `/v1/webhooks/${ref(id)}`),
+      /** Sends a ping.test now and returns { delivery }. */
+      test: (id) => a._req("POST", `/v1/webhooks/${ref(id)}/test`),
+      deliveries: (id, { limit } = {}) => a._req("GET", `/v1/webhooks/${ref(id)}/deliveries`, { query: { limit } }),
+      redeliver: (id, deliveryId, o2) => a._req("POST", `/v1/webhooks/${ref(id)}/deliveries/${ref(deliveryId)}/retry`, idem(o2)),
+      rotateSecret: (id, o2) => a._req("POST", `/v1/webhooks/${ref(id)}/rotate-secret`, idem(o2))
+    };
+    this.ideas = {
+      list: () => a._req("GET", "/v1/ideas"),
+      create: ({ title, note, group, tags, idempotencyKey } = {}) => a._req("POST", "/v1/ideas", { body: { title, note, group, tags }, ...idem({ idempotencyKey }) }),
+      update: (id, { title, note, group, tags } = {}) => a._req("PATCH", `/v1/ideas/${ref(id)}`, { body: { title, note, group, tags } }),
+      remove: (id) => a._req("DELETE", `/v1/ideas/${ref(id)}`),
+      import: (ideas, o2) => a._req("POST", "/v1/ideas/import", { body: { ideas }, ...idem(o2) })
+    };
+    addLegacy(this);
+  }
+  calendar({ from, to, channel, tag } = {}) {
+    return this._req("GET", "/v1/calendar", { query: { from, to, channel, tag } });
+  }
+  mentions({ network } = {}) {
+    return this._req("GET", "/v1/mentions", { query: { network } });
+  }
+  health() {
+    return this._req("GET", "/health", { noKey: true });
+  }
+  /**
+   * One HTTP call. `legacy: true` (only for the deprecated Portuguese aliases) skips the `X-Praeko-Contract: en` header, so the shared paths
+   * (/v1/posts, /v1/insights, /v1/youtube/videos) answer in the old shape.
+   */
+  async _req(method, path, { body, bytes, query, retry = method === "GET", noKey = false, legacy = false, idempotencyKey } = {}) {
+    if (idempotencyKey) {
+      retry = true;
+      idempotencyKey = idempotencyKey === true ? uuid() : String(idempotencyKey);
+    }
+    const q = query ? Object.entries(query).filter(([, v]) => v !== void 0 && v !== null && v !== "").map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&") : "";
+    const url = `${this.url}${path}${q ? "?" + q : ""}`;
+    const init = { method, headers: { ...noKey || this._cookies ? {} : { authorization: `Bearer ${this._key}` }, ...legacy ? {} : { "x-praeko-contract": "en" } } };
+    if (idempotencyKey) init.headers["idempotency-key"] = idempotencyKey;
+    if (bytes !== void 0) {
+      init.body = bytes;
+      init.headers["content-type"] = "application/octet-stream";
+    } else if (body !== void 0) {
+      init.body = JSON.stringify(body);
+      init.headers["content-type"] = "application/json";
+    }
+    let last;
+    for (let i = 0; i < (retry ? this._retries : 1); i++) {
+      if (i) await this._wait(Math.min(8e3, 500 * 2 ** i));
+      let r;
+      try {
+        r = await this._fetch(url, init);
+      } catch (e2) {
+        last = new PraekoError(0, "network", `network failure: ${e2.message}`);
+        continue;
+      }
+      const txt = await r.text();
+      let j = null;
+      try {
+        j = txt ? JSON.parse(txt) : null;
+      } catch {
+      }
+      if (r.ok) return j;
+      const e = j?.error ?? (j?.erro && { code: j.erro.codigo, message: j.erro.mensagem, details: j.erro.detalhes });
+      last = new PraekoError(r.status, e?.code || "http_error", e?.message || `HTTP ${r.status}`, e?.details);
+      if (!(r.status === 429 || r.status >= 500)) throw last;
+    }
+    throw last;
+  }
+};
+
+// ../sdk/src/node.mjs
+import { closeSync, fstatSync, openSync, readSync } from "node:fs";
+import { basename, extname } from "node:path";
+var MIME = { ".mp4": "video/mp4", ".mov": "video/quicktime", ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg" };
+var mimeOf = (path) => MIME[extname(path).toLowerCase()] || null;
+function fileSource(path) {
+  const fd = openSync(path, "r"), size = fstatSync(fd).size;
+  const read = async (start, n) => {
+    const b = Buffer.alloc(Math.min(n, size - start));
+    readSync(fd, b, 0, b.length, start);
+    return b;
+  };
+  const close = () => closeSync(fd), name = basename(path);
+  return { size, name, mime: mimeOf(path), read, close, tamanho: size, nome: name, ler: read, fechar: close };
+}
+async function uploadFile(cliente, path, { type, onProgress, tipo, aoProgredir } = {}) {
+  const f = fileSource(path);
+  try {
+    if (!f.mime) throw new Error(`n\xE3o sei o tipo de ${path} (use .mp4, .mov, .png ou .jpg)`);
+    const t = type || tipo || (f.mime.startsWith("video/") ? "video" : "cover"), cb = onProgress || aoProgredir;
+    if (cliente.media?.upload) return await cliente.media.upload(f, { type: t === "capa" ? "cover" : t, name: f.name, mime: f.mime, onProgress: cb });
+    return await cliente.midia.enviar(f, { tipo: t === "cover" ? "capa" : t, nome: f.name, mime: f.mime, aoProgredir: cb });
+  } finally {
+    f.close();
+  }
+}
+
+// ../sdk/src/contract.mjs
+var ROUTES = [
+  { key: "health", method: "GET", path: "/health", legacy: "/saude", scope: "public", summary: "Liveness probe" },
+  { key: "health.v1", method: "GET", path: "/v1/health", legacy: "/v1/saude", scope: "public", summary: "Liveness probe (versioned path)" },
+  { key: "connections.callback", method: "GET", path: "/connections/:network/callback", legacy: "/conexoes/:rede/retorno", scope: "public", raw: true, summary: "OAuth redirect target (HTML page; youtube, tiktok, meta); registered redirect URIs keep working" },
+  { key: "media.public", method: "GET", path: "/v1/m/:id/:token/:name", legacy: null, scope: "public", raw: true, summary: "Public media by token (Range supported); also served at /m/\u2026" },
+  { key: "media.public", method: "HEAD", path: "/v1/m/:id/:token/:name", legacy: null, scope: "public", raw: true, summary: "Same as GET, headers only" },
+  { key: "connections.start", method: "GET", path: "/v1/connections/:network/start", legacy: "/v1/conexoes/:rede/iniciar", scope: "write", summary: "Start OAuth for youtube|tiktok|meta (Instagram login); for youtube it always asks for `youtube.upload`, `youtube.force-ssl` and `yt-analytics.readonly` (retention, impressions, CTR; the consent screen lets the user untick a scope, and the channel then stays `reauthorize` in the retention view); the old `analytics=1` is accepted and ignored; returns the authorization URL. A different account of the same network becomes another channel; the same account is reconnected. `meta` takes `replace=true` (replace the token of an existing connection), `add=true` (connect ANOTHER Instagram account as a new channel) and `instagram=<username>`, `instagram_id=<id|current>`, `probe=true` (report only, stores nothing)" },
+  { key: "connections.disconnect", method: "DELETE", path: "/v1/connections/:network", legacy: "/v1/conexoes/:rede", scope: "write", summary: "Disconnect one account of youtube|tiktok|instagram (Meta token only; the Buffer channel is never touched); `channel` picks the account, without it the default channel; other accounts, the channel and its history stay. If it was the default, another connected account takes over" },
+  { key: "connections.instagramToken", method: "PUT", path: "/v1/connections/instagram/token", legacy: "/v1/conexoes/instagram/token", scope: "admin", body: "json", summary: "Store the Meta API token for Instagram (encrypted)" },
+  { key: "channels.list", method: "GET", path: "/v1/channels", legacy: "/v1/canais", scope: "read", summary: "One item per connected channel (several accounts of a network = several items, `default` marks the one used without `channel`), plus a not-connected item for a network with none; status and slots count" },
+  { key: "channels.default", method: "PUT", path: "/v1/channels/:channel/default", legacy: "/v1/canais/:canal/padrao", scope: "write", summary: "Make this account the default of its network (used when a network route has no `channel`); the other accounts of the same network lose the mark. 404 channel_not_found if it is not an active channel of this workspace" },
+  { key: "channels.remove", method: "DELETE", path: "/v1/channels/:channel", legacy: "/v1/canais/:canal", scope: "write", summary: "Remove a DISCONNECTED account from the list (history stays; refused while connected, with pending items, or for the Buffer Instagram channel)" },
+  { key: "channels.avatar", method: "GET", path: "/v1/channels/:network/avatar", legacy: "/v1/canais/:rede/avatar", scope: "read", summary: "Channel avatar image (`channel` picks the account)" },
+  { key: "tiktok.creator", method: "GET", path: "/v1/tiktok/creator", legacy: "/v1/tiktok/criador", scope: "read", summary: "What the connected TikTok account accepts (creator_info); `channel` picks the account" },
+  { key: "channels.slots.get", method: "GET", path: "/v1/channels/:network/slots", legacy: "/v1/canais/:rede/vagas", scope: "read", summary: "Weekly publishing slots of a channel (`channel` picks the account, else the default)" },
+  { key: "channels.slots.put", method: "PUT", path: "/v1/channels/:network/slots", legacy: "/v1/canais/:rede/vagas", scope: "write", body: "json", summary: "Replace the weekly slots of one channel (`channel`; reorganizes its queued items)" },
+  { key: "channels.followers.put", method: "PUT", path: "/v1/channels/:network/followers", legacy: "/v1/canais/:rede/seguidores", scope: "write", body: "json", summary: "Manual follower count (Instagram only; `channel` picks the account)" },
+  { key: "channels.followers.get", method: "GET", path: "/v1/channels/:network/followers", legacy: "/v1/canais/:rede/seguidores", scope: "read", summary: "Last 60 daily follower records (`channel` picks the account)" },
+  { key: "media.create", method: "POST", path: "/v1/media", legacy: "/v1/midia", scope: "write", body: "json", summary: "Start a media upload" },
+  { key: "media.list", method: "GET", path: "/v1/media", legacy: "/v1/midia", scope: "read", summary: "List media (last 100); older videos get durationMs/width/height filled on first read" },
+  { key: "media.get", method: "GET", path: "/v1/media/:id", legacy: "/v1/midia/:id", scope: "read", summary: "One media item (with publicUrl when ready; videos also carry durationMs, width and height when the container header says so)" },
+  { key: "media.part", method: "PUT", path: "/v1/media/:id/parts/:part", legacy: "/v1/midia/:id/partes/:n", scope: "write", body: "bytes", summary: "Upload one part (raw bytes)" },
+  { key: "media.content.put", method: "PUT", path: "/v1/media/:id/content", legacy: "/v1/midia/:id/conteudo", scope: "write", body: "bytes", summary: "Single-request upload (media created with simple: true)" },
+  { key: "media.content.get", method: "GET", path: "/v1/media/:id/content", legacy: "/v1/midia/:id/conteudo", scope: "read", summary: "The file (Bearer, Range supported)" },
+  { key: "media.content.head", method: "HEAD", path: "/v1/media/:id/content", legacy: "/v1/midia/:id/conteudo", scope: "read", summary: "Same as GET, headers only" },
+  { key: "media.complete", method: "POST", path: "/v1/media/:id/complete", legacy: "/v1/midia/:id/completar", scope: "write", summary: "Join the parts" },
+  { key: "media.delete", method: "DELETE", path: "/v1/media/:id", legacy: "/v1/midia/:id", scope: "write", summary: "Remove a media item (refused while used by a pending post)" },
+  { key: "posts.create", method: "POST", path: "/v1/posts", legacy: "/v1/posts", scope: "write", body: "json", summary: "Create a post with one item per network (queue, fixed time or draft); an item may carry `channel` (account of that network; default channel without it)" },
+  { key: "posts.adopt", method: "POST", path: "/v1/posts/adopt", legacy: "/v1/posts/adotar", scope: "write", body: "json", summary: "Register a Reel already scheduled in Buffer (does not call Buffer)" },
+  { key: "posts.list", method: "GET", path: "/v1/posts", legacy: "/v1/posts", scope: "read", summary: "List posts (filters: state, channel, tag)" },
+  { key: "posts.get", method: "GET", path: "/v1/posts/:id", legacy: "/v1/posts/:id", scope: "read", summary: "One post with its items and actions" },
+  { key: "posts.update", method: "PATCH", path: "/v1/posts/:id", legacy: "/v1/posts/:id", scope: "write", body: "json", summary: "Edit title, texts, media, tags, items; move to draft/queue" },
+  { key: "posts.cancel", method: "DELETE", path: "/v1/posts/:id", legacy: "/v1/posts/:id", scope: "write", summary: "Cancel the pending items of a post" },
+  { key: "posts.publishNow", method: "POST", path: "/v1/posts/:id/publish-now", legacy: "/v1/posts/:id/publicar-agora", scope: "write", summary: "Take pending items out of the queue and publish now (?network=)" },
+  { key: "posts.youtubeSchedule", method: "POST", path: "/v1/posts/:id/youtube/schedule", legacy: "/v1/posts/:id/youtube/agendar", scope: "write", body: "json", summary: "Schedule publication of a video already uploaded to YouTube (private)" },
+  { key: "posts.itemComment", method: "POST", path: "/v1/posts/:id/items/:item/comment", legacy: "/v1/posts/:id/itens/:destino/comentar", scope: "write", summary: "Release the stored pinned comment of an item" },
+  { key: "calendar.get", method: "GET", path: "/v1/calendar", legacy: "/v1/calendario", scope: "read", summary: "Items in a period plus free slots" },
+  { key: "insights.get", method: "GET", path: "/v1/insights", legacy: "/v1/insights", scope: "read", summary: "Cards, top posts, per-channel results (one row per account when a network has several; `channel` filters one account), summary, 48 h reading" },
+  { key: "insights.retention", method: "GET", path: "/v1/insights/retention", legacy: "/v1/insights/retention", scope: "read", summary: "Retention, impressions and CTR per post of the period (`from`, `to`, `channel`, `limit` 1-200). YouTube: audience retention (YouTube Analytics API), thumbnail impressions and CTR (YouTube Reporting API); Instagram: reach, watch time and skip rate (Meta API). `channels[].state` says whether each account can deliver them: `ready`, `pending` (first report still being generated), `reauthorize` (reconnect YouTube once and keep the Analytics permission ticked), `unavailable` or `error`; a missing number is `null`, never 0" },
+  { key: "insights.retention.item", method: "GET", path: "/v1/insights/:item/retention", legacy: "/v1/insights/:item/retention", scope: "read", summary: "One post (item id or imported content id) with its retention `curve`: points of `position` (0..1 of the video), `watched` (audienceWatchRatio, above 1 when viewers rewatch) and `relative` (relativeRetentionPerformance, 0.5 = median of similar-length videos)" },
+  { key: "insights.import", method: "POST", path: "/v1/insights/import", legacy: "/v1/insights/importar", scope: "admin", query: { network: { all: "tudo" } }, summary: "Import history from YouTube, Buffer (Instagram) and TikTok (every connected account; `channel` with a network limits it to one)" },
+  { key: "content.list", method: "GET", path: "/v1/content", legacy: "/v1/conteudo", scope: "read", summary: "Everything already published (Praeko + imported)" },
+  { key: "youtube.videos", method: "GET", path: "/v1/youtube/videos", legacy: "/v1/youtube/videos", scope: "read", summary: "Channel videos (including private and scheduled); `channel` picks the account" },
+  { key: "youtube.video", method: "GET", path: "/v1/youtube/videos/:id", legacy: "/v1/youtube/videos/:id", scope: "read", summary: "One video" },
+  { key: "youtube.editVideo", method: "PATCH", path: "/v1/youtube/videos/:id", legacy: "/v1/youtube/videos/:id", scope: "write", body: "json", summary: "Edit title/description/tags (dryRun: true returns before/after only)" },
+  { key: "youtube.comments", method: "GET", path: "/v1/youtube/comments", legacy: "/v1/youtube/comentarios", scope: "read", summary: "Comment threads (`channel` picks the account)" },
+  { key: "youtube.reply", method: "POST", path: "/v1/youtube/comments/:id/reply", legacy: "/v1/youtube/comentarios/:id/responder", scope: "write", body: "json", summary: "Reply to a thread (writes to YouTube)" },
+  { key: "youtube.resolve", method: "POST", path: "/v1/youtube/comments/:id/resolve", legacy: "/v1/youtube/comentarios/:id/resolver", scope: "write", summary: "Mark a thread as resolved (Praeko only)" },
+  { key: "youtube.reopen", method: "DELETE", path: "/v1/youtube/comments/:id/resolve", legacy: "/v1/youtube/comentarios/:id/resolver", scope: "write", summary: "Reopen a resolved thread" },
+  { key: "instagram.media", method: "GET", path: "/v1/instagram/media", legacy: "/v1/instagram/midias", scope: "read", summary: "Profile media grid (Meta API)" },
+  { key: "instagram.comments", method: "GET", path: "/v1/instagram/comments", legacy: "/v1/instagram/comentarios", scope: "read", summary: "Instagram comments (Meta API)" },
+  { key: "instagram.reply", method: "POST", path: "/v1/instagram/comments/:id/reply", legacy: "/v1/instagram/comentarios/:id/responder", scope: "write", body: "json", summary: "Reply to a comment (writes to Instagram)" },
+  { key: "instagram.hide", method: "POST", path: "/v1/instagram/comments/:id/hide", legacy: "/v1/instagram/comentarios/:id/ocultar", scope: "write", body: "json", summary: "Hide or unhide a comment" },
+  { key: "instagram.resolve", method: "POST", path: "/v1/instagram/comments/:id/resolve", legacy: "/v1/instagram/comentarios/:id/resolver", scope: "write", summary: "Mark a comment as resolved (Praeko only)" },
+  { key: "instagram.reopen", method: "DELETE", path: "/v1/instagram/comments/:id/resolve", legacy: "/v1/instagram/comentarios/:id/resolver", scope: "write", summary: "Reopen a resolved comment" },
+  { key: "comments.list", method: "GET", path: "/v1/comments", legacy: "/v1/comentarios", scope: "read", query: { network: { all: "todas" } }, summary: "Comments of all networks together, from EVERY active account of each network (each comment carries `channel`; `channel` filters one account; an account that fails goes to `errors`, the others still answer)" },
+  { key: "mentions.list", method: "GET", path: "/v1/mentions", legacy: "/v1/mencoes", scope: "read", query: { network: { all: "todas" } }, summary: "Mentions (Instagram by tag; YouTube has none)" },
+  { key: "apiKeys.list", method: "GET", path: "/v1/api-keys", legacy: "/v1/chaves", scope: "admin", summary: "List API keys (never the secret)" },
+  { key: "apiKeys.create", method: "POST", path: "/v1/api-keys", legacy: "/v1/chaves", scope: "admin", body: "json", summary: "Create a key (the secret is shown once)" },
+  { key: "apiKeys.revoke", method: "DELETE", path: "/v1/api-keys/:id", legacy: "/v1/chaves/:id", scope: "admin", summary: "Revoke a key" },
+  // Rotas nascidas depois do contrato novo: sem caminho em português; o "legacy" é o mesmo caminho (sem o cabeçalho, a forma interna), como /v1/insights.
+  { key: "usage.get", method: "GET", path: "/v1/usage", legacy: "/v1/usage", scope: "read", summary: "API usage of this workspace over the last `days` (1-30, default 7, UTC): total, succeeded (< 400), errors, p95 duration, peak requests in one minute vs the per-minute limit, `byDay`, `byHour` (only with days=1: the last 24 hours) and `byKey` (`session` = the panel)" },
+  { key: "usage.log", method: "GET", path: "/v1/usage/log", legacy: "/v1/usage/log", scope: "read", summary: "Request log, newest first, kept 30 days; metadata only (method, route template without ids, status, duration, key), never bodies, headers or query. Filters: `key` (id or `session`), `status` (`2xx`|`3xx`|`4xx`|`5xx` or a code), `route` (substring), `method`, `days` (1-30); `limit` (1-200, default 50) and `cursor` (the `next` of the previous page)" },
+  { key: "preferences.get", method: "GET", path: "/v1/preferences", legacy: "/v1/preferences", scope: "read", summary: "Panel preferences of the signed-in user in this workspace (an API key reads the workspace row): `theme` (light, dark, system), `language` (pt-BR, en) and `notifications` per event (`postSent`, `postFailed`, `scheduledFail`, `weeklySummary`, `newComment`) with `email` and `panel` flags. Missing values come back as the defaults (dark, pt-BR, no e-mail, panel on)" },
+  { key: "preferences.put", method: "PUT", path: "/v1/preferences", legacy: "/v1/preferences", scope: "write", body: "json", summary: "Change preferences; partial (only the fields sent change) and strict (unknown field or value is 422 invalid_field). Returns the full preferences. `postSent`, `postFailed` and `scheduledFail` e-mails are sent by the server when `email` is true; `weeklySummary` and `newComment` are stored but no sender exists yet" },
+  { key: "webhooks.list", method: "GET", path: "/v1/webhooks", legacy: "/v1/webhooks", scope: "admin", summary: "Outgoing webhooks of this workspace (never the secret: only `secretHint`), with the delivery success of the last 7 days (`recentDeliveries`) and the subscribable `events`" },
+  { key: "webhooks.create", method: "POST", path: "/v1/webhooks", legacy: "/v1/webhooks", scope: "admin", body: "json", summary: "Create a webhook: `url` (https, public host; private IPs, localhost and cloud metadata are refused with unsafe_url), `events` (post.sent, post.failed, post.scheduled-fail; default the first two), `active`. The signing `secret` is returned ONCE. Max 10 per workspace" },
+  { key: "webhooks.get", method: "GET", path: "/v1/webhooks/:id", legacy: "/v1/webhooks/:id", scope: "admin", summary: "One webhook (no secret)" },
+  { key: "webhooks.update", method: "PATCH", path: "/v1/webhooks/:id", legacy: "/v1/webhooks/:id", scope: "admin", body: "json", summary: "Change `url`, `events` or `active`. Pausing discards the pending deliveries; re-activating resets the failure count" },
+  { key: "webhooks.delete", method: "DELETE", path: "/v1/webhooks/:id", legacy: "/v1/webhooks/:id", scope: "admin", summary: "Delete a webhook and its delivery history" },
+  { key: "webhooks.test", method: "POST", path: "/v1/webhooks/:id/test", legacy: "/v1/webhooks/:id/test", scope: "admin", summary: "Send a `ping.test` event now (even when paused) and return the `delivery` result; it does not count towards auto-disable" },
+  { key: "webhooks.deliveries", method: "GET", path: "/v1/webhooks/:id/deliveries", legacy: "/v1/webhooks/:id/deliveries", scope: "admin", summary: "Recent deliveries, newest first (`limit` 1-100, default 20; kept 30 days): event, state (pending, delivered, failed, discarded), attempts, last HTTP status and error, duration" },
+  { key: "webhooks.redeliver", method: "POST", path: "/v1/webhooks/:id/deliveries/:delivery/retry", legacy: "/v1/webhooks/:id/deliveries/:delivery/retry", scope: "admin", summary: "Send one delivery again now, with the same `Praeko-Delivery` id (receivers can deduplicate)" },
+  { key: "webhooks.rotateSecret", method: "POST", path: "/v1/webhooks/:id/rotate-secret", legacy: "/v1/webhooks/:id/rotate-secret", scope: "admin", summary: "Replace the signing secret; the new `secret` is returned ONCE and the old one stops signing immediately" },
+  { key: "ideas.list", method: "GET", path: "/v1/ideas", legacy: "/v1/ideas", scope: "read", summary: 'Idea board of this workspace (the "Create" screen), newest first: `title`, `note`, `group` (idea, scripting, ready, posted), `tags` (the first one is the series), `createdAt`, `updatedAt`' },
+  { key: "ideas.create", method: "POST", path: "/v1/ideas", legacy: "/v1/ideas", scope: "write", body: "json", summary: "Add an idea: `title` (1-200 characters, required), `note` (up to 5000), `group` (default idea), `tags` (up to 20, 40 characters each). Max 2000 per workspace" },
+  { key: "ideas.import", method: "POST", path: "/v1/ideas/import", legacy: "/v1/ideas/import", scope: "write", body: "json", summary: "Bulk-add `ideas` (up to 500 per call), as the panel does with the ideas it kept in the browser. An item whose `id` was already imported is skipped (`skippedCount`), so repeating the call never duplicates. Items without a valid `title` are skipped" },
+  { key: "ideas.update", method: "PATCH", path: "/v1/ideas/:id", legacy: "/v1/ideas/:id", scope: "write", body: "json", summary: "Change `title`, `note`, `group` (moving a card) or `tags`; omitted fields stay" },
+  { key: "ideas.delete", method: "DELETE", path: "/v1/ideas/:id", legacy: "/v1/ideas/:id", scope: "write", summary: "Delete an idea" }
+];
+var toRegExp = (tpl) => new RegExp("^" + tpl.replace(/:[A-Za-z_]+/g, "([^/]+)").replace(/\//g, "\\/") + "$");
+var NEW_RE = ROUTES.map((r) => ({ r, re: toRegExp(r.path) }));
+var OLD_RE = ROUTES.filter((r) => r.legacy).map((r) => ({ r, re: toRegExp(r.legacy) }));
+var KEYS = [
+  ["abs", "absolute"],
+  ["acao", "action"],
+  ["acoes", "actions"],
+  ["adotado", "adopted"],
+  ["agregadoAtualizadoEm", "aggregateUpdatedAt"],
+  ["agregadoBuffer", "bufferAggregate"],
+  ["alcance", "reach"],
+  ["anterior", "previous"],
+  ["antes", "before"],
+  ["appAuditado", "appAudited"],
+  ["ate", "to"],
+  ["ativa", "active"],
+  ["atual", "current"],
+  ["atualizado_em", "updatedAt"],
+  ["atualizados", "updated"],
+  ["autor", "author"],
+  ["autorCanal", "authorChannel"],
+  ["aviso", "warning"],
+  ["avisarInscritos", "notifySubscribers"],
+  ["canais", "channels"],
+  ["canal", "channel"],
+  ["canalId", "channelId"],
+  ["cancelados", "canceled"],
+  ["cancelar", "cancel"],
+  ["capa", "cover"],
+  ["capaNoQuadro", "coverInFrame"],
+  ["cartoes", "cards"],
+  ["categoriaId", "categoryId"],
+  ["chave", "key"],
+  ["chaves", "keys"],
+  ["codigo", "code"],
+  ["coleta", "collection"],
+  ["coletando", "collecting"],
+  ["comentar", "comment", "req"],
+  ["comentario", "comment", "res"],
+  ["comentarioDesabilitado", "commentsDisabled"],
+  ["comentarioFixo", "pinnedComment"],
+  ["comentarios", "comments"],
+  ["compartilhamentos", "shares"],
+  ["compartilharNoFeed", "shareToFeed"],
+  ["comparar", "compare"],
+  ["conectado", "connected"],
+  ["conectadoEm", "connectedAt"],
+  ["consultadoEm", "queriedAt"],
+  ["conteudoComercial", "commercialContent"],
+  ["criado_em", "createdAt"],
+  ["curtidas", "likes"],
+  ["de", "from"],
+  ["depois", "after"],
+  ["deslocamento", "offset"],
+  ["desabilitarComentarios", "disableComments"],
+  ["desabilitarDueto", "disableDuet"],
+  ["desabilitarStitch", "disableStitch"],
+  ["desconectado", "disconnected"],
+  ["descricao", "description"],
+  ["destino_id", "itemId"],
+  ["destinos", "items", "req"],
+  ["detalhe", "detail"],
+  ["detalhes", "details"],
+  ["dia", "day"],
+  ["dia_semana", "weekday"],
+  ["direcao", "direction"],
+  ["diretoDisponivel", "directAvailable"],
+  ["doDono", "fromOwner"],
+  ["duetoDesabilitado", "duetDisabled"],
+  ["duracaoMaxSeg", "maxDurationSec"],
+  ["editarHorario", "editSchedule"],
+  ["editarTexto", "editText"],
+  ["encontrados", "found"],
+  ["engajamento", "engagement"],
+  ["engajamentoGeral", "overallEngagement"],
+  ["enviar", "uploadHint"],
+  ["erro", "error"],
+  ["erros", "errors"],
+  ["escopo", "scope"],
+  ["escrito", "written"],
+  ["estado", "state"],
+  ["etiqueta", "tag"],
+  ["etiquetas", "tags"],
+  ["executarEm", "runAt"],
+  ["expiraEm", "expiresAt"],
+  ["expiraEmDias", "expiresInDays", "req"],
+  ["expirada", "expired"],
+  ["diasRestantes", "daysLeft"],
+  ["externo", "external"],
+  ["fila", "queue"],
+  ["filtros", "filters"],
+  ["fonte", "source"],
+  ["fontes", "sources"],
+  ["formato", "format"],
+  ["fuso", "timezone"],
+  ["hora", "time"],
+  ["ignorado", "skipped"],
+  ["importados", "imported"],
+  ["itens", "items", "res"],
+  ["jaFeita", "alreadyDone"],
+  ["legenda", "caption"],
+  ["leitura48h", "reading48h"],
+  ["leitura48hTexto", "reading48hText"],
+  ["leiturasNoBanco", "storedReadings"],
+  ["lembrete", "reminder"],
+  ["limite", "limit"],
+  ["mantidos", "kept"],
+  ["marcaPropria", "ownBrand"],
+  ["marcaTerceiros", "thirdPartyBrand"],
+  ["marcos", "milestones"],
+  ["mencoes", "mentions"],
+  ["mensagem", "message"],
+  ["midia", "media"],
+  ["midiaId", "mediaId"],
+  ["midias", "mediaItems"],
+  ["miniatura", "thumb"],
+  ["miniaturaMidia", "thumbMedia"],
+  ["miniaturaMs", "coverFrameMs"],
+  ["miniaturaTipo", "thumbType"],
+  ["modo", "mode"],
+  ["motivo", "reason"],
+  ["mover", "moveTo"],
+  ["moverRascunho", "moveToDraft"],
+  ["envio", "delivery"],
+  ["revogacaoPulada", "revocationSkipped"],
+  ["removido", "accountRemoved"],
+  ["motivoFalha", "failReason"],
+  ["verificadoEm", "checkedAt"],
+  ["mudou", "changed"],
+  ["naCaixaDeEntrada", "inInbox"],
+  ["nome", "name"],
+  ["novos", "created"],
+  ["ocultar", "hide"],
+  ["oculto", "hidden"],
+  ["opcoes", "options"],
+  ["ordem", "sort"],
+  ["origem", "origin"],
+  ["pagina", "page"],
+  ["paginas", "pages"],
+  ["parte", "part"],
+  ["parteMaxima", "maxPartSize"],
+  ["parteMinima", "minPartSize"],
+  ["padrao", "default"],
+  ["partes", "parts"],
+  ["parteSugerida", "suggestedPartSize"],
+  ["pendentes", "pending"],
+  ["pendentesPorRede", "pendingByNetwork"],
+  ["pendentesPorCanal", "pendingByChannel"],
+  ["periodo", "period"],
+  ["periodoAnterior", "previousPeriod"],
+  ["postsAnterior", "previousPosts"],
+  ["postsComMetricas", "postsWithMetrics"],
+  ["postsSemMetricas", "postsWithoutMetrics"],
+  ["prefixo", "prefix"],
+  ["privacidade", "privacy"],
+  ["privacidades", "privacyLevels"],
+  ["privacidadesPermitidas", "allowedPrivacyLevels"],
+  ["provedor", "provider"],
+  ["proxima", "next"],
+  ["publicadoEm", "publishedAt"],
+  ["publicaPelaMeta", "publishesViaMeta"],
+  ["publicarAgora", "publishNow"],
+  ["quando", "scheduledFor"],
+  ["rascunho", "draft"],
+  ["reacoes", "reactions"],
+  ["reconciliados", "reconciled"],
+  ["rede", "network"],
+  ["registros", "records"],
+  ["removida", "removed"],
+  ["reorganizados", "rescheduled"],
+  ["resolvido", "resolved"],
+  ["respondido", "answered"],
+  ["respostas", "replies"],
+  ["resultado", "result"],
+  ["resumo", "summary"],
+  ["revogada", "revoked"],
+  ["revogada_em", "revokedAt"],
+  ["revogadoNoTiktok", "revokedAtTiktok"],
+  ["revogadoNoGoogle", "revokedAtGoogle"],
+  ["novoPadrao", "newDefault"],
+  ["salvamentos", "saves"],
+  ["seguidores", "followers"],
+  ["seguidoresGanhos", "followersGained"],
+  ["seguidoresVar", "followersChange"],
+  ["semMetricas", "noMetrics"],
+  ["semResposta", "unanswered"],
+  ["servico", "service"],
+  ["simples", "simple"],
+  ["simulado", "simulated"],
+  ["simular", "dryRun"],
+  ["stitchDesabilitado", "stitchDisabled"],
+  ["substitui", "replaces"],
+  ["suportado", "supported"],
+  ["tamanho", "size"],
+  ["tempoAssistidoMin", "watchTimeMin"],
+  ["tempoMedioSeg", "avgWatchTimeSec"],
+  ["texto", "text"],
+  ["texto_base", "baseText"],
+  ["textos", "texts"],
+  ["tipo", "type"],
+  ["titulo", "title"],
+  ["total", "total"],
+  ["totalRespostas", "replyCount"],
+  ["ultima", "last"],
+  ["ultimaImportacao", "lastImport"],
+  ["ultimo_uso", "lastUsedAt"],
+  ["urlPublica", "publicUrl"],
+  ["usuario", "username"],
+  ["vagas", "slots"],
+  ["vagasLivres", "freeSlots"],
+  ["valor", "value"],
+  ["variacao", "change"],
+  ["verificar", "verify"],
+  ["versao", "version"],
+  ["visualizacoes", "viewCount"],
+  ["ignorados", "skippedCount"],
+  ["publicos", "publicCount"],
+  // uso e log de requisições (/v1/usage)
+  ["dias", "days"],
+  ["sucesso", "succeeded"],
+  ["picoPorMinuto", "peakPerMinute"],
+  ["limitePorMinuto", "limitPerMinute"],
+  ["porDia", "byDay"],
+  ["porHora", "byHour"],
+  ["porChave", "byKey"],
+  ["inicio", "start"],
+  ["ultimoEm", "lastAt"],
+  ["metodo", "method"],
+  ["rota", "route"],
+  ["duracaoMs", "durationMs"],
+  ["largura", "width"],
+  ["altura", "height"],
+  ["chaveNome", "keyName"],
+  // webhooks (/v1/webhooks)
+  ["eventos", "events"],
+  ["evento", "event"],
+  ["eventoId", "eventId"],
+  ["segredo", "secret"],
+  ["segredoDica", "secretHint"],
+  ["falhasSeguidas", "consecutiveFailures"],
+  ["desativadoMotivo", "disabledReason"],
+  ["recentes", "recentDeliveries"],
+  ["entregas", "deliveries"],
+  ["tentativas", "attempts"],
+  ["proximaTentativa", "nextAttemptAt"],
+  ["ultimoStatus", "lastStatus"],
+  ["ultimoErro", "lastError"],
+  ["entregueEm", "deliveredAt"],
+  ["apagado", "deleted"],
+  // banco de ideias (/v1/ideas)
+  ["ideias", "ideas"],
+  ["nota", "note"],
+  ["grupo", "group"],
+  // retenção, impressões e CTR (/v1/insights/retention)
+  ["retencao", "retention"],
+  ["curva", "curve"],
+  ["impressoes", "impressions"],
+  ["posicao", "position"],
+  ["assistida", "watched"],
+  ["relativa", "relative"],
+  ["percentualMedio", "avgViewPercentage"],
+  ["taxaPulo", "skipRate"],
+  ["desde", "since"],
+  ["pontos", "points"],
+  ["coletadoEm", "collectedAt"]
+].filter((x, i, a) => a.findIndex((y) => y[0] === x[0]) === i);
+var SCOPED_KEYS = { reorganizados: [["de", "from"], ["para", "to"]], leitura48h: [["destinoId", "itemId"]] };
+var SAME_KEYS = /* @__PURE__ */ new Set(["id", "ctr", "item", "url", "views", "tags", "meta", "host", "token", "userId", "ok", "total", "pct", "manual", "custom", "studio", "video", "mime", "etag", "avatar", "youtube", "instagram", "tiktok", "publishAt", "parentId", "permalink", "thumbnail", "posts", "topPosts", "videos", "redirect", "chunkMB", "via", "videoId", "postId", "threadId", "limit", "max", "publishId", "status", "p95Ms", "cursor", "webhooks", "theme", "language", "notifications", "email", "panel", "postSent", "postFailed", "scheduledFail", "weeklySummary", "newComment"]);
+var VALUES = {
+  estado: [
+    ["rascunho", "draft"],
+    ["agendado", "scheduled"],
+    ["enviado", "sent"],
+    ["erro", "error"],
+    ["cancelado", "canceled"],
+    ["privado", "private"],
+    ["fila", "queued"],
+    ["enviando", "uploading"],
+    ["pronta", "ready"],
+    ["removida", "removed"],
+    ["pendente", "pending"],
+    ["reautorizar", "reauthorize"],
+    ["indisponivel", "unavailable"],
+    ["entregue", "delivered"],
+    ["falhou", "failed"],
+    ["descartada", "discarded"]
+  ],
+  // os quatro últimos: entregas de webhook
+  grupo: [["sem", "idea"], ["fazer", "scripting"], ["andamento", "ready"], ["feito", "posted"]],
+  // grupos do quadro de ideias (Ideia, Roteirizando, Pronto para postar, Postado)
+  modo: [["privado", "private"], ["agendado", "scheduled"], ["publico", "public"], ["rascunho", "draft"], ["direto", "direct"], ["agora", "now"]],
+  mover: [["rascunho", "draft"], ["fila", "queue"]],
+  tipo: [["capa", "cover"], ["longo", "long"], ["comentar", "comment"], ["agendar", "schedule"]],
+  formato: [["longo", "long"]],
+  dia: [
+    ["dom", "sun"],
+    ["seg", "mon"],
+    ["ter", "tue"],
+    ["qua", "wed"],
+    ["qui", "thu"],
+    ["sex", "fri"],
+    ["sab", "sat"],
+    ["dom", "sunday", "req"],
+    ["seg", "monday", "req"],
+    ["ter", "tuesday", "req"],
+    ["qua", "wednesday", "req"],
+    ["qui", "thursday", "req"],
+    ["sex", "friday", "req"],
+    ["sab", "saturday", "req"]
+  ],
+  escopo: [["leitura", "read"], ["escrita", "write"], ["admin", "admin"]],
+  origem: [["externo", "external"], ["importado", "imported"]],
+  ordem: [
+    ["recentes", "recent"],
+    ["comentarios", "comments"],
+    ["reacoes", "reactions"],
+    ["publicadoEm", "publishedAt"],
+    ["engajamento", "engagement"],
+    ["compartilhamentos", "shares"],
+    ["salvamentos", "saves"],
+    ["alcance", "reach"]
+  ],
+  rede: [["todas", "all"], ["tudo", "all"]],
+  direcao: [],
+  fonte: [["marco48h", "milestone48h"], ["atual", "current"], ["sem-dados", "no-data"]],
+  detalhe: [
+    ["reserva no Buffer", "buffer-fallback"],
+    ["publicado", "published"],
+    ["aguardando hor\xE1rio", "awaiting-time"],
+    ["publicando", "publishing"],
+    ["preparado", "prepared"],
+    ["preparando", "preparing"],
+    ["aguardando preparo", "awaiting-prep"]
+  ]
+};
+var SCOPED_VALUES = {
+  acoes: { estado: [["agendada", "pending"], ["executando", "running"], ["feita", "done"], ["erro", "error"], ["cancelada", "canceled"]] }
+};
+var PATH_KEYS = /* @__PURE__ */ new Set(["avatar", "enviar"]);
+var PATH_PAIRS = [["/v1/canais/", "/v1/channels/"], ["?canal=", "?channel="], ["/v1/midia", "/v1/media"], ["/conteudo", "/content"], ["/partes/", "/parts/"]];
+var rewritePath = (s, dir) => PATH_PAIRS.reduce((x, [pt, en]) => dir === "toEN" ? x.split(pt).join(en) : x.split(en).join(pt), s);
+var index = (rows, dir) => {
+  const mk = (kind) => {
+    const m = /* @__PURE__ */ new Map();
+    for (const [pt, en, only] of rows) {
+      if (only && only !== kind) continue;
+      if (dir === "toEN") {
+        if (!m.has(pt)) m.set(pt, en);
+      } else if (!m.has(en)) m.set(en, pt);
+    }
+    return m;
+  };
+  return { req: mk("req"), res: mk("res") };
+};
+var KEY_IDX = { toEN: index(KEYS, "toEN"), toPT: index(KEYS, "toPT") };
+var VAL_IDX = Object.fromEntries(Object.entries(VALUES).map(([k, rows]) => [k, { toEN: index(rows, "toEN"), toPT: index(rows, "toPT") }]));
+var SKEY_IDX = Object.fromEntries(Object.entries(SCOPED_KEYS).map(([k, rows]) => [k, { toEN: index(rows, "toEN"), toPT: index(rows, "toPT") }]));
+var SVAL_IDX = Object.fromEntries(Object.entries(SCOPED_VALUES).map(([p, fields]) => [p, Object.fromEntries(Object.entries(fields).map(([k, rows]) => [k, { toEN: index(rows, "toEN"), toPT: index(rows, "toPT") }]))]));
+var PT_ONLY_KEYS = new Set(KEYS.filter(([pt, en]) => pt !== en).map(([pt]) => pt));
+var EN_KEYS = new Set(KEYS.map(([, en]) => en));
+for (const k of EN_KEYS) PT_ONLY_KEYS.delete(k);
+var EN_ALSO = new Set(Object.entries(VALUES).flatMap(([campo, rows]) => rows.map((r) => `${campo}|${r[1]}`)));
+var PtKeyError = class extends Error {
+  constructor(key, value) {
+    super(value === void 0 ? `o campo "${key}" n\xE3o existe no contrato novo` : `o valor "${value}" de "${key}" n\xE3o existe no contrato novo`);
+    this.name = "PtKeyError";
+    this.key = key;
+    this.value = value;
+  }
+};
+var PT_ONLY_VALUES = {};
+for (const [campo, rows] of Object.entries(VALUES)) {
+  const en = new Set(rows.map((r) => r[1]));
+  PT_ONLY_VALUES[campo] = new Set(rows.filter((r) => !r[2] || r[2] === "req").map((r) => r[0]).filter((pt) => !en.has(pt)));
+}
+for (const [pai, campos] of Object.entries(SCOPED_VALUES)) for (const [campo, rows] of Object.entries(campos)) {
+  const en = new Set(rows.map((r) => r[1]));
+  PT_ONLY_VALUES[`${pai}.${campo}`] ||= new Set(rows.map((r) => r[0]).filter((pt) => !en.has(pt)));
+}
+function translate(value, o, container = null, own = null) {
+  const { dir, kind } = o;
+  if (Array.isArray(value)) return value.map((x) => translate(x, o, container, own));
+  if (value && typeof value === "object") {
+    const out = {}, scoped = SKEY_IDX[own]?.[dir]?.[kind];
+    for (const [k, v] of Object.entries(value)) {
+      const hit = scoped?.get(k) ?? KEY_IDX[dir][kind].get(k);
+      if (hit === void 0 && o.strict && dir === "toPT" && PT_ONLY_KEYS.has(k) && !SAME_KEYS.has(k)) throw new PtKeyError(k);
+      const outKey = hit ?? k, ptKey = dir === "toEN" ? k : outKey;
+      out[outKey] = translate(v, o, own, ptKey);
+    }
+    return out;
+  }
+  if (typeof value === "string" && own !== null) {
+    const idx = SVAL_IDX[container]?.[own] ?? VAL_IDX[own], mapped = idx?.[dir]?.[kind]?.get(value);
+    if (mapped !== void 0) return mapped;
+    if (o.strict && dir === "toPT" && kind === "req" && PT_ONLY_VALUES[own]?.has(value) && !EN_ALSO.has(`${own}|${value}`)) throw new PtKeyError(own, value);
+    if (o.paths && PATH_KEYS.has(own)) return rewritePath(value, dir);
+  }
+  return value;
+}
+var toEN = (value, kind = "res", o = {}) => translate(value, { dir: "toEN", kind, ...o });
+var toPT = (value, kind = "req", o = {}) => translate(value, { dir: "toPT", kind, ...o });
+var ERROR_CODES = {
+  rota_inexistente: "route_not_found",
+  metodo_nao_permitido: "method_not_allowed",
+  erro_interno: "internal_error",
+  nao_autenticado: "unauthorized",
+  chave_invalida: "invalid_api_key",
+  chave_revogada: "revoked_api_key",
+  chave_expirada: "expired_api_key",
+  mfa_necessario: "mfa_required",
+  codigo_invalido: "invalid_code",
+  mfa_ja_ativo: "mfa_already_enabled",
+  mfa_nao_iniciado: "mfa_not_started",
+  mfa_inativo: "mfa_not_enabled",
+  sessao_atual: "current_session",
+  sessao_inexistente: "session_not_found",
+  confirmacao_invalida: "invalid_confirmation",
+  sessao_invalida: "invalid_session",
+  origem_invalida: "invalid_origin",
+  sem_permissao: "forbidden",
+  muitas_requisicoes: "rate_limited",
+  corpo_vazio: "empty_body",
+  json_invalido: "invalid_json",
+  corpo_grande: "body_too_large",
+  campo_invalido: "invalid_field",
+  pedido_invalido: "invalid_request",
+  falta_horario: "missing_schedule",
+  sem_horario: "missing_time",
+  horario_passado: "time_in_past",
+  sem_vagas: "no_slots",
+  sem_vaga_livre: "no_free_slot",
+  post_inexistente: "post_not_found",
+  destino_inexistente: "item_not_found",
+  acao_inexistente: "action_not_found",
+  canal_inexistente: "channel_not_found",
+  canal_nao_conectado: "channel_not_connected",
+  chave_inexistente: "api_key_not_found",
+  workspace_inexistente: "workspace_not_found",
+  oauth_requer_painel: "oauth_requires_panel",
+  video_publicado: "video_not_private",
+  canal_em_uso: "channel_in_use",
+  canal_conectado: "channel_connected",
+  canal_do_buffer: "channel_is_buffer",
+  credenciais_invalidas: "invalid_credentials",
+  senha_fraca: "weak_password",
+  link_invalido: "invalid_link",
+  conta_travada: "account_locked",
+  passkey_invalida: "invalid_passkey",
+  passkey_inexistente: "passkey_not_found",
+  passkey_existente: "passkey_exists",
+  desafio_invalido: "invalid_challenge",
+  limite_de_passkeys: "passkey_limit",
+  codigo_necessario: "code_required",
+  workspace_da_plataforma: "platform_workspace",
+  migracao_pendente: "migration_pending",
+  chave_em_uso: "api_key_in_use",
+  video_inexistente: "video_not_found",
+  sem_video: "no_video",
+  sem_avatar: "no_avatar",
+  midia_inexistente: "media_not_found",
+  midia_em_uso: "media_in_use",
+  midia_nao_pronta: "media_not_ready",
+  midia_tipo: "media_type_mismatch",
+  midia_travada: "media_locked",
+  rede_desconhecida: "unknown_network",
+  rede_nao_suportada: "network_not_supported",
+  estado_invalido: "invalid_state",
+  id_existente: "id_exists",
+  ja_adotado: "already_adopted",
+  nada_a_publicar: "nothing_to_publish",
+  nao_editavel: "not_editable",
+  post_adotado: "post_adopted",
+  post_preparado: "post_prepared",
+  sem_credencial_oauth: "oauth_not_configured",
+  tem_api: "followers_from_api",
+  youtube_nao_conectado: "youtube_not_connected",
+  instagram_meta_nao_conectado: "instagram_meta_not_connected",
+  falha_download: "download_failed",
+  mime_nao_suportado: "unsupported_mime",
+  // upload_media do MCP (docs/mcp.md)
+  arquivo_grande: "file_too_large",
+  parte_grande: "part_too_large",
+  parte_pequena: "part_too_small",
+  parte_vazia: "part_empty",
+  partes_desiguais: "parts_unequal",
+  partes_faltando: "parts_missing",
+  sem_partes: "no_parts",
+  tamanho_diferente: "size_mismatch",
+  r2_recusou: "storage_rejected",
+  identidade_inexistente: "identity_not_linked",
+  ultima_forma_de_login: "last_login_method",
+  credencial_oauth_ausente: "missing_oauth_credential",
+  ja_conectado: "already_connected",
+  oauth_state_invalido: "oauth_state_invalid",
+  oauth_negado: "oauth_denied",
+  sem_conta_instagram: "no_instagram_account",
+  varias_contas_instagram: "multiple_instagram_accounts",
+  troca_token_falhou: "token_exchange_failed",
+  permissao_publicar_ausente: "publish_permission_missing",
+  token_sem_acesso: "token_cannot_read_account",
+  webhook_inexistente: "webhook_not_found",
+  entrega_inexistente: "delivery_not_found",
+  url_insegura: "unsafe_url",
+  limite_webhooks: "webhook_limit_reached",
+  ideia_inexistente: "idea_not_found",
+  limite_ideias: "idea_limit_reached",
+  idempotencia_reutilizada: "idempotency_key_reuse",
+  idempotencia_em_andamento: "idempotency_in_progress",
+  idempotencia_resposta_grande: "idempotency_response_too_large",
+  buffer_erro: "buffer_error",
+  instagram_erro: "instagram_error",
+  tiktok_indisponivel: "tiktok_unavailable",
+  youtube_erro: "youtube_error"
+};
+var ERROR_CODES_REVERSE = Object.fromEntries(Object.entries(ERROR_CODES).map(([pt, en]) => [en, pt]));
+
+// ../core/src/segredos.mjs
+import { execFileSync } from "node:child_process";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var SERVICO = "praeko";
+var SERVICO_ANTIGO = "arauto";
+var REFS_CONHECIDAS = ["praeko/chave", "buffer/principal", "youtube/cliente", "youtube/token", "instagram/token", "instagram/meta", "tiktok/cliente", "tiktok/token", "tiktok/pendente"];
+var refAntiga = (ref2) => ref2.startsWith("praeko/") ? "arauto/" + ref2.slice("praeko/".length) : ref2;
+var sufixoEnv = (ref2) => ref2.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+var envDe = (ref2) => `PRAEKO_KEY_${sufixoEnv(ref2)}`;
+var envAntigaDe = (ref2) => `ARAUTO_KEY_${sufixoEnv(refAntiga(ref2))}`;
+var semChaveiro = (env = process.env) => !!(env.PRAEKO_SEM_CHAVEIRO || env.ARAUTO_SEM_CHAVEIRO);
+var chaveiro = {
+  ativo: () => process.platform === "darwin" && !semChaveiro(),
+  ler(servico, ref2) {
+    try {
+      return execFileSync("security", ["find-generic-password", "-s", servico, "-a", ref2, "-w"], { stdio: ["ignore", "pipe", "ignore"] }).toString().trim() || null;
+    } catch {
+      return null;
+    }
+  },
+  gravar(servico, ref2, valor) {
+    execFileSync("security", ["add-generic-password", "-U", "-s", servico, "-a", ref2, "-w", valor], { stdio: ["ignore", "ignore", "pipe"] });
+  }
+};
+var arquivoSegredos = () => process.env.PRAEKO_SEGREDOS || process.env.ARAUTO_SEGREDOS || join(homedir(), ".config", "praeko", "segredos.json");
+var arquivoSegredosAntigo = () => join(homedir(), ".config", "arauto", "segredos.json");
+var lerArquivo = (f = arquivoSegredos()) => {
+  if (!existsSync(f)) return {};
+  try {
+    return JSON.parse(readFileSync(f, "utf8"));
+  } catch {
+    return {};
+  }
+};
+function obterNovo(ref2) {
+  if (process.env[envDe(ref2)]) return process.env[envDe(ref2)];
+  if (chaveiro.ativo()) {
+    const k = chaveiro.ler(SERVICO, ref2);
+    if (k) return k;
+  }
+  return lerArquivo()[ref2] ?? null;
+}
+function obterAntigoGuardado(ref2) {
+  const velha = refAntiga(ref2);
+  if (chaveiro.ativo()) {
+    const k = chaveiro.ler(SERVICO_ANTIGO, velha);
+    if (k) return k;
+  }
+  return lerArquivo(arquivoSegredos())[velha] ?? lerArquivo(arquivoSegredosAntigo())[velha] ?? null;
+}
+var obterAntigo = (ref2) => process.env[envAntigaDe(ref2)] || obterAntigoGuardado(ref2);
+var obter = (ref2) => obterNovo(ref2) ?? obterAntigo(ref2);
+function guardar(ref2, valor) {
+  if (chaveiro.ativo()) {
+    chaveiro.gravar(SERVICO, ref2, valor);
+    return "chaveiro";
+  }
+  const f = arquivoSegredos();
+  mkdirSync(dirname(f), { recursive: true });
+  const s = lerArquivo();
+  s[ref2] = valor;
+  writeFileSync(f, JSON.stringify(s, null, 2) + "\n", { mode: 384 });
+  chmodSync(f, 384);
+  return "arquivo";
+}
+var segredos = { obter, guardar, obterNovo, obterAntigo, obterAntigoGuardado };
+function migrar(loja = segredos, refs = REFS_CONHECIDAS) {
+  const r = { copiados: [], jaNoNovo: [], ausentes: [] };
+  for (const ref2 of refs) {
+    if (loja.obterNovo(ref2)) {
+      r.jaNoNovo.push(ref2);
+      continue;
+    }
+    const v = loja.obterAntigoGuardado(ref2);
+    if (!v) {
+      r.ausentes.push(ref2);
+      continue;
+    }
+    loja.guardar(ref2, v);
+    r.copiados.push(ref2);
+  }
+  return r;
+}
+
+// ../core/src/adaptadores/remoto.mjs
+var REF_CHAVE = "praeko/chave";
+var itemDoContrato = (i) => ({ rede: i.rede, id: i.id, estado: i.estado, quando: i.quando, ...i.url ? { url: i.url } : {}, ...i.studio ? { studio: i.studio } : {}, ...i.aviso ? { aviso: i.aviso } : {}, ...i.custom ? { custom: true } : {} });
+function criar({ config, ctx, praeko, arauto } = {}) {
+  const injetado = ctx?.praeko ?? praeko ?? ctx?.arauto ?? arauto, seg = ctx?.segredos || segredos, log = ctx?.log || (() => {
+  });
+  const cliente = () => {
+    if (injetado) return injetado;
+    const url = config?.remoto?.url, chave = process.env.PRAEKO_KEY || process.env.ARAUTO_CHAVE || seg.obter(REF_CHAVE);
+    if (!url) throw new Error('falta a url do servi\xE7o: "remoto": { "url": "https://\u2026" } no praeko.json (ou --server)');
+    if (!chave) throw new Error("falta a chave do servi\xE7o: defina PRAEKO_KEY (ou ARAUTO_CHAVE) ou rode `echo $KEY | praeko key store`");
+    return new Praeko({ url, key: chave });
+  };
+  const novo = (a) => !!a.media;
+  const subir = (a, caminho, tipo, onProgress) => uploadFile(a, caminho, { type: tipo, onProgress });
+  return {
+    nome: "remoto",
+    async publicar(pedido, { aoProgredir } = {}) {
+      const erros = validarPedido(pedido.midia?.videoId ? { ...pedido, midia: { video: pedido.midia.videoId } } : pedido);
+      if (erros.length) throw new Error(`pedido inv\xE1lido: ${erros.join("; ")}`);
+      const a = cliente();
+      let videoId = pedido.midia.videoId, capaId = pedido.midia.capaId;
+      if (!videoId) {
+        log(`  enviando o v\xEDdeo ao servi\xE7o (${pedido.midia.video})\u2026`);
+        videoId = (await subir(a, pedido.midia.video, "video", aoProgredir)).id;
+      }
+      if (!capaId && pedido.midia.capa) {
+        log("  enviando a capa\u2026");
+        capaId = (await subir(a, pedido.midia.capa, "cover")).id;
+      }
+      const extras = /* @__PURE__ */ new Map(), doDestino = async (d) => {
+        if (!d.midia) return void 0;
+        const m = {};
+        for (const [campo, tipo] of [["video", "video"], ["capa", "capa"]]) {
+          const x = d.midia[campo], idJa = d.midia[`${campo}Id`];
+          if (idJa) m[campo] = idJa;
+          else if (x) {
+            if (!extras.has(x)) {
+              log(`  enviando ${tipo} do destino ${d.rede} (${x})\u2026`);
+              extras.set(x, (await subir(a, x, tipo === "capa" ? "cover" : tipo)).id);
+            }
+            m[campo] = extras.get(x);
+          }
+        }
+        return Object.keys(m).length ? m : void 0;
+      };
+      const destinosCorpo = [];
+      for (const d of pedido.destinos) {
+        const m = await doDestino(d);
+        destinosCorpo.push({ ...d, ...m ? { midia: m } : {} });
+      }
+      const corpo = { ...pedido.id ? { id: pedido.id } : {}, titulo: pedido.titulo, midia: { video: videoId, ...capaId ? { capa: capaId } : {} }, textos: pedido.textos, destinos: destinosCorpo.map((d) => ({ rede: d.rede, ...d.midia ? { midia: d.midia } : {}, ...d.quando ? { quando: d.quando } : {}, ...d.modo ? { modo: d.modo } : {}, ...d.fila ? { fila: true } : {}, ...d.rascunho ? { rascunho: true } : {} })), ...pedido.etiquetas ? { etiquetas: pedido.etiquetas } : {}, ...pedido.opcoes ? { opcoes: pedido.opcoes } : {}, ...pedido.fila ? { fila: true } : {}, ...pedido.rascunho ? { rascunho: true } : {}, origem: "arauto-cli" };
+      const r = novo(a) ? toPT(await a.posts.create(toEN(corpo, "req")), "res") : await a.posts.criar(corpo);
+      return { id: r.id, itens: r.itens.map(itemDoContrato) };
+    },
+    async status(id) {
+      const c = cliente(), p = novo(c) ? toPT(await c.posts.get(id), "res") : await c.posts.obter(id);
+      return { id: p.id, itens: p.itens.map(itemDoContrato) };
+    },
+    async cancelar(id) {
+      const c = cliente(), r = novo(c) ? toPT(await c.posts.cancel(id), "res") : await c.posts.cancelar(id);
+      return { cancelados: r.cancelados, mantidos: r.mantidos.map(itemDoContrato) };
+    },
+    async canais() {
+      const c0 = cliente(), r0 = novo(c0) ? toPT(await c0.channels.list({ verify: true }), "res") : await c0.canais.listar({ verificar: true });
+      return r0.canais.map((c) => ({ rede: c.rede, conectado: c.conectado, detalhe: c.detalhe, ...c.id ? { id: c.id } : {} }));
+    }
+  };
+}
+
+export {
+  Praeko,
+  segredos,
+  migrar,
+  REF_CHAVE,
+  itemDoContrato,
+  criar,
+  remoto_exports
+};