@praeko/cli 0.0.0-stage → 0.1.0

package/dist/chunks/chunk-Z325UM27.mjs

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

package/dist/chunks/instagram-GNY73ESY.mjs

@@ -0,0 +1,293 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import "./chunk-LCFK6X55.mjs";
+
+// ../core/src/provedores/instagram.mjs
+import { spawnSync } from "node:child_process";
+import { existsSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, extname, join } from "node:path";
+import { createInterface } from "node:readline";
+var nome = "instagram";
+var rede = "instagram";
+var antecedenciaMs = 15 * 6e4;
+var HOST = "https://graph.instagram.com";
+var REF = "instagram/token";
+var DIA = 864e5;
+var LIMITES = { legenda: 2200, hashtags: 30, duracaoMin: 3, duracaoMax: 900, bytes: 300 * 1048576, fpsMin: 23, fpsMax: 60 };
+var VERSAO_PADRAO = "v23.0";
+var versao = (ctx) => ctx.config?.instagram?.versao || VERSAO_PADRAO;
+var agora = (ctx) => ctx.agora ? ctx.agora() : /* @__PURE__ */ new Date();
+var pausa = (ctx, ms) => ctx.pausa ? ctx.pausa(ms) : new Promise((r) => setTimeout(r, ms));
+async function api(ctx, metodo, caminho, params = {}, { semVersao = false, host } = {}) {
+  const base = host || lerToken(ctx)?.host || HOST;
+  const url = new URL(`${base}/${semVersao ? "" : versao(ctx) + "/"}${caminho}`);
+  let init = { method: metodo };
+  if (metodo === "GET") for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);
+  else {
+    init.headers = { "content-type": "application/x-www-form-urlencoded" };
+    init.body = new URLSearchParams(Object.entries(params).map(([k, v]) => [k, String(v)])).toString();
+  }
+  const r = await (ctx.fetchFn || fetch)(url.toString(), init);
+  const txt = await r.text();
+  let j;
+  try {
+    j = JSON.parse(txt);
+  } catch {
+    throw new Error(`Instagram respondeu ${r.status}: ${txt.slice(0, 200)}`);
+  }
+  if (j.error) throw new Error(`Instagram: ${j.error.message}${j.error.code ? ` (c\xF3digo ${j.error.code}${j.error.error_subcode ? "/" + j.error.error_subcode : ""})` : ""}`);
+  if (!r.ok) throw new Error(`Instagram respondeu ${r.status}: ${txt.slice(0, 200)}`);
+  return j;
+}
+function lerToken(ctx) {
+  const bruto = ctx.segredos.obter(REF);
+  if (!bruto) return null;
+  try {
+    return JSON.parse(bruto);
+  } catch {
+    return null;
+  }
+}
+var guardarToken = (ctx, t) => ctx.segredos.guardar(REF, JSON.stringify(t));
+var diasRestantes = (t, d = /* @__PURE__ */ new Date()) => t.expira ? (Date.parse(t.expira) - +d) / DIA : Infinity;
+async function tokenValido(ctx) {
+  const t = lerToken(ctx);
+  if (!t?.token) throw new Error("Instagram n\xE3o conectado: praeko conta instagram conectar --token \u2026");
+  const dias = diasRestantes(t, agora(ctx));
+  if (dias <= 0) throw new Error("o token do Instagram expirou: gere outro no painel da Meta e rode praeko conta instagram conectar --token \u2026");
+  if (t.expira && dias < 15) {
+    try {
+      const r = await api(ctx, "GET", "refresh_access_token", { grant_type: "ig_refresh_token", access_token: t.token }, { semVersao: true });
+      const novo = { ...t, token: r.access_token, expira: new Date(+agora(ctx) + r.expires_in * 1e3).toISOString() };
+      guardarToken(ctx, novo);
+      ctx.log?.(`\u2713 token do Instagram renovado (vale mais ${Math.round(r.expires_in / 86400)} dias)`);
+      return novo;
+    } catch (e) {
+      ctx.log?.(`\u26A0 n\xE3o consegui renovar o token do Instagram (${e.message}); faltam ${Math.floor(dias)} dias`);
+    }
+  }
+  return t;
+}
+async function lerEntrada(args, ctx) {
+  const i = args.indexOf("--token");
+  if (i >= 0 && args[i + 1]) return args[i + 1].trim();
+  if (!process.stdin.isTTY) {
+    const ch = [];
+    for await (const c of process.stdin) ch.push(c);
+    const s = Buffer.concat(ch).toString().trim();
+    if (s) return s;
+  }
+  if (process.stdin.isTTY) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const s = await new Promise((ok) => rl.question("Cole o token de acesso do Instagram (painel da Meta \u2192 Instagram \u2192 API setup \u2192 Generate token): ", ok));
+    rl.close();
+    return s.trim();
+  }
+  return "";
+}
+async function conectar({ ctx, args = [] }) {
+  const token = await lerEntrada(args, ctx);
+  if (!token) throw new Error("sem token: praeko conta instagram conectar --token <token> (ou por stdin)");
+  const j = args.indexOf("--app-secret"), segredoApp = j >= 0 ? args[j + 1] : null;
+  const flag = (k) => {
+    const i = args.indexOf(k);
+    return i >= 0 ? args[i + 1] : void 0;
+  };
+  const userIdArg = flag("--user-id"), hostArg = flag("--host");
+  let eu, host = null;
+  if (hostArg || !userIdArg) {
+    try {
+      eu = await api(ctx, "GET", "me", { fields: "user_id,username,account_type", access_token: token }, { host: hostArg ? `https://${hostArg.replace(/^https?:\/\//, "")}` : HOST });
+      host = hostArg ? `https://${hostArg.replace(/^https?:\/\//, "")}` : null;
+    } catch (e) {
+      if (!userIdArg) throw e;
+    }
+  }
+  if (!eu) {
+    if (!userIdArg) throw new Error("para token de usu\xE1rio de sistema informe --user-id <id da conta do Instagram>");
+    host = "https://graph.facebook.com";
+    const r = await api(ctx, "GET", userIdArg, { fields: "id,username", access_token: token }, { host });
+    eu = { user_id: r.id, id: r.id, username: r.username, account_type: "BUSINESS" };
+  }
+  let final = token, expiraEm = 60 * 86400;
+  if (segredoApp) {
+    try {
+      const r = await api(ctx, "GET", "access_token", { grant_type: "ig_exchange_token", client_secret: segredoApp, access_token: token }, { semVersao: true });
+      final = r.access_token;
+      expiraEm = r.expires_in;
+      ctx.log?.("\u2713 token trocado por um de longa dura\xE7\xE3o");
+    } catch (e) {
+      ctx.log?.(`\u26A0 n\xE3o troquei o token (${e.message}); mantive o original`);
+    }
+  }
+  const salvo = { token: final, userId: String(eu.user_id || eu.id), username: eu.username, tipo: eu.account_type, ...host && /facebook/.test(host) ? { host, expira: null } : { expira: new Date(+agora(ctx) + expiraEm * 1e3).toISOString() }, conectadoEm: agora(ctx).toISOString() };
+  guardarToken(ctx, salvo);
+  ctx.log?.(`\u2713 Instagram conectado: @${salvo.username} (${salvo.tipo || "tipo desconhecido"}); ${salvo.expira ? "token vale at\xE9 " + salvo.expira.slice(0, 10) : "token de usu\xE1rio de sistema, sem expira\xE7\xE3o"}`);
+  if (salvo.tipo && !/BUSINESS|CREATOR|MEDIA_CREATOR/i.test(salvo.tipo)) ctx.log?.("\u26A0 a conta n\xE3o parece profissional (Business/Creator): a API s\xF3 publica em conta profissional");
+  return 0;
+}
+async function status({ ctx }) {
+  const t = lerToken(ctx);
+  if (!t?.token) return { conectado: false, detalhe: "rode: praeko conta instagram conectar --token \u2026" };
+  const dias = diasRestantes(t, agora(ctx));
+  return { conectado: dias > 0, detalhe: `@${t.username}, ${t.tipo || "tipo ?"}, ${!t.expira ? "token sem expira\xE7\xE3o (usu\xE1rio de sistema)" : dias > 0 ? `token vale mais ${Math.floor(dias)} dias${dias < 15 ? " (renova sozinho)" : ""}` : "token EXPIRADO"}` };
+}
+function sondar(arq, ctx) {
+  if (ctx.sondar) return ctx.sondar(arq);
+  const r = spawnSync("ffprobe", ["-v", "error", "-select_streams", "v:0", "-show_entries", "stream=codec_name,width,height,r_frame_rate", "-show_entries", "format=duration", "-of", "json", arq], { encoding: "utf8" });
+  if (r.status !== 0) return null;
+  const j = JSON.parse(r.stdout), s = j.streams[0], [a, b] = String(s.r_frame_rate).split("/").map(Number);
+  return { codec: s.codec_name, largura: s.width, altura: s.height, fps: b ? a / b : a, duracao: +j.format.duration };
+}
+function avisosVideo(arq, ctx = {}) {
+  const av = [];
+  try {
+    try {
+      const bytes = statSync(arq).size;
+      if (bytes > LIMITES.bytes) av.push(`v\xEDdeo com ${(bytes / 1048576).toFixed(0)} MB (limite do Reel: 300 MB)`);
+    } catch {
+    }
+    const s = sondar(arq, ctx);
+    if (!s) return av;
+    if (s.duracao < LIMITES.duracaoMin || s.duracao > LIMITES.duracaoMax) av.push(`dura\xE7\xE3o ${s.duracao.toFixed(1)} s fora de 3 s a 15 min`);
+    if (s.fps < LIMITES.fpsMin || s.fps > LIMITES.fpsMax) av.push(`${s.fps.toFixed(1)} fps fora de 23 a 60`);
+    if (!/^(h264|hevc)$/.test(s.codec)) av.push(`codec ${s.codec} (use H.264 ou HEVC)`);
+    const prop = s.largura / s.altura;
+    if (prop < 0.5 || prop > 0.6) av.push(`propor\xE7\xE3o ${s.largura}x${s.altura}: 9:16 evita cortes e faixas`);
+  } catch (e) {
+    av.push(`n\xE3o consegui conferir o v\xEDdeo (${e.message})`);
+  }
+  return av;
+}
+function avisosTexto(texto) {
+  const av = [];
+  if (texto.length > LIMITES.legenda) av.push(`legenda com ${texto.length} caracteres (limite ${LIMITES.legenda})`);
+  const n = (texto.match(/#[\p{L}\p{N}_]+/gu) || []).length;
+  if (n > LIMITES.hashtags) av.push(`${n} hashtags (limite ${LIMITES.hashtags})`);
+  return av;
+}
+async function planejar({ item, ctx }) {
+  const l = [`Reel na hora marcada; preparo ${antecedenciaMs / 6e4} min antes (v\xEDdeo e capa v\xE3o para a hospedagem p\xFAblica)`];
+  l.push(item.capa ? `capa: ${basename(item.capa)} (vira cover_url; PNG \xE9 convertido para JPEG)` : "sem capa: miniatura = quadro 0 do v\xEDdeo");
+  const t = lerToken(ctx);
+  l.push(t ? `conta @${t.username}; token vale mais ${Math.floor(diasRestantes(t, agora(ctx)))} dias` : "\u26A0 conta n\xE3o conectada (praeko conta instagram conectar)");
+  for (const a of [...avisosTexto(item.textos?.texto || ""), ...item.video ? avisosVideo(item.video, ctx) : []]) l.push(`\u26A0 ${a}`);
+  return l;
+}
+function capaJpeg(capa, ctx) {
+  if (/\.jpe?g$/i.test(capa)) return capa;
+  if (ctx.converterCapa) return ctx.converterCapa(capa);
+  const saida = join(tmpdir(), `praeko-capa-${basename(capa, extname(capa))}-${Date.now()}.jpg`);
+  const r = spawnSync("ffmpeg", ["-v", "error", "-y", "-i", capa, "-q:v", "2", saida], { stdio: "ignore" });
+  return r.status === 0 && existsSync(saida) ? saida : capa;
+}
+async function limpar(ctx, prep) {
+  for (const chave of prep?.chavesHospedadas || []) {
+    try {
+      await ctx.removerHospedado(chave);
+    } catch (e) {
+      ctx.log?.(`\u26A0 n\xE3o removi ${chave} da hospedagem (${e.message})`);
+    }
+  }
+}
+async function preparar({ item, ctx }) {
+  if (item.prep?.containerId && !item.prep.publicado && +agora(ctx) - Date.parse(item.prep.criadoEm) < 23 * 36e5) return item.prep;
+  if (item.prep?.containerId && !item.prep.publicado) {
+    await limpar(ctx, item.prep);
+    item.prep = null;
+  }
+  const t = await tokenValido(ctx), texto = item.textos?.texto || "";
+  const erros = avisosTexto(texto).filter((x) => /caracteres|hashtags/.test(x));
+  if (erros.length) throw new Error(erros.join("; "));
+  const chaves = [];
+  try {
+    const v = await ctx.hospedar(item.video, item.slug);
+    chaves.push(v.chave);
+    const params = { media_type: "REELS", video_url: v.url, caption: texto, share_to_feed: "true", access_token: t.token };
+    if (item.capa) {
+      const c = await ctx.hospedar(capaJpeg(item.capa, ctx), item.slug);
+      chaves.push(c.chave);
+      params.cover_url = c.url;
+    } else if (item.opcoes?.miniaturaMs != null) params.thumb_offset = item.opcoes.miniaturaMs;
+    const r = await api(ctx, "POST", `${t.userId}/media`, params);
+    item.prep = { containerId: r.id, criadoEm: agora(ctx).toISOString(), chavesHospedadas: chaves, videoUrl: v.url, capaUrl: params.cover_url || null };
+    ctx.log?.(`\u2713 Instagram: cont\xEAiner ${r.id} criado`);
+    return item.prep;
+  } catch (e) {
+    await limpar(ctx, { chavesHospedadas: chaves });
+    throw e;
+  }
+}
+async function esperarContainer({ ctx, token, containerId, intervaloMs, maxMs }) {
+  const tentativas = Math.max(1, Math.ceil(maxMs / intervaloMs));
+  for (let i = 0; i < tentativas; i++) {
+    const r = await api(ctx, "GET", containerId, { fields: "status_code,status", access_token: token });
+    if (r.status_code === "FINISHED" || r.status_code === "PUBLISHED") return r.status_code;
+    if (r.status_code === "ERROR" || r.status_code === "EXPIRED") {
+      const e = new Error(`Instagram: cont\xEAiner ${r.status_code}${r.status ? ` (${r.status})` : ""}`);
+      e.codigo = r.status_code;
+      throw e;
+    }
+    if (i < tentativas - 1) await pausa(ctx, intervaloMs);
+  }
+  throw new Error(`Instagram: o v\xEDdeo ainda est\xE1 processando depois de ${Math.round(maxMs / 6e4)} min; a pr\xF3xima tentativa continua`);
+}
+async function publicar({ item, ctx }) {
+  if (item.prep?.publicado) return item.prep.resultado;
+  const prep = await preparar({ item, ctx });
+  const t = await tokenValido(ctx), op = item.opcoes || {};
+  try {
+    await esperarContainer({ ctx, token: t.token, containerId: prep.containerId, intervaloMs: op.intervaloMs ?? 3e4, maxMs: op.esperaMaxMs ?? 10 * 6e4 });
+  } catch (e) {
+    if (e.codigo) {
+      await limpar(ctx, prep);
+      item.prep = null;
+    }
+    throw e;
+  }
+  try {
+    const q = await api(ctx, "GET", `${t.userId}/content_publishing_limit`, { fields: "quota_usage,config", access_token: t.token });
+    const uso = q.data?.[0]?.quota_usage, total = q.data?.[0]?.config?.quota_total;
+    if (uso != null && total != null && uso >= total) throw Object.assign(new Error(`cota de publica\xE7\xE3o do Instagram esgotada (${uso}/${total} em 24 h)`), { cota: true });
+  } catch (e) {
+    if (e.cota) throw e;
+  }
+  const pub = await api(ctx, "POST", `${t.userId}/media_publish`, { creation_id: prep.containerId, access_token: t.token });
+  const resultado = { id: pub.id, containerId: prep.containerId };
+  prep.publicado = pub.id;
+  prep.resultado = resultado;
+  try {
+    const m = await api(ctx, "GET", pub.id, { fields: "permalink", access_token: t.token });
+    resultado.url = m.permalink;
+  } catch (e) {
+    ctx.log?.(`\u26A0 publicado, mas sem o link (${e.message})`);
+  }
+  if (op.comentar !== false && item.textos?.comentarioFixo) {
+    try {
+      await api(ctx, "POST", `${pub.id}/comments`, { message: item.textos.comentarioFixo, access_token: t.token });
+      resultado.comentario = true;
+    } catch (e) {
+      ctx.log?.(`\u26A0 publicado, mas o coment\xE1rio falhou (${e.message}); precisa do escopo instagram_business_manage_comments no token (o post saiu normal); comente pelo app`);
+    }
+  }
+  await limpar(ctx, prep);
+  ctx.log?.(`\u2713 Instagram publicado${resultado.url ? ": " + resultado.url : ""}`);
+  return resultado;
+}
+export {
+  LIMITES,
+  antecedenciaMs,
+  avisosTexto,
+  avisosVideo,
+  conectar,
+  diasRestantes,
+  esperarContainer,
+  lerToken,
+  nome,
+  planejar,
+  preparar,
+  publicar,
+  rede,
+  status,
+  tokenValido
+};