@praeko/cli 0.0.0-stage → 0.1.1

package/dist/chunks/chunk-TTGQU5CG.mjs

@@ -0,0 +1,238 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  carregarTodos
+} from "./chunk-VJRMAQCR.mjs";
+import {
+  PROVEDORES,
+  validarPedido
+} from "./chunk-Z325UM27.mjs";
+import {
+  __export,
+  __glob
+} from "./chunk-LCFK6X55.mjs";
+
+// ../core/src/adaptadores/local.mjs
+var local_exports = {};
+__export(local_exports, {
+  MODO_PADRAO: () => MODO_PADRAO,
+  criar: () => criar,
+  estadoDe: () => estadoDe
+});
+
+// ../core/src/fila.mjs
+import { existsSync as existsSync2, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { randomBytes } from "node:crypto";
+
+// ../core/src/estado.mjs
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+var PASTA_ESTADO = ".praeko";
+var PASTA_ESTADO_ANTIGA = ".arauto";
+var pastaEstado = (raiz) => join(raiz, PASTA_ESTADO);
+var caminhoEstado = (raiz, ...nome) => join(raiz, PASTA_ESTADO, ...nome);
+function caminhoLeitura(raiz, ...nome) {
+  const novo = caminhoEstado(raiz, ...nome);
+  if (existsSync(novo)) return novo;
+  const velho = join(raiz, PASTA_ESTADO_ANTIGA, ...nome);
+  return existsSync(velho) ? velho : novo;
+}
+
+// ../core/src/fila.mjs
+var MAX_TENTATIVAS = 3;
+var arquivoFila = (raiz) => caminhoEstado(raiz, "fila.json");
+function lerFila(raiz) {
+  const f = caminhoLeitura(raiz, "fila.json");
+  return existsSync2(f) ? JSON.parse(readFileSync(f, "utf8")) : { itens: [] };
+}
+function salvarFila(raiz, fila) {
+  const f = arquivoFila(raiz);
+  mkdirSync(dirname(f), { recursive: true });
+  writeFileSync(f + ".tmp", JSON.stringify(fila, null, 2) + "\n");
+  renameSync(f + ".tmp", f);
+}
+function enfileirar(raiz, item) {
+  const fila = lerFila(raiz);
+  const it = { id: randomBytes(4).toString("hex"), estado: "pendente", tentativas: 0, criadoEm: (/* @__PURE__ */ new Date()).toISOString(), ...item };
+  fila.itens.push(it);
+  salvarFila(raiz, fila);
+  return it;
+}
+function liberarItem(raiz, id) {
+  const fila = lerFila(raiz), it = fila.itens.find((x) => x.id === id || x.id.startsWith(id));
+  if (!it) throw new Error(`item ${id} n\xE3o existe na fila`);
+  if (!it.manual) throw new Error(`item ${it.id} n\xE3o \xE9 manual`);
+  it.manual = false;
+  it.quando = (/* @__PURE__ */ new Date()).toISOString();
+  it.tentativas = 0;
+  it.estado = "pendente";
+  salvarFila(raiz, fila);
+  return it;
+}
+function cancelarItem(raiz, id) {
+  const fila = lerFila(raiz), it = fila.itens.find((x) => x.id === id || x.id.startsWith(id));
+  if (!it) throw new Error(`item ${id} n\xE3o existe na fila`);
+  if (it.estado === "enviado") throw new Error(`item ${it.id} j\xE1 foi enviado; desfa\xE7a pela pr\xF3pria rede`);
+  it.estado = "cancelado";
+  it.canceladoEm = (/* @__PURE__ */ new Date()).toISOString();
+  salvarFila(raiz, fila);
+  return it;
+}
+function proximaAcao(it, prov, agora) {
+  if (it.manual) return null;
+  if (!["pendente", "preparado"].includes(it.estado) || it.tentativas >= MAX_TENTATIVAS) return null;
+  const t = Date.parse(it.quando), ant = it.acao ? 0 : prov.antecedenciaMs ?? 0;
+  if (prov.imediato && !it.acao) return it.estado === "pendente" ? "publicar" : null;
+  if (it.estado === "pendente" && prov.preparar && +agora >= t - ant && +agora < t) return "preparar";
+  if (+agora >= t) return "publicar";
+  return null;
+}
+async function executar({ raiz, provedores, ctx, agora = /* @__PURE__ */ new Date(), simular = false, soIds = null, log = console.log }) {
+  const fila = lerFila(raiz), feitos = [];
+  for (const it of fila.itens) {
+    if (soIds && !soIds.includes(it.id)) continue;
+    const prov = provedores[it.provedor];
+    if (!prov) {
+      if (["pendente", "preparado"].includes(it.estado)) log(`\u26A0 ${it.id}: provedor "${it.provedor}" n\xE3o instalado`);
+      continue;
+    }
+    let acao = proximaAcao(it, prov, agora);
+    while (acao) {
+      if (simular) {
+        log(`\u2022 ${it.id} ${it.rede} (${it.slug}): ${acao}`);
+        break;
+      }
+      try {
+        if (acao === "preparar") {
+          it.prep = await prov.preparar({ item: it, ctx });
+          it.estado = "preparado";
+          log(`\u2713 ${it.id} ${it.rede}: preparado`);
+        } else {
+          it.resultado = await prov.publicar({ item: it, ctx });
+          it.estado = "enviado";
+          it.enviadoEm = (/* @__PURE__ */ new Date()).toISOString();
+          log(`\u2713 ${it.id} ${it.rede}${it.acao ? " (" + it.acao + ")" : ""}: enviado${it.resultado?.url ? " " + it.resultado.url : ""}`);
+          for (const s of it.resultado?.seguinte || []) fila.itens.push({ id: randomBytes(4).toString("hex"), estado: "pendente", tentativas: 0, criadoEm: (/* @__PURE__ */ new Date()).toISOString(), origem: it.id, ...s });
+          delete it.resultado.seguinte;
+        }
+        feitos.push(it.id);
+      } catch (e) {
+        it.tentativas++;
+        it.erro = String(e.message || e).slice(0, 500);
+        if (it.tentativas >= MAX_TENTATIVAS) it.estado = "erro";
+        log(`\u2717 ${it.id} ${it.rede}: ${it.erro}${it.estado === "erro" ? " (desisti)" : ` (tentativa ${it.tentativas}/${MAX_TENTATIVAS})`}`);
+      }
+      salvarFila(raiz, fila);
+      acao = it.estado === "enviado" ? null : acao === "preparar" && it.estado === "preparado" ? proximaAcao(it, prov, agora) : null;
+    }
+  }
+  return { feitos, fila };
+}
+function plistLaunchd({ rotulo = "br.praeko.fila", node, praeko, arauto, cwd, minutos = 5, log }) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+<key>Label</key><string>${rotulo}</string>
+<key>ProgramArguments</key><array><string>${node}</string><string>${praeko ?? arauto}</string><string>fila</string><string>executar</string></array>
+<key>WorkingDirectory</key><string>${cwd}</string>
+<key>StartInterval</key><integer>${minutos * 60}</integer>
+<key>RunAtLoad</key><true/>
+<key>StandardOutPath</key><string>${log}</string><key>StandardErrorPath</key><string>${log}</string>
+</dict></plist>
+`;
+}
+
+// import("./adaptadores/**/*.mjs") in ../core/src/publicador.mjs
+var globImport_adaptadores_mjs = __glob({
+  "./adaptadores/buffer.mjs": () => import("./buffer-SP52FWTI.mjs"),
+  "./adaptadores/index.mjs": () => import("./adaptadores-ESUZ36N2.mjs"),
+  "./adaptadores/local.mjs": () => import("./local-FMMUWECN.mjs"),
+  "./adaptadores/remoto.mjs": () => import("./remoto-OAB5Y2MS.mjs")
+});
+
+// ../core/src/publicador.mjs
+async function criarPublicador({ config, provedor, ctx } = {}) {
+  const nome = provedor || config?.provedor || "buffer";
+  if (!PROVEDORES.includes(nome)) throw new Error(`provedor "${nome}" desconhecido (use ${PROVEDORES.join(", ")})`);
+  const mod = await globImport_adaptadores_mjs(`./adaptadores/${nome}.mjs`);
+  return mod.criar({ config, ctx });
+}
+
+// ../core/src/adaptadores/local.mjs
+import { randomBytes as randomBytes2 } from "node:crypto";
+var MODO_PADRAO = { youtube: "privado", tiktok: "rascunho", instagram: "agora" };
+function estadoDe(it) {
+  if (it.estado === "cancelado") return "cancelado";
+  if (it.estado === "erro") return "erro";
+  if (it.estado === "enviado") {
+    if (it.acao) return "enviado";
+    if (it.rede === "youtube" && it.resultado?.privacidade === "private" && !it.resultado?.publishAt) return "privado";
+    if (it.rede === "tiktok" && it.resultado?.modo === "rascunho") return "rascunho";
+    return it.rede === "youtube" && it.resultado?.publishAt ? "agendado" : "enviado";
+  }
+  return "agendado";
+}
+var itemDoContrato = (it) => ({ rede: it.rede, id: it.id, estado: estadoDe(it), quando: it.quando, ...it.acao ? { acao: it.acao } : {}, ...it.manual ? { manual: true } : {}, ...it.resultado?.url ? { url: it.resultado.url } : {}, ...it.resultado?.studio ? { studio: it.resultado.studio } : {}, ...it.erro ? { aviso: it.erro } : {} });
+function criar({ config, ctx, provedores }) {
+  const todos = async () => provedores || carregarTodos();
+  const agora = () => ctx.agora ? ctx.agora() : /* @__PURE__ */ new Date();
+  const doPedido = (id) => lerFila(ctx.raiz).itens.filter((x) => x.pedido === id);
+  return {
+    nome: "local",
+    async publicar(pedido) {
+      const erros = validarPedido(pedido);
+      if (erros.length) throw new Error(`pedido inv\xE1lido: ${erros.join("; ")}`);
+      const id = pedido.id || `p${randomBytes2(3).toString("hex")}`, provs = await todos();
+      const faltam = pedido.destinos.filter((d) => !provs[d.rede]).map((d) => d.rede);
+      if (faltam.length) throw new Error(`provedor n\xE3o instalado: ${faltam.join(", ")}`);
+      const novos = pedido.destinos.map((d) => {
+        const op = { ...config[d.rede] || {}, ...pedido.opcoes?.[d.rede] || {} };
+        op.modo = d.modo || op.modo || MODO_PADRAO[d.rede];
+        return enfileirar(ctx.raiz, { pedido: id, slug: id, rede: d.rede, provedor: d.rede, quando: d.quando || agora().toISOString(), video: pedido.midia.video, capa: pedido.midia.capa || null, textos: pedido.textos[d.rede], opcoes: op, formato: pedido.opcoes?.formato || "short", titulo: pedido.titulo });
+      });
+      await executar({ raiz: ctx.raiz, provedores: provs, ctx, agora: agora(), soIds: novos.map((n) => n.id), log: ctx.log });
+      return { id, itens: doPedido(id).map(itemDoContrato) };
+    },
+    async status(id) {
+      const it = doPedido(id);
+      if (!it.length) throw new Error(`pedido ${id} n\xE3o existe na fila`);
+      return { id, itens: it.map(itemDoContrato) };
+    },
+    async cancelar(id) {
+      const cancelados = [], mantidos = [];
+      for (const it of doPedido(id)) {
+        if (["enviado", "cancelado"].includes(it.estado)) {
+          if (it.estado === "enviado") mantidos.push(itemDoContrato(it));
+        } else {
+          cancelarItem(ctx.raiz, it.id);
+          cancelados.push(it.id);
+        }
+      }
+      return { cancelados, mantidos };
+    },
+    async canais() {
+      const provs = await todos(), out = [];
+      for (const [rede, p] of Object.entries(provs)) {
+        const s = await p.status({ ctx });
+        out.push({ rede, conectado: s.conectado, detalhe: s.detalhe });
+      }
+      return out;
+    }
+  };
+}
+
+export {
+  pastaEstado,
+  caminhoEstado,
+  caminhoLeitura,
+  lerFila,
+  liberarItem,
+  cancelarItem,
+  executar,
+  plistLaunchd,
+  MODO_PADRAO,
+  estadoDe,
+  criar,
+  local_exports,
+  criarPublicador
+};

package/dist/chunks/chunk-UK3UKRPR.mjs

@@ -0,0 +1,363 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+
+// ../core/src/provedores/youtube-api.mjs
+var nome = "youtube";
+var rede = "youtube";
+var imediato = true;
+var REF_CLIENTE = "youtube/cliente";
+var REF_TOKEN = "youtube/token";
+var ESCOPOS_BASE = ["https://www.googleapis.com/auth/youtube.upload", "https://www.googleapis.com/auth/youtube.force-ssl"];
+var ESCOPO_ANALYTICS = "https://www.googleapis.com/auth/yt-analytics.readonly";
+var ESCOPOS = [...ESCOPOS_BASE, ESCOPO_ANALYTICS];
+var AUTH = "https://accounts.google.com/o/oauth2/v2/auth";
+var TOKEN = "https://oauth2.googleapis.com/token";
+var REVOGAR = "https://oauth2.googleapis.com/revoke";
+var API = "https://www.googleapis.com/youtube/v3";
+var UP = "https://www.googleapis.com/upload/youtube/v3";
+var BLOCO = 8 * 1024 * 1024;
+var LIMITE_MINIATURA = 2 * 1024 * 1024;
+var TENTATIVAS = 5;
+var b64url = (bytes) => {
+  const u = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+  let s = "";
+  for (const b of u) s += String.fromCharCode(b);
+  return btoa(s).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+};
+var aleatorioPadrao = (n) => crypto.getRandomValues(new Uint8Array(n));
+async function desafioPkceAsync(verificador) {
+  return b64url(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verificador)));
+}
+var dormirPadrao = (ms) => new Promise((r) => setTimeout(r, ms));
+var bytesDe = (x) => x instanceof Uint8Array ? x : new Uint8Array(x);
+function deps(ctx) {
+  const d = ctx.deps || {};
+  return {
+    ...d,
+    dormir: d.dormir || dormirPadrao,
+    agora: d.agora || (() => Date.now()),
+    aleatorio: d.aleatorio || aleatorioPadrao,
+    abrirArquivo: d.abrirArquivo || (ctx.midia ? (ref) => ctx.midia.abrir(ref) : () => {
+      throw new Error("sem acesso a arquivo: o contexto precisa de ctx.midia.abrir (ou ctx.deps.abrirArquivo)");
+    }),
+    converterImagem: d.converterImagem || (() => {
+      throw new Error("a capa passa de 2 MB e n\xE3o h\xE1 convers\xE3o neste ambiente; envie a capa j\xE1 em JPEG/PNG menor");
+    })
+  };
+}
+function mensagemErro(status2, corpo) {
+  let j = null;
+  try {
+    j = JSON.parse(corpo);
+  } catch {
+  }
+  const e = j?.error, razao = e?.errors?.[0]?.reason || e?.status || "", msg = e?.message || String(corpo || "").slice(0, 200);
+  if (/quotaExceeded|rateLimitExceeded|dailyLimitExceeded/i.test(razao) || /quota/i.test(msg)) return `cota da API do YouTube esgotada (${razao || status2}): uploads custam 1 unidade e h\xE1 um teto di\xE1rio; tente depois da meia-noite do Pac\xEDfico`;
+  if (/uploadLimitExceeded/i.test(razao)) return "o canal atingiu o limite de uploads do dia";
+  if (/forbidden|insufficientPermissions/i.test(razao) || status2 === 403) return `YouTube negou (403 ${razao}): ${msg}. Confira os escopos (praeko conta youtube conectar) e se o canal est\xE1 verificado para miniaturas`;
+  if (status2 === 401) return "token recusado (401): rode `praeko conta youtube conectar` de novo";
+  return `YouTube ${status2} ${razao}: ${msg}`;
+}
+var falha = (status2, corpo) => Object.assign(new Error(mensagemErro(status2, corpo)), { status: status2 });
+async function cliente(ctx, args = []) {
+  const f = (k) => {
+    const i = args.indexOf("--" + k);
+    return i >= 0 ? args[i + 1] : void 0;
+  };
+  const id = f("cliente-id"), segredo = f("cliente-segredo");
+  if (id && segredo) return { client_id: id, client_secret: segredo };
+  const salvo = await ctx.segredos.obter(REF_CLIENTE);
+  if (salvo) {
+    const j = JSON.parse(salvo);
+    if (j.client_id && j.client_secret) return j;
+  }
+  throw new Error("sem credencial OAuth do Google: praeko conta youtube conectar --cliente-id <id> --cliente-segredo <segredo> (veja docs/youtube.md)");
+}
+function urlAutorizacao({ clientId, redirect, desafio, estado }) {
+  const q = new URLSearchParams({ client_id: clientId, redirect_uri: redirect, response_type: "code", scope: ESCOPOS.join(" "), code_challenge: desafio, code_challenge_method: "S256", state: estado, access_type: "offline", prompt: "consent" });
+  return `${AUTH}?${q}`;
+}
+async function trocarCodigo(ctx, cl, { codigo, verificador, redirect }) {
+  const r = await ctx.fetchFn(TOKEN, { method: "POST", headers: { "content-type": "application/x-www-form-urlencoded" }, body: new URLSearchParams({ code: codigo, client_id: cl.client_id, client_secret: cl.client_secret, code_verifier: verificador, redirect_uri: redirect, grant_type: "authorization_code" }).toString() });
+  const j = await r.json();
+  if (!r.ok) throw new Error(`Google recusou o c\xF3digo: ${j.error_description || j.error}`);
+  if (!j.refresh_token) throw new Error("o Google n\xE3o devolveu refresh_token (revogue o acesso em myaccount.google.com/permissions e conecte de novo)");
+  return j;
+}
+function registroToken(j, agora) {
+  return JSON.stringify({ access_token: j.access_token, refresh_token: j.refresh_token, expiry: agora + (j.expires_in || 3600) * 1e3, escopos: (j.scope || ESCOPOS_BASE.join(" ")).split(" ") });
+}
+async function tokenValido(ctx) {
+  const d = deps(ctx), bruto = await ctx.segredos.obter(REF_TOKEN);
+  if (!bruto) throw new Error("YouTube n\xE3o conectado: praeko conta youtube conectar");
+  const t = JSON.parse(bruto);
+  if (t.access_token && t.expiry - 6e4 > d.agora()) return t.access_token;
+  const cl = await cliente(ctx);
+  const r = await ctx.fetchFn(TOKEN, { method: "POST", headers: { "content-type": "application/x-www-form-urlencoded" }, body: new URLSearchParams({ client_id: cl.client_id, client_secret: cl.client_secret, refresh_token: t.refresh_token, grant_type: "refresh_token" }).toString() });
+  const j = await r.json();
+  if (!r.ok) throw new Error(j.error === "invalid_grant" ? "o Google revogou o refresh token (app em modo Testing expira em 7 dias): rode `praeko conta youtube conectar` e publique o app como Em produ\xE7\xE3o (docs/youtube.md)" : `n\xE3o consegui renovar o token: ${j.error_description || j.error}`);
+  const novo = { ...t, access_token: j.access_token, expiry: d.agora() + (j.expires_in || 3600) * 1e3, ...j.refresh_token ? { refresh_token: j.refresh_token } : {} };
+  await ctx.segredos.guardar(REF_TOKEN, JSON.stringify(novo));
+  return novo.access_token;
+}
+async function revogar(ctx) {
+  try {
+    const bruto = await ctx.segredos.obter(REF_TOKEN);
+    if (!bruto) return false;
+    const t = JSON.parse(bruto), token = t.refresh_token || t.access_token;
+    if (!token) return false;
+    const r = await ctx.fetchFn(REVOGAR, { method: "POST", headers: { "content-type": "application/x-www-form-urlencoded" }, body: new URLSearchParams({ token }).toString() });
+    return r.ok;
+  } catch {
+    return false;
+  }
+}
+async function api(ctx, url, opcoes = {}) {
+  const token = await tokenValido(ctx);
+  return ctx.fetchFn(url, { ...opcoes, headers: { authorization: `Bearer ${token}`, ...opcoes.headers || {} } });
+}
+async function status({ ctx }) {
+  if (!await ctx.segredos.obter(REF_TOKEN)) return { conectado: false, detalhe: "rode: praeko conta youtube conectar --cliente-id \u2026 --cliente-segredo \u2026" };
+  try {
+    const r = await api(ctx, `${API}/channels?part=snippet&mine=true`);
+    const txt = await r.text();
+    if (!r.ok) return { conectado: false, detalhe: mensagemErro(r.status, txt) };
+    const c = JSON.parse(txt).items?.[0];
+    return c ? { conectado: true, detalhe: c.snippet.title, ...c.id ? { canalId: c.id } : {} } : { conectado: false, detalhe: "a conta autorizada n\xE3o tem canal do YouTube" };
+  } catch (e) {
+    return { conectado: false, detalhe: e.message };
+  }
+}
+function modoDe(item) {
+  const m = item.opcoes?.modo || "privado";
+  if (!["privado", "agendado", "publico"].includes(m)) throw new Error(`modo do YouTube inv\xE1lido: ${m} (use privado, agendado ou publico)`);
+  return m;
+}
+function montarMetadados(item, agora = Date.now()) {
+  const o = item.opcoes || {}, modo = modoDe(item);
+  let titulo = item.textos?.titulo || item.titulo || item.slug;
+  if (titulo.length > 100) titulo = titulo.slice(0, 99).trimEnd() + "\u2026";
+  const status2 = { privacyStatus: modo === "publico" ? "public" : "private", selfDeclaredMadeForKids: false, embeddable: true, publicStatsViewable: true };
+  if (modo === "agendado") {
+    const t = Date.parse(item.quando);
+    if (!(t > agora + 6e4)) throw new Error(`modo agendado: ${item.quando} j\xE1 passou ou \xE9 daqui a menos de 1 minuto`);
+    status2.publishAt = new Date(t).toISOString();
+  }
+  return {
+    snippet: { title: titulo, description: item.textos?.texto || "", categoryId: String(o.categoriaId || "28"), defaultLanguage: "pt", defaultAudioLanguage: "pt", ...o.tags ? { tags: o.tags } : {} },
+    status: status2
+  };
+}
+var dormir = (ms, d) => d.dormir(ms);
+var lerRange = (rg) => rg ? Number(rg.split("-")[1]) + 1 : 0;
+async function iniciarUpload({ ctx, total, metadados, avisarInscritos = false }) {
+  const q = new URLSearchParams({ uploadType: "resumable", part: "snippet,status", notifySubscribers: String(!!avisarInscritos) });
+  const ini = await api(ctx, `${UP}/videos?${q}`, { method: "POST", headers: { "content-type": "application/json; charset=UTF-8", "x-upload-content-length": String(total), "x-upload-content-type": "video/mp4" }, body: JSON.stringify(metadados) });
+  if (!ini.ok) throw falha(ini.status, await ini.text());
+  const sessao = ini.headers.get("location");
+  if (!sessao) throw new Error("o YouTube n\xE3o devolveu o endere\xE7o da sess\xE3o de upload");
+  return { sessao, total };
+}
+async function sincronizarUpload({ ctx, sessao, total }) {
+  const r = await ctx.fetchFn(sessao, { method: "PUT", headers: { "content-length": "0", "content-range": `bytes */${total}` } });
+  if (r.status === 200 || r.status === 201) return { fim: true, video: await r.json() };
+  if (r.status === 308) return { fim: false, pos: lerRange(r.headers.get("range")) };
+  if (r.status === 404) throw Object.assign(new Error("a sess\xE3o de upload expirou (404): refa\xE7a o upload"), { sessaoExpirada: true });
+  throw Object.assign(falha(r.status, await r.text()), { transitorio: r.status >= 500 });
+}
+async function enviarBloco({ ctx, f, sessao, total, pos, sincronizar = true }) {
+  if (sincronizar) {
+    const s = await sincronizarUpload({ ctx, sessao, total });
+    if (s.fim) return s;
+    pos = s.pos;
+  }
+  if (pos >= total) return { fim: false, pos };
+  const bloco = bytesDe(await f.ler(pos, BLOCO)), fim = pos + bloco.length - 1;
+  let r;
+  try {
+    r = await ctx.fetchFn(sessao, { method: "PUT", headers: { "content-length": String(bloco.length), "content-range": `bytes ${pos}-${fim}/${total}`, "content-type": "video/mp4" }, body: bloco });
+  } catch (e) {
+    throw Object.assign(new Error(`falha de rede no upload: ${e.message}`), { transitorio: true });
+  }
+  if (r.status === 200 || r.status === 201) return { fim: true, video: await r.json() };
+  if (r.status === 308) return { fim: false, pos: lerRange(r.headers.get("range")) };
+  if ([500, 502, 503, 504].includes(r.status)) throw Object.assign(new Error(`YouTube ${r.status} no upload`), { transitorio: true });
+  throw falha(r.status, await r.text());
+}
+async function enviarVideo({ ctx, arquivo, metadados, avisarInscritos = false }) {
+  const d = deps(ctx), f = await d.abrirArquivo(arquivo), total = f.tamanho;
+  try {
+    const { sessao } = await iniciarUpload({ ctx, total, metadados, avisarInscritos });
+    let pos = 0, falhas = 0;
+    while (pos < total) {
+      try {
+        const r = await enviarBloco({ ctx, f, sessao, total, pos, sincronizar: false });
+        if (r.fim) return r.video;
+        pos = r.pos;
+        falhas = 0;
+      } catch (e) {
+        if (!e.transitorio) throw e;
+        if (++falhas > TENTATIVAS) throw new Error(`upload interrompido depois de ${TENTATIVAS} tentativas (${e.message})`);
+        await dormir(Math.min(3e4, 1e3 * 2 ** falhas), d);
+        const s = await sincronizarUpload({ ctx, sessao, total }).catch(() => null);
+        if (s?.fim) return s.video;
+        if (s) pos = s.pos;
+      }
+    }
+    throw new Error("o upload terminou sem resposta do YouTube");
+  } finally {
+    f.fechar?.();
+  }
+}
+async function esperarProcessamento(ctx, id, d = deps(ctx), tentativas = 12) {
+  for (let i = 0; i < tentativas; i++) {
+    const r = await api(ctx, `${API}/videos?part=processingDetails&id=${id}`);
+    if (r.ok) {
+      const s = (await r.json()).items?.[0]?.processingDetails?.processingStatus;
+      if (s === "succeeded") return true;
+      if (s === "failed" || s === "terminated") return false;
+    }
+    await d.dormir(1e4);
+  }
+  return false;
+}
+var sniffMime = (b) => b[0] === 137 && b[1] === 80 ? "image/png" : b[0] === 255 && b[1] === 216 ? "image/jpeg" : null;
+var MIME_EXT = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg" };
+async function definirMiniatura(ctx, id, capa, d = deps(ctx)) {
+  let arq = capa, f = await d.abrirArquivo(arq);
+  if (f.tamanho > LIMITE_MINIATURA) {
+    f.fechar?.();
+    arq = await d.converterImagem(arq);
+    f = await d.abrirArquivo(arq);
+  }
+  try {
+    const corpo = bytesDe(await f.ler(0, f.tamanho));
+    const ext = /\.([a-z0-9]+)$/i.exec(String(arq))?.[1]?.toLowerCase();
+    const mime = f.mime || MIME_EXT[ext] || sniffMime(corpo) || "image/jpeg";
+    const r = await api(ctx, `${UP}/thumbnails/set?videoId=${id}`, { method: "POST", headers: { "content-type": mime, "content-length": String(corpo.length) }, body: corpo });
+    if (!r.ok) throw falha(r.status, await r.text());
+    return true;
+  } finally {
+    f.fechar?.();
+  }
+}
+function acoesSeguintes(item, id, metadados, d) {
+  const texto = item.textos?.comentarioFixo;
+  if (!texto || item.opcoes?.comentar === false) return [];
+  const base = { slug: item.slug, rede: "youtube", provedor: "youtube", acao: "comentar", videoId: id, textos: { comentarioFixo: texto }, opcoes: {}, video: item.video, pedido: item.pedido };
+  const modo = modoDe(item);
+  if (modo === "agendado") return [{ ...base, quando: new Date(Date.parse(metadados.status.publishAt) + 2 * 6e4).toISOString() }];
+  if (modo === "publico") return [{ ...base, quando: new Date(d.agora() + 6e4).toISOString() }];
+  return [{ ...base, quando: null, manual: true }];
+}
+async function finalizarPublicacao({ item, ctx, video, metadados }) {
+  const d = deps(ctx), avisos = [], id = video.id;
+  let miniatura = false;
+  if (item.capa) {
+    try {
+      const pronto = await esperarProcessamento(ctx, id, d);
+      if (!pronto) avisos.push("o v\xEDdeo ainda estava processando; a miniatura pode n\xE3o ter pegado");
+      miniatura = await definirMiniatura(ctx, id, item.capa, d);
+    } catch (e) {
+      avisos.push(`miniatura n\xE3o definida (${e.message}); troque no Studio`);
+    }
+  }
+  for (const a of avisos) ctx.log?.(`  \u26A0 ${a}`);
+  const seguinte = acoesSeguintes(item, id, metadados, d);
+  if (seguinte.length && seguinte[0].manual) ctx.log?.("  \u2139 coment\xE1rio fixo guardado: depois de publicar no Studio, rode `praeko fila comentar <id>` (a API n\xE3o comenta em v\xEDdeo privado de forma garantida e n\xE3o fixa coment\xE1rio)");
+  return { id, url: `https://youtu.be/${id}`, studio: `https://studio.youtube.com/video/${id}/edit`, privacidade: metadados.status.privacyStatus, publishAt: metadados.status.publishAt, miniatura, avisos, seguinte };
+}
+async function publicar({ item, ctx }) {
+  if (item.acao === "comentar") return comentar({ item, ctx });
+  if (item.acao === "agendar") return agendarPublicacao({ item, ctx });
+  const d = deps(ctx);
+  const metadados = montarMetadados(item, d.agora());
+  ctx.log?.(`  YouTube: enviando ${String(item.video).split("/").pop()} (${metadados.status.privacyStatus})\u2026`);
+  const video = await enviarVideo({ ctx, arquivo: item.video, metadados, avisarInscritos: item.opcoes?.avisarInscritos });
+  return finalizarPublicacao({ item, ctx, video, metadados });
+}
+async function comentar({ item, ctx }) {
+  const canal = await ctx.segredos.obter(REF_TOKEN) && await canalId(ctx);
+  const corpo = { snippet: { channelId: canal, videoId: item.videoId, topLevelComment: { snippet: { textOriginal: item.textos.comentarioFixo } } } };
+  const r = await api(ctx, `${API}/commentThreads?part=snippet`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(corpo) });
+  const txt = await r.text();
+  if (!r.ok) throw new Error(mensagemErro(r.status, txt) + " (coment\xE1rio: o v\xEDdeo precisa estar publicado e o token com o escopo youtube.force-ssl; reconecte com `praeko conta youtube conectar`)");
+  const id = JSON.parse(txt).id;
+  return { id, comentario: true, url: `https://youtu.be/${item.videoId}?lc=${id}`, lembrete: "a API n\xE3o fixa coment\xE1rio: fixe pelo app" };
+}
+async function canalId(ctx) {
+  const r = await api(ctx, `${API}/channels?part=id&mine=true`);
+  if (!r.ok) throw falha(r.status, await r.text());
+  const c = (await r.json()).items?.[0];
+  if (!c) throw new Error("a conta autorizada n\xE3o tem canal do YouTube");
+  return c.id;
+}
+async function planejar({ item }) {
+  if (item.acao === "comentar") return [`coment\xE1rio no v\xEDdeo ${item.videoId}`];
+  const modo = modoDe(item), m = montarMetadados(item, Date.now());
+  return [
+    `t\xEDtulo: ${m.snippet.title}`,
+    `modo: ${modo} \u2192 privacidade ${m.status.privacyStatus}${m.status.publishAt ? ` (publica sozinho em ${m.status.publishAt})` : modo === "privado" ? " (voc\xEA troca a capa e publica no Studio)" : ""}`,
+    `arquivo: ${item.tamanhoTexto || "?"}; capa: ${item.capa ? String(item.capa).split("/").pop() + " (thumbnails.set)" : "nenhuma"}`
+  ];
+}
+async function agendarPublicacao({ item, ctx, agora = Date.now() }) {
+  const quando = new Date(item.quando);
+  if (Number.isNaN(quando.getTime())) throw new Error(`hor\xE1rio inv\xE1lido: ${item.quando}`);
+  if (quando.getTime() < agora + 5 * 6e4) throw new Error("o hor\xE1rio precisa ser daqui a pelo menos 5 minutos");
+  const r0 = await api(ctx, `${API}/videos?part=status&id=${encodeURIComponent(item.videoId)}`);
+  if (!r0.ok) throw falha(r0.status, await r0.text());
+  const v = (await r0.json()).items?.[0];
+  if (!v) throw new Error(`o v\xEDdeo ${item.videoId} n\xE3o existe neste canal`);
+  const st = v.status || {};
+  const status2 = { privacyStatus: "private", publishAt: quando.toISOString(), embeddable: st.embeddable ?? true, license: st.license || "youtube", publicStatsViewable: st.publicStatsViewable ?? true, selfDeclaredMadeForKids: st.selfDeclaredMadeForKids ?? false };
+  const r = await api(ctx, `${API}/videos?part=status`, { method: "PUT", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: item.videoId, status: status2 }) });
+  if (!r.ok) throw falha(r.status, await r.text());
+  return { id: item.videoId, publishAt: status2.publishAt, privacidade: "private", url: `https://youtu.be/${item.videoId}` };
+}
+
+export {
+  nome,
+  rede,
+  imediato,
+  REF_CLIENTE,
+  REF_TOKEN,
+  ESCOPOS_BASE,
+  ESCOPO_ANALYTICS,
+  ESCOPOS,
+  AUTH,
+  TOKEN,
+  REVOGAR,
+  API,
+  UP,
+  BLOCO,
+  LIMITE_MINIATURA,
+  b64url,
+  aleatorioPadrao,
+  desafioPkceAsync,
+  deps,
+  mensagemErro,
+  falha,
+  cliente,
+  urlAutorizacao,
+  trocarCodigo,
+  registroToken,
+  tokenValido,
+  revogar,
+  api,
+  status,
+  modoDe,
+  montarMetadados,
+  iniciarUpload,
+  sincronizarUpload,
+  enviarBloco,
+  enviarVideo,
+  esperarProcessamento,
+  definirMiniatura,
+  acoesSeguintes,
+  finalizarPublicacao,
+  publicar,
+  comentar,
+  canalId,
+  planejar,
+  agendarPublicacao
+};

package/dist/chunks/chunk-VJRMAQCR.mjs

@@ -0,0 +1,56 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  __export,
+  __glob
+} from "./chunk-LCFK6X55.mjs";
+
+// ../core/src/provedores/registro.mjs
+var registro_exports = {};
+__export(registro_exports, {
+  NOMES: () => NOMES,
+  carregar: () => carregar,
+  carregarTodos: () => carregarTodos
+});
+
+// import("./**/*.mjs") in ../core/src/provedores/registro.mjs
+var globImport_mjs = __glob({
+  "./instagram-meta.mjs": () => import("./instagram-meta-COY6BTNX.mjs"),
+  "./instagram.mjs": () => import("./instagram-GNY73ESY.mjs"),
+  "./registro.mjs": () => import("./registro-5PYVQ5LJ.mjs"),
+  "./tiktok-api.mjs": () => import("./tiktok-api-36DV2H43.mjs"),
+  "./tiktok.mjs": () => import("./tiktok-QOUHOWDU.mjs"),
+  "./youtube-analytics.mjs": () => import("./youtube-analytics-3KIW2ZIW.mjs"),
+  "./youtube-api.mjs": () => import("./youtube-api-Z2RP5D2V.mjs"),
+  "./youtube-comunidade.mjs": () => import("./youtube-comunidade-OAK5GGK4.mjs"),
+  "./youtube.mjs": () => import("./youtube-RZ4XTUZW.mjs")
+});
+
+// ../core/src/provedores/registro.mjs
+var NOMES = ["youtube", "instagram", "tiktok"];
+async function carregar(nome) {
+  if (!NOMES.includes(nome)) throw new Error(`provedor desconhecido: ${nome}`);
+  try {
+    return await globImport_mjs(`./${nome}.mjs`);
+  } catch (e) {
+    if (e.code === "ERR_MODULE_NOT_FOUND" && String(e.message).includes(`${nome}.mjs`)) throw new Error(`provedor "${nome}" ainda n\xE3o foi escrito`);
+    throw e;
+  }
+}
+async function carregarTodos() {
+  const o = {};
+  for (const n of NOMES) {
+    try {
+      o[n] = await carregar(n);
+    } catch (e) {
+      if (!/ainda não foi escrito/.test(e.message)) throw e;
+    }
+  }
+  return o;
+}
+
+export {
+  NOMES,
+  carregar,
+  carregarTodos,
+  registro_exports
+};