@praeko/cli 0.0.0-stage → 0.1.0

package/dist/chunks/youtube-RZ4XTUZW.mjs

@@ -0,0 +1,199 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  API,
+  AUTH,
+  BLOCO,
+  ESCOPOS,
+  ESCOPOS_BASE,
+  ESCOPO_ANALYTICS,
+  LIMITE_MINIATURA,
+  REF_CLIENTE,
+  REF_TOKEN,
+  REVOGAR,
+  TOKEN,
+  UP,
+  acoesSeguintes,
+  agendarPublicacao,
+  aleatorioPadrao,
+  api,
+  b64url,
+  canalId,
+  cliente,
+  comentar,
+  definirMiniatura,
+  deps,
+  desafioPkceAsync,
+  enviarBloco,
+  enviarVideo,
+  esperarProcessamento,
+  falha,
+  finalizarPublicacao,
+  imediato,
+  iniciarUpload,
+  mensagemErro,
+  modoDe,
+  montarMetadados,
+  nome,
+  planejar,
+  publicar,
+  rede,
+  registroToken,
+  revogar,
+  sincronizarUpload,
+  status,
+  tokenValido,
+  trocarCodigo,
+  urlAutorizacao
+} from "./chunk-UK3UKRPR.mjs";
+import "./chunk-LCFK6X55.mjs";
+
+// ../core/src/provedores/youtube.mjs
+import { createServer } from "node:http";
+import { createHash, randomBytes } from "node:crypto";
+import { closeSync, fstatSync, openSync, readSync, statSync } from "node:fs";
+import { spawn, spawnSync } from "node:child_process";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+var b64url2 = (b) => Buffer.from(b).toString("base64url");
+var desafioPkce = (verificador) => createHash("sha256").update(verificador).digest("base64url");
+function abrirArquivoReal(caminho) {
+  const fd = openSync(caminho, "r"), tamanho = fstatSync(fd).size;
+  return {
+    tamanho,
+    ler(inicio, n) {
+      const buf = Buffer.alloc(Math.min(n, tamanho - inicio));
+      readSync(fd, buf, 0, buf.length, inicio);
+      return buf;
+    },
+    fechar() {
+      closeSync(fd);
+    }
+  };
+}
+function converterParaJpeg(entrada) {
+  const saida = join(tmpdir(), `praeko-miniatura-${Date.now()}.jpg`);
+  const r = spawnSync("ffmpeg", ["-v", "error", "-y", "-i", entrada, "-q:v", "3", saida], { stdio: "inherit" });
+  if (r.status !== 0) throw new Error("ffmpeg n\xE3o conseguiu reduzir a miniatura");
+  return saida;
+}
+function comNode(ctx) {
+  return {
+    ...ctx,
+    deps: {
+      abrirArquivo: ctx.midia ? void 0 : abrirArquivoReal,
+      converterImagem: converterParaJpeg,
+      aleatorio: (n) => randomBytes(n),
+      abrirNavegador: (url) => {
+        try {
+          spawn("open", [url], { stdio: "ignore", detached: true }).unref();
+        } catch {
+        }
+      },
+      criarServidor: createServer,
+      ...ctx.deps
+    }
+  };
+}
+var tokenValido2 = (ctx) => tokenValido(comNode(ctx));
+var status2 = ({ ctx }) => status({ ctx: comNode(ctx) });
+var enviarVideo2 = (o) => enviarVideo({ ...o, ctx: comNode(o.ctx) });
+var publicar2 = ({ item, ctx }) => publicar({ item, ctx: comNode(ctx) });
+var comentar2 = ({ item, ctx }) => comentar({ item, ctx: comNode(ctx) });
+async function planejar2({ item, ctx }) {
+  let tam = "?";
+  try {
+    tam = (statSync(item.video).size / 1048576).toFixed(1) + " MB";
+  } catch {
+  }
+  return planejar({ item: { ...item, tamanhoTexto: tam }, ctx });
+}
+async function conectar({ ctx: ctx0, args = [] }) {
+  const ctx = comNode(ctx0), d = deps(ctx), cl = await cliente(ctx, args);
+  const verificador = b64url2(d.aleatorio(48)), estado = b64url2(d.aleatorio(16));
+  let aguardo;
+  const codigoP = new Promise((ok, no) => {
+    aguardo = { ok, no };
+  });
+  const srv = d.criarServidor((req, res) => {
+    const u = new URL(req.url, "http://127.0.0.1");
+    if (u.pathname !== "/") {
+      res.writeHead(404).end();
+      return;
+    }
+    const erro = u.searchParams.get("error"), codigo = u.searchParams.get("code");
+    res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+    res.end(`<meta charset="utf-8"><body style="font-family:sans-serif"><h2>${erro || !codigo ? "N\xE3o deu certo" : "Pronto"}</h2><p>${erro || !codigo ? "Volte ao terminal." : "Pode fechar esta aba e voltar ao terminal."}</p>`);
+    if (erro) aguardo.no(new Error(`autoriza\xE7\xE3o negada: ${erro}`));
+    else if (u.searchParams.get("state") !== estado) aguardo.no(new Error("state n\xE3o confere (tente de novo)"));
+    else if (codigo) aguardo.ok(codigo);
+  });
+  await new Promise((ok) => srv.listen(0, "127.0.0.1", ok));
+  const redirect = `http://127.0.0.1:${srv.address().port}`;
+  const url = urlAutorizacao({ clientId: cl.client_id, redirect, desafio: desafioPkce(verificador), estado });
+  ctx.log(`Abrindo o navegador para autorizar o Praeko no YouTube.
+Se n\xE3o abrir, copie este endere\xE7o:
+${url}`);
+  d.abrirNavegador(url);
+  const limite = setTimeout(() => aguardo.no(new Error("tempo esgotado (5 min) esperando a autoriza\xE7\xE3o")), d.limiteMs ?? 5 * 6e4);
+  try {
+    const codigo = await codigoP;
+    const j = await trocarCodigo(ctx, cl, { codigo, verificador, redirect });
+    await ctx.segredos.guardar(REF_CLIENTE, JSON.stringify(cl));
+    await ctx.segredos.guardar(REF_TOKEN, registroToken(j, d.agora()));
+  } finally {
+    clearTimeout(limite);
+    srv.close();
+  }
+  const s = await status2({ ctx });
+  ctx.log(s.conectado ? `\u2713 YouTube conectado: ${s.detalhe}` : "\u26A0 autorizado, mas n\xE3o consegui ler o canal");
+  return s.conectado ? 0 : 1;
+}
+export {
+  API,
+  AUTH,
+  BLOCO,
+  ESCOPOS,
+  ESCOPOS_BASE,
+  ESCOPO_ANALYTICS,
+  LIMITE_MINIATURA,
+  REF_CLIENTE,
+  REF_TOKEN,
+  REVOGAR,
+  TOKEN,
+  UP,
+  acoesSeguintes,
+  agendarPublicacao,
+  aleatorioPadrao,
+  api,
+  b64url,
+  canalId,
+  cliente,
+  comNode,
+  comentar2 as comentar,
+  conectar,
+  definirMiniatura,
+  deps,
+  desafioPkce,
+  desafioPkceAsync,
+  enviarBloco,
+  enviarVideo2 as enviarVideo,
+  esperarProcessamento,
+  falha,
+  finalizarPublicacao,
+  imediato,
+  iniciarUpload,
+  mensagemErro,
+  modoDe,
+  montarMetadados,
+  nome,
+  planejar2 as planejar,
+  publicar2 as publicar,
+  rede,
+  registroToken,
+  revogar,
+  sincronizarUpload,
+  status2 as status,
+  tokenValido2 as tokenValido,
+  trocarCodigo,
+  urlAutorizacao
+};

package/dist/chunks/youtube-analytics-3KIW2ZIW.mjs

@@ -0,0 +1,109 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  ESCOPOS_BASE,
+  ESCOPO_ANALYTICS,
+  REF_TOKEN,
+  api,
+  falha
+} from "./chunk-UK3UKRPR.mjs";
+import "./chunk-LCFK6X55.mjs";
+
+// ../core/src/provedores/youtube-analytics.mjs
+var ANALYTICS = "https://youtubeanalytics.googleapis.com/v2/reports";
+var REPORTING = "https://youtubereporting.googleapis.com/v1";
+var TIPO_RELATORIO_ALCANCE = "channel_reach_basic_a1";
+var NOME_JOB_ALCANCE = "praeko-alcance";
+var erroReautorizar = (detalhe) => Object.assign(new Error(`o token do YouTube n\xE3o tem o escopo yt-analytics.readonly: reconecte o canal para liberar reten\xE7\xE3o, impress\xF5es e CTR${detalhe ? ` (${detalhe})` : ""}`), { status: 403, reautorizar: true });
+async function escoposConcedidos(ctx) {
+  const bruto = await ctx.segredos.obter(REF_TOKEN);
+  if (!bruto) return null;
+  let t;
+  try {
+    t = JSON.parse(bruto);
+  } catch {
+    return null;
+  }
+  return Array.isArray(t.escopos) ? t.escopos : ESCOPOS_BASE;
+}
+var temEscopoAnalytics = async (ctx) => (await escoposConcedidos(ctx))?.includes(ESCOPO_ANALYTICS) ?? false;
+async function lerRespostaGoogle(r) {
+  const txt = await r.text();
+  if (r.ok) return txt ? JSON.parse(txt) : {};
+  if (r.status === 403 && /insufficient|scope|permission|access.?not.?configured|accessNotConfigured/i.test(txt)) {
+    if (/accessNotConfigured|has not been used|is disabled/i.test(txt)) throw Object.assign(falha(r.status, txt), { apiDesligada: true });
+    throw erroReautorizar();
+  }
+  if (r.status === 401) throw erroReautorizar("token recusado");
+  throw falha(r.status, txt);
+}
+var dataISO = (ms) => new Date(ms).toISOString().slice(0, 10);
+var arredonda = (x, n = 4) => Number.isFinite(+x) ? Math.round(+x * 10 ** n) / 10 ** n : null;
+var linhasDe = (j) => {
+  const cols = (j.columnHeaders || []).map((c) => c.name);
+  return (j.rows || []).map((l) => Object.fromEntries(cols.map((c, i) => [c, l[i]])));
+};
+async function retencaoDoVideo({ ctx, videoId, publicadoEm, agora = Date.now() }) {
+  const inicio = dataISO(Math.min(Date.parse(publicadoEm) || agora, agora) - 864e5), fim = dataISO(agora);
+  const consulta = (extra) => `${ANALYTICS}?${new URLSearchParams({ ids: "channel==MINE", startDate: inicio, endDate: fim, ...extra })}`;
+  const curvaJ = await lerRespostaGoogle(await api(ctx, consulta({ metrics: "audienceWatchRatio,relativeRetentionPerformance", dimensions: "elapsedVideoTimeRatio", filters: `video==${videoId};audienceType==ORGANIC` })));
+  const curva = linhasDe(curvaJ).map((l) => [arredonda(l.elapsedVideoTimeRatio), arredonda(l.audienceWatchRatio), arredonda(l.relativeRetentionPerformance)]).filter((p) => p[0] != null && p[1] != null).sort((a, b) => a[0] - b[0]);
+  const totJ = await lerRespostaGoogle(await api(ctx, consulta({ metrics: "views,estimatedMinutesWatched,averageViewDuration,averageViewPercentage", filters: `video==${videoId}` })));
+  const t = linhasDe(totJ)[0] || {};
+  return { curva, views: t.views ?? null, minutos: t.estimatedMinutesWatched ?? null, duracaoMediaSeg: t.averageViewDuration ?? null, percentualMedio: t.averageViewPercentage ?? null };
+}
+var jobs = async (ctx) => (await lerRespostaGoogle(await api(ctx, `${REPORTING}/jobs`))).jobs || [];
+async function garantirJobAlcance({ ctx }) {
+  const existente = (await jobs(ctx)).find((j2) => j2.reportTypeId === TIPO_RELATORIO_ALCANCE);
+  if (existente) return { id: existente.id, criado: false };
+  const j = await lerRespostaGoogle(await api(ctx, `${REPORTING}/jobs`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ reportTypeId: TIPO_RELATORIO_ALCANCE, name: NOME_JOB_ALCANCE }) }));
+  return { id: j.id, criado: true };
+}
+async function relatoriosDoJob({ ctx, jobId, criadosApos }) {
+  const out = [];
+  let pagina;
+  for (let i = 0; i < 10; i++) {
+    const q = new URLSearchParams({ pageSize: "100", ...criadosApos ? { createdAfter: criadosApos } : {}, ...pagina ? { pageToken: pagina } : {} });
+    const j = await lerRespostaGoogle(await api(ctx, `${REPORTING}/jobs/${encodeURIComponent(jobId)}/reports?${q}`));
+    for (const r of j.reports || []) out.push({ id: r.id, inicio: r.startTime, fim: r.endTime, criadoEm: r.createTime, url: r.downloadUrl });
+    pagina = j.nextPageToken;
+    if (!pagina) break;
+  }
+  return out.sort((a, b) => String(a.criadoEm).localeCompare(String(b.criadoEm)));
+}
+function lerCsvAlcance(csv) {
+  const linhas = String(csv || "").split(/\r?\n/).filter((l) => l.trim());
+  if (linhas.length < 2) return [];
+  const cab = linhas[0].split(",").map((c) => c.trim()), ix = (n) => cab.indexOf(n);
+  const iD = ix("date"), iV = ix("video_id"), iI = ix("video_thumbnail_impressions"), iC = ix("video_thumbnail_impressions_ctr");
+  if (iD < 0 || iV < 0 || iI < 0) return [];
+  const out = [];
+  for (const l of linhas.slice(1)) {
+    const c = l.split(","), d = String(c[iD] || "").trim();
+    if (!/^\d{8}$/.test(d) || !c[iV]?.trim()) continue;
+    const imp = Number(c[iI]), ctr = iC >= 0 && c[iC]?.trim() !== "" ? Number(c[iC]) : null;
+    if (!Number.isFinite(imp)) continue;
+    out.push({ dia: `${d.slice(0, 4)}-${d.slice(4, 6)}-${d.slice(6, 8)}`, videoId: c[iV].trim(), impressoes: Math.round(imp), ctr: ctr != null && Number.isFinite(ctr) ? ctr : null });
+  }
+  return out;
+}
+async function baixarRelatorioAlcance({ ctx, url }) {
+  if (!/^https:\/\/youtubereporting\.googleapis\.com\//.test(String(url))) throw new Error("URL de relat\xF3rio inesperada");
+  const r = await api(ctx, url);
+  if (!r.ok) await lerRespostaGoogle(r);
+  return lerCsvAlcance(await r.text());
+}
+export {
+  ANALYTICS,
+  ESCOPO_ANALYTICS,
+  NOME_JOB_ALCANCE,
+  REPORTING,
+  TIPO_RELATORIO_ALCANCE,
+  baixarRelatorioAlcance,
+  erroReautorizar,
+  escoposConcedidos,
+  garantirJobAlcance,
+  lerCsvAlcance,
+  relatoriosDoJob,
+  retencaoDoVideo,
+  temEscopoAnalytics
+};

package/dist/chunks/youtube-api-Z2RP5D2V.mjs

@@ -0,0 +1,94 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  API,
+  AUTH,
+  BLOCO,
+  ESCOPOS,
+  ESCOPOS_BASE,
+  ESCOPO_ANALYTICS,
+  LIMITE_MINIATURA,
+  REF_CLIENTE,
+  REF_TOKEN,
+  REVOGAR,
+  TOKEN,
+  UP,
+  acoesSeguintes,
+  agendarPublicacao,
+  aleatorioPadrao,
+  api,
+  b64url,
+  canalId,
+  cliente,
+  comentar,
+  definirMiniatura,
+  deps,
+  desafioPkceAsync,
+  enviarBloco,
+  enviarVideo,
+  esperarProcessamento,
+  falha,
+  finalizarPublicacao,
+  imediato,
+  iniciarUpload,
+  mensagemErro,
+  modoDe,
+  montarMetadados,
+  nome,
+  planejar,
+  publicar,
+  rede,
+  registroToken,
+  revogar,
+  sincronizarUpload,
+  status,
+  tokenValido,
+  trocarCodigo,
+  urlAutorizacao
+} from "./chunk-UK3UKRPR.mjs";
+import "./chunk-LCFK6X55.mjs";
+export {
+  API,
+  AUTH,
+  BLOCO,
+  ESCOPOS,
+  ESCOPOS_BASE,
+  ESCOPO_ANALYTICS,
+  LIMITE_MINIATURA,
+  REF_CLIENTE,
+  REF_TOKEN,
+  REVOGAR,
+  TOKEN,
+  UP,
+  acoesSeguintes,
+  agendarPublicacao,
+  aleatorioPadrao,
+  api,
+  b64url,
+  canalId,
+  cliente,
+  comentar,
+  definirMiniatura,
+  deps,
+  desafioPkceAsync,
+  enviarBloco,
+  enviarVideo,
+  esperarProcessamento,
+  falha,
+  finalizarPublicacao,
+  imediato,
+  iniciarUpload,
+  mensagemErro,
+  modoDe,
+  montarMetadados,
+  nome,
+  planejar,
+  publicar,
+  rede,
+  registroToken,
+  revogar,
+  sincronizarUpload,
+  status,
+  tokenValido,
+  trocarCodigo,
+  urlAutorizacao
+};

package/dist/chunks/youtube-comunidade-OAK5GGK4.mjs

@@ -0,0 +1,25 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  apagarVideo,
+  editarVideo,
+  estatisticasCanal,
+  estatisticasVideos,
+  lerVideo,
+  listarComentarios,
+  listarVideos,
+  responderComentario,
+  trocarHashtags
+} from "./chunk-LLXYUCTT.mjs";
+import "./chunk-UK3UKRPR.mjs";
+import "./chunk-LCFK6X55.mjs";
+export {
+  apagarVideo,
+  editarVideo,
+  estatisticasCanal,
+  estatisticasVideos,
+  lerVideo,
+  listarComentarios,
+  listarVideos,
+  responderComentario,
+  trocarHashtags
+};

package/dist/praeko.mjs

@@ -0,0 +1,11 @@
+#!/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 "./chunks/chunk-LCFK6X55.mjs";

package/package.json

@@ -1,6 +1,50 @@
 {
   "name": "@praeko/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "type": "module",
+  "description": "CLI do Praeko: publica e agenda vídeos curtos no YouTube, Instagram e TikTok, e fala com a API do serviço (praeko.app).",
+  "license": "MIT",
+  "keywords": [
+    "praeko",
+    "cli",
+    "social-media",
+    "youtube",
+    "instagram",
+    "tiktok",
+    "scheduler"
+  ],
+  "homepage": "https://praeko.app/docs",
+  "bugs": {
+    "url": "https://github.com/Praeko/praeko-js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Praeko/praeko-js.git",
+    "directory": "packages/cli"
+  },
+  "bin": {
+    "praeko": "dist/praeko.mjs",
+    "arauto": "dist/arauto.mjs"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node ../../scripts/build-cli.mjs",
+    "prepack": "npm run build"
+  },
+  "devDependencies": {
+    "@praeko/core": "*",
+    "@praeko/sdk": "*"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}