@praeko/cli 0.0.0-stage → 0.1.1

package/dist/chunks/tiktok-QOUHOWDU.mjs

@@ -0,0 +1,311 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import "./chunk-LCFK6X55.mjs";
+
+// ../core/src/provedores/tiktok.mjs
+import { closeSync, openSync, readSync, statSync } from "node:fs";
+import { createHash, randomBytes } from "node:crypto";
+import { spawnSync } from "node:child_process";
+var nome = "tiktok";
+var rede = "tiktok";
+var imediato = false;
+var API = "https://open.tiktokapis.com";
+var AUTORIZAR = "https://www.tiktok.com/v2/auth/authorize/";
+var ESCOPOS = ["user.info.basic", "video.upload", "video.publish"];
+var MB = 1024 * 1024;
+var LIMITES = { chunkMin: 5 * MB, chunkMax: 64 * MB, ultimoMax: 128 * MB, chunksMax: 1e3, videoMax: 4 * 1024 * MB, titulo: 2200 };
+var REF_CLIENTE = "tiktok/cliente";
+var REF_TOKEN = "tiktok/token";
+var ERROS = {
+  unaudited_client_can_only_post_to_private_accounts: 'o app do TikTok ainda n\xE3o foi auditado: ele s\xF3 pode postar em conta PRIVADA e como SELF_ONLY. Use o modo "rascunho" (padr\xE3o) ou torne a conta privada at\xE9 a auditoria (developers.tiktok.com/application/content-posting-api).',
+  spam_risk_too_many_pending_share: "o TikTok aceita no m\xE1ximo 5 envios pendentes na caixa de entrada por 24 h; publique ou descarte algum rascunho no app.",
+  spam_risk_too_many_posts: "limite di\xE1rio de posts do TikTok atingido para esta conta (cerca de 15 por dia).",
+  spam_risk_user_banned_from_posting: "esta conta est\xE1 impedida de postar pelo TikTok.",
+  reached_active_user_cap: "o app atingiu a cota di\xE1ria de usu\xE1rios ativos de publica\xE7\xE3o.",
+  url_ownership_unverified: "o TikTok exige dom\xEDnio verificado para PULL_FROM_URL (o Praeko usa FILE_UPLOAD; isto n\xE3o deveria ocorrer).",
+  privacy_level_option_mismatch: "a privacidade pedida n\xE3o est\xE1 entre as op\xE7\xF5es da conta (privacy_level_options).",
+  access_token_invalid: "token do TikTok inv\xE1lido ou expirado: rode `praeko conta tiktok conectar` de novo.",
+  scope_not_authorized: "falta autorizar o escopo necess\xE1rio (video.upload para rascunho, video.publish para direto): rode `praeko conta tiktok conectar` e aceite todos.",
+  rate_limit_exceeded: "limite de requisi\xE7\xF5es do TikTok; tente de novo em um minuto."
+};
+var mensagemErro = (cod, msg) => ERROS[cod] ? `${ERROS[cod]} [${cod}]` : `TikTok recusou: ${cod}${msg ? ` (${msg})` : ""}`;
+function planoChunks(tamanho, chunkPreferido = 10 * MB) {
+  if (!(tamanho > 0)) throw new Error("v\xEDdeo vazio");
+  if (tamanho > LIMITES.videoMax) throw new Error(`v\xEDdeo de ${(tamanho / MB).toFixed(0)} MB passa de 4 GB`);
+  let chunk = Math.min(LIMITES.chunkMax, Math.max(LIMITES.chunkMin, chunkPreferido));
+  if (tamanho < LIMITES.chunkMin || tamanho <= chunk) chunk = tamanho;
+  const total = Math.floor(tamanho / chunk);
+  if (total < 1 || total > LIMITES.chunksMax) throw new Error(`plano de partes inv\xE1lido (${total} partes)`);
+  const partes = [];
+  for (let i = 0; i < total; i++) {
+    const a = i * chunk, b = i === total - 1 ? tamanho - 1 : a + chunk - 1;
+    partes.push({ a, b, tamanho: b - a + 1 });
+  }
+  if (partes.at(-1).tamanho > LIMITES.ultimoMax) throw new Error("a \xFAltima parte passaria de 128 MB; aumente o tamanho da parte");
+  return { chunk, total, partes };
+}
+function truncar(texto, max = LIMITES.titulo) {
+  const s = String(texto ?? "");
+  if (s.length <= max) return s;
+  let corte = max - 1;
+  const c = s.charCodeAt(corte - 1);
+  if (c >= 55296 && c <= 56319) corte--;
+  return s.slice(0, corte) + "\u2026";
+}
+function privacidadeEfetiva({ pedida, auditado, opcoesCriador }) {
+  const quer = pedida || "SELF_ONLY";
+  const nivel = auditado ? quer : "SELF_ONLY";
+  const aviso = nivel !== quer ? `privacidade ${quer} \u2192 SELF_ONLY (app sem auditoria)` : null;
+  if (opcoesCriador && !opcoesCriador.includes(nivel)) throw new Error(`privacidade ${nivel} fora das op\xE7\xF5es da conta (${opcoesCriador.join(", ")})`);
+  return { nivel, aviso };
+}
+var codigoPkce = () => {
+  const verificador = randomBytes(48).toString("base64url");
+  return { verificador, desafio: createHash("sha256").update(verificador).digest("base64url") };
+};
+function urlAutorizacao({ key, redirect, escopos = ESCOPOS, estado, pkce }) {
+  const q = new URLSearchParams({ client_key: key, scope: escopos.join(","), response_type: "code", redirect_uri: redirect, state: estado });
+  if (pkce) {
+    q.set("code_challenge", pkce.desafio);
+    q.set("code_challenge_method", "S256");
+  }
+  return `${AUTORIZAR}?${q}`;
+}
+function extrairCodigo(texto) {
+  const t = String(texto).trim();
+  if (/^https?:\/\//.test(t) || t.includes("code=")) {
+    const q = new URL(t.startsWith("http") ? t : "http://x/?" + t.replace(/^\?/, "")).searchParams;
+    if (q.get("error")) throw new Error(`o TikTok devolveu erro: ${q.get("error")} ${q.get("error_description") || ""}`);
+    if (!q.get("code")) throw new Error("n\xE3o achei `code=` na URL de retorno");
+    return { code: q.get("code"), estado: q.get("state") };
+  }
+  return { code: decodeURIComponent(t), estado: null };
+}
+var dormirPadrao = (ms) => new Promise((r) => setTimeout(r, ms));
+async function json(ctx, url, opts) {
+  const r = await ctx.fetchFn(url, opts);
+  const txt = await r.text();
+  let j;
+  try {
+    j = JSON.parse(txt);
+  } catch {
+    throw new Error(`TikTok respondeu ${r.status}: ${txt.slice(0, 200)}`);
+  }
+  return { status: r.status, ok: r.ok, j };
+}
+function lancarSeErro(res) {
+  const e = res.j?.error;
+  if (e && e.code && e.code !== "ok") throw new Error(mensagemErro(e.code, e.message));
+  if (res.j?.error && typeof res.j.error === "string") throw new Error(`TikTok: ${res.j.error}${res.j.error_description ? ` (${res.j.error_description})` : ""}`);
+  if (!res.ok) throw new Error(`TikTok respondeu ${res.status}`);
+  return res.j;
+}
+var lerJson = (ctx, ref) => {
+  const v = ctx.segredos.obter(ref);
+  if (!v) return null;
+  try {
+    return JSON.parse(v);
+  } catch {
+    return null;
+  }
+};
+var agora = (ctx) => ctx.agora ? ctx.agora() : /* @__PURE__ */ new Date();
+function guardarToken(ctx, r, anterior = {}) {
+  const t = agora(ctx).getTime();
+  const tok = { access_token: r.access_token, refresh_token: r.refresh_token || anterior.refresh_token, open_id: r.open_id || anterior.open_id, scope: r.scope || anterior.scope, expira_em: t + (r.expires_in || 7200) * 1e3, refresh_expira_em: t + (r.refresh_expires_in || 180 * 86400) * 1e3 };
+  ctx.segredos.guardar(REF_TOKEN, JSON.stringify(tok));
+  return tok;
+}
+async function pedirToken(ctx, cliente, corpo) {
+  const res = await json(ctx, `${API}/v2/oauth/token/`, { method: "POST", headers: { "content-type": "application/x-www-form-urlencoded", "cache-control": "no-cache" }, body: new URLSearchParams({ client_key: cliente.key, client_secret: cliente.segredo, ...corpo }).toString() });
+  if (res.j.error && typeof res.j.error === "string") throw new Error(`TikTok: ${res.j.error}${res.j.error_description ? ` (${res.j.error_description})` : ""}`);
+  if (!res.j.access_token) throw new Error(`TikTok n\xE3o devolveu token (${res.status})`);
+  return res.j;
+}
+async function tokenValido(ctx) {
+  const cliente = lerJson(ctx, REF_CLIENTE), tok = lerJson(ctx, REF_TOKEN);
+  if (!cliente || !tok) throw new Error("TikTok n\xE3o conectado: rode `praeko conta tiktok conectar`");
+  if (tok.expira_em - 5 * 6e4 > agora(ctx).getTime()) return tok.access_token;
+  if (tok.refresh_expira_em <= agora(ctx).getTime()) throw new Error("a autoriza\xE7\xE3o do TikTok venceu (refresh token de 180 dias): rode `praeko conta tiktok conectar` de novo");
+  const novo = await pedirToken(ctx, cliente, { grant_type: "refresh_token", refresh_token: tok.refresh_token });
+  return guardarToken(ctx, novo, tok).access_token;
+}
+var auth = (token) => ({ authorization: `Bearer ${token}`, "content-type": "application/json; charset=UTF-8" });
+async function conectar({ ctx, args = [] }) {
+  const f = (k) => {
+    const i = args.indexOf("--" + k);
+    return i >= 0 ? args[i + 1] : void 0;
+  };
+  let cliente = lerJson(ctx, REF_CLIENTE);
+  if (f("cliente-key") || f("cliente-segredo") || f("redirect")) {
+    cliente = { ...cliente || {}, ...f("cliente-key") ? { key: f("cliente-key") } : {}, ...f("cliente-segredo") ? { segredo: f("cliente-segredo") } : {}, ...f("redirect") ? { redirect: f("redirect") } : {} };
+    ctx.segredos.guardar(REF_CLIENTE, JSON.stringify(cliente));
+  }
+  if (!cliente?.key || !cliente?.segredo || !cliente?.redirect) throw new Error("uso: praeko conta tiktok conectar --cliente-key K --cliente-segredo S --redirect https://sua-pagina/retorno   (veja docs/tiktok.md)");
+  const log = ctx.log || console.log;
+  const codigo = f("url") || f("code");
+  if (!codigo) {
+    const estado2 = randomBytes(8).toString("hex"), pkce = args.includes("--pkce") ? codigoPkce() : null;
+    ctx.segredos.guardar("tiktok/pendente", JSON.stringify({ estado: estado2, verificador: pkce?.verificador || null }));
+    log("1) Abra no navegador (logado na conta do canal) e autorize:\n");
+    log(urlAutorizacao({ key: cliente.key, redirect: cliente.redirect, estado: estado2, pkce }));
+    log(`
+2) O TikTok vai redirecionar para ${cliente.redirect}?code=\u2026  (a p\xE1gina pode dar 404, n\xE3o importa).
+   Copie a URL inteira da barra de endere\xE7o e rode:
+   praeko conta tiktok conectar --url "<URL copiada>"`);
+    return 0;
+  }
+  const { code, estado } = extrairCodigo(codigo);
+  const pend = lerJson(ctx, "tiktok/pendente");
+  if (estado && pend?.estado && estado !== pend.estado) throw new Error("o `state` da URL n\xE3o confere com o do pedido (poss\xEDvel link de outra tentativa); rode conectar de novo sem --url");
+  const r = await pedirToken(ctx, cliente, { grant_type: "authorization_code", code, redirect_uri: cliente.redirect, ...pend?.verificador ? { code_verifier: pend.verificador } : {} });
+  const tok = guardarToken(ctx, r);
+  log(`\u2713 TikTok conectado (open_id ${tok.open_id}); escopos: ${tok.scope}`);
+  if (!String(tok.scope).includes("video.upload")) log("\u26A0 sem o escopo video.upload: o modo rascunho n\xE3o vai funcionar");
+  if (!String(tok.scope).includes("video.publish")) log("\u26A0 sem video.publish (s\xF3 vem depois de o app ser aprovado para Direct Post): o modo direto n\xE3o vai funcionar");
+  return 0;
+}
+async function status({ ctx }) {
+  const tok = lerJson(ctx, REF_TOKEN);
+  if (!tok || !lerJson(ctx, REF_CLIENTE)) return { conectado: false, detalhe: "rode `praeko conta tiktok conectar`" };
+  try {
+    const t = await tokenValido(ctx);
+    const res = await json(ctx, `${API}/v2/user/info/?fields=open_id,display_name`, { method: "GET", headers: { authorization: `Bearer ${t}` } });
+    const j = lancarSeErro(res);
+    const dias = Math.floor((lerJson(ctx, REF_TOKEN).refresh_expira_em - agora(ctx).getTime()) / 864e5);
+    return { conectado: true, detalhe: `${j.data?.user?.display_name || tok.open_id}; escopos ${tok.scope}; autoriza\xE7\xE3o vale mais ${dias} dias` };
+  } catch (e) {
+    return { conectado: false, detalhe: e.message };
+  }
+}
+var modoDe = (item) => item.opcoes?.modo === "direto" ? "direto" : "rascunho";
+function duracaoDe(ctx, arquivo) {
+  if (ctx.duracao) return ctx.duracao(arquivo);
+  try {
+    const r = spawnSync("ffprobe", ["-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", arquivo], { encoding: "utf8" });
+    const d = parseFloat(r.stdout);
+    return Number.isFinite(d) ? d : null;
+  } catch {
+    return null;
+  }
+}
+async function planejar({ item }) {
+  const modo = modoDe(item), o = item.opcoes || {};
+  let tam;
+  try {
+    tam = statSync(item.video).size;
+  } catch {
+    tam = null;
+  }
+  const linhas = [`modo: ${modo}${modo === "rascunho" ? " (vai para a caixa de entrada do app; capa e legenda voc\xEA p\xF5e no app)" : ""}`];
+  if (modo === "direto") {
+    const p = privacidadeEfetiva({ pedida: o.privacidade, auditado: o.auditado });
+    linhas.push(`privacidade: ${p.nivel}${p.aviso ? ` (${p.aviso})` : ""}`);
+    linhas.push(`capa: quadro de ${o.capaMs ?? 0} ms`);
+  } else linhas.push("legenda n\xE3o vai pela API do rascunho: cole no app (fica em .praeko/ no resultado)");
+  if (tam) {
+    const pl = planoChunks(tam, (o.chunkMB || 10) * MB);
+    linhas.push(`v\xEDdeo ${(tam / MB).toFixed(1)} MB em ${pl.total} parte(s) de ${(pl.chunk / MB).toFixed(1)} MB`);
+  }
+  return linhas;
+}
+async function enviarPartes(ctx, uploadUrl, arquivo, plano, tamanho) {
+  const fd = openSync(arquivo, "r");
+  try {
+    for (const [i, p] of plano.partes.entries()) {
+      const buf = Buffer.alloc(p.tamanho);
+      readSync(fd, buf, 0, p.tamanho, p.a);
+      let ultimo;
+      for (let t = 1; t <= 3; t++) {
+        const r = await ctx.fetchFn(uploadUrl, { method: "PUT", headers: { "content-type": "video/mp4", "content-length": String(p.tamanho), "content-range": `bytes ${p.a}-${p.b}/${tamanho}` }, body: buf });
+        if (r.status >= 500) {
+          ultimo = r.status;
+          await (ctx.dormir || dormirPadrao)(1e3 * t);
+          continue;
+        }
+        const ultimaParte = i === plano.partes.length - 1;
+        if (ultimaParte && r.status === 201 || !ultimaParte && r.status === 206 || r.status === 200) {
+          ultimo = null;
+          break;
+        }
+        if (r.status === 403) throw new Error("o upload_url expirou (vale 1 h); o item ser\xE1 refeito na pr\xF3xima tentativa");
+        throw new Error(`upload da parte ${i + 1}/${plano.total} recusado (${r.status})`);
+      }
+      if (ultimo) throw new Error(`upload da parte ${i + 1}/${plano.total} falhou (${ultimo}) depois de 3 tentativas`);
+    }
+  } finally {
+    closeSync(fd);
+  }
+}
+async function aguardar(ctx, token, publicId, alvo) {
+  const pollMs = ctx.tiktok?.pollMs ?? 5e3, max = ctx.tiktok?.maxPolls ?? 72, dormir = ctx.dormir || dormirPadrao;
+  let ultimo;
+  for (let i = 0; i < max; i++) {
+    const j = lancarSeErro(await json(ctx, `${API}/v2/post/publish/status/fetch/`, { method: "POST", headers: auth(token), body: JSON.stringify({ publish_id: publicId }) }));
+    ultimo = j.data || {};
+    if (ultimo.status === "FAILED") throw new Error(`o TikTok falhou ao processar: ${ultimo.fail_reason || "motivo n\xE3o informado"}`);
+    if (alvo.includes(ultimo.status)) return ultimo;
+    await dormir(pollMs);
+  }
+  throw new Error(`o TikTok ainda n\xE3o terminou (\xFAltimo status ${ultimo?.status}); confira o app e a fila`);
+}
+async function publicar({ item, ctx }) {
+  const o = item.opcoes || {}, modo = modoDe(item), log = ctx.log || console.log;
+  const tamanho = statSync(item.video).size, plano = planoChunks(tamanho, (o.chunkMB || 10) * MB);
+  const token = await tokenValido(ctx);
+  if (item.prep?.publish_id) {
+    try {
+      const j = lancarSeErro(await json(ctx, `${API}/v2/post/publish/status/fetch/`, { method: "POST", headers: auth(token), body: JSON.stringify({ publish_id: item.prep.publish_id }) }));
+      if (["SEND_TO_USER_INBOX", "PUBLISH_COMPLETE"].includes(j.data?.status)) return { id: item.prep.publish_id, modo, status: j.data.status, retomado: true };
+    } catch {
+    }
+  }
+  let corpo, caminho, creator = null;
+  if (modo === "direto") {
+    const ci = lancarSeErro(await json(ctx, `${API}/v2/post/publish/creator_info/query/`, { method: "POST", headers: auth(token), body: "{}" })).data || {};
+    creator = ci;
+    const dur = duracaoDe(ctx, item.video);
+    if (dur != null && ci.max_video_post_duration_sec && dur > ci.max_video_post_duration_sec) throw new Error(`o v\xEDdeo tem ${dur.toFixed(0)} s e esta conta s\xF3 posta at\xE9 ${ci.max_video_post_duration_sec} s no TikTok`);
+    const pv = privacidadeEfetiva({ pedida: o.privacidade, auditado: o.auditado, opcoesCriador: ci.privacy_level_options });
+    if (pv.aviso) log(`\u26A0 TikTok: ${pv.aviso}`);
+    caminho = "/v2/post/publish/video/init/";
+    corpo = { post_info: { title: truncar(item.textos?.texto), privacy_level: pv.nivel, disable_duet: !!(o.desabilitarDueto || ci.duet_disabled), disable_stitch: !!(o.desabilitarStitch || ci.stitch_disabled), disable_comment: !!(o.desabilitarComentarios || ci.comment_disabled), video_cover_timestamp_ms: o.capaMs ?? 0, brand_content_toggle: false, brand_organic_toggle: false, is_aigc: o.ia === true }, source_info: { source: "FILE_UPLOAD", video_size: tamanho, chunk_size: plano.chunk, total_chunk_count: plano.total } };
+  } else {
+    caminho = "/v2/post/publish/inbox/video/init/";
+    corpo = { source_info: { source: "FILE_UPLOAD", video_size: tamanho, chunk_size: plano.chunk, total_chunk_count: plano.total } };
+  }
+  const init = lancarSeErro(await json(ctx, API + caminho, { method: "POST", headers: auth(token), body: JSON.stringify(corpo) })).data || {};
+  if (!init.publish_id || !init.upload_url) throw new Error("o TikTok n\xE3o devolveu publish_id/upload_url");
+  item.prep = { publish_id: init.publish_id, modo };
+  await enviarPartes(ctx, init.upload_url, item.video, plano, tamanho);
+  const fim = await aguardar(ctx, token, init.publish_id, modo === "direto" ? ["PUBLISH_COMPLETE"] : ["SEND_TO_USER_INBOX", "PUBLISH_COMPLETE"]);
+  const postId = fim.publicaly_available_post_id?.[0];
+  const res = { id: init.publish_id, modo, status: fim.status, ...postId && creator?.creator_username ? { url: `https://www.tiktok.com/@${creator.creator_username}/video/${postId}` } : {} };
+  if (modo === "rascunho") res.legenda = item.textos?.texto;
+  if (modo === "rascunho") log(`\u2713 TikTok: v\xEDdeo na caixa de entrada do app. Abra o app, escolha a capa, cole a legenda e publique.
+--- legenda ---
+${item.textos?.texto || ""}
+---------------`);
+  return res;
+}
+export {
+  API,
+  AUTORIZAR,
+  ESCOPOS,
+  LIMITES,
+  codigoPkce,
+  conectar,
+  extrairCodigo,
+  imediato,
+  mensagemErro,
+  modoDe,
+  nome,
+  planejar,
+  planoChunks,
+  privacidadeEfetiva,
+  publicar,
+  rede,
+  status,
+  tokenValido,
+  truncar,
+  urlAutorizacao
+};

package/dist/chunks/tiktok-api-36DV2H43.mjs

@@ -0,0 +1,309 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import "./chunk-LCFK6X55.mjs";
+
+// ../core/src/provedores/tiktok-api.mjs
+var nome = "tiktok";
+var rede = "tiktok";
+var imediato = true;
+var REF_CLIENTE = "tiktok/cliente";
+var REF_TOKEN = "tiktok/token";
+var ESCOPOS = ["user.info.basic", "user.info.stats", "video.list", "video.upload", "video.publish"];
+var HOST = "https://open.tiktokapis.com";
+var AUTH = "https://www.tiktok.com/v2/auth/authorize/";
+var MB = 1024 * 1024;
+var LIMITES = { chunkMin: 5 * MB, chunkMax: 64 * MB, ultimoMax: 128 * MB, chunksMax: 1e3, videoMax: 4 * 1024 * MB, titulo: 2200 };
+var PRIVACIDADES = ["PUBLIC_TO_EVERYONE", "MUTUAL_FOLLOW_FRIENDS", "FOLLOWER_OF_CREATOR", "SELF_ONLY"];
+var MODOS = ["rascunho", "direto"];
+var MARGEM_RENOVAR_MS = 5 * 6e4;
+var CAMPOS_PERFIL = ["open_id", "avatar_url", "display_name", "follower_count", "following_count", "likes_count", "video_count"];
+var CAMPOS_VIDEO = "id,title,video_description,create_time,cover_image_url,share_url,duration,view_count,like_count,comment_count,share_count";
+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(/=+$/, "");
+};
+async function desafioPkceHex(verificador) {
+  const h = new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verificador)));
+  return [...h].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var novoVerificador = (aleatorio = (n) => crypto.getRandomValues(new Uint8Array(n))) => b64url(aleatorio(48));
+function truncar(texto, max = LIMITES.titulo) {
+  const s = String(texto ?? "");
+  if (s.length <= max) return s;
+  let corte = max - 1;
+  const c = s.charCodeAt(corte - 1);
+  if (c >= 55296 && c <= 56319) corte--;
+  return s.slice(0, corte) + "\u2026";
+}
+function planoChunks(tamanho, chunkPreferido = 10 * MB) {
+  if (!(tamanho > 0)) throw new Error("v\xEDdeo vazio");
+  if (tamanho > LIMITES.videoMax) throw new Error(`v\xEDdeo de ${(tamanho / MB).toFixed(0)} MB passa de 4 GB`);
+  let chunk = Math.min(LIMITES.chunkMax, Math.max(LIMITES.chunkMin, chunkPreferido));
+  if (tamanho < LIMITES.chunkMin || tamanho <= chunk) chunk = tamanho;
+  const total = Math.floor(tamanho / chunk);
+  if (total === 1) chunk = tamanho;
+  if (total < 1 || total > LIMITES.chunksMax) throw new Error(`plano de partes inv\xE1lido (${total} partes)`);
+  const partes = [];
+  for (let i = 0; i < total; i++) {
+    const a = i * chunk, b = i === total - 1 ? tamanho - 1 : a + chunk - 1;
+    partes.push({ a, b, tamanho: b - a + 1 });
+  }
+  if (partes.at(-1).tamanho > LIMITES.ultimoMax) throw new Error("a \xFAltima parte passaria de 128 MB; aumente o tamanho da parte");
+  return { chunk, total, partes };
+}
+var ERROS = {
+  unaudited_client_can_only_post_to_private_accounts: 'o app do TikTok ainda n\xE3o foi auditado: ele s\xF3 posta em conta PRIVADA e como SELF_ONLY. Use o modo "rascunho" ou torne a conta privada at\xE9 a auditoria (developers.tiktok.com/application/content-posting-api).',
+  spam_risk_too_many_pending_share: "o TikTok aceita no m\xE1ximo 5 envios pendentes na caixa de entrada por 24 h; publique ou descarte algum rascunho no app.",
+  spam_risk_too_many_posts: "limite di\xE1rio de posts do TikTok atingido para esta conta (cerca de 15 por dia).",
+  spam_risk_user_banned_from_posting: "esta conta est\xE1 impedida de postar pelo TikTok.",
+  spam_risk_text: "o TikTok recusou o texto da legenda como spam.",
+  spam_risk: "o TikTok bloqueou o envio por risco de spam.",
+  reached_active_user_cap: "o app atingiu a cota di\xE1ria de usu\xE1rios ativos de publica\xE7\xE3o do TikTok.",
+  url_ownership_unverified: "o dom\xEDnio do v\xEDdeo n\xE3o est\xE1 verificado no TikTok (PULL_FROM_URL).",
+  privacy_level_option_mismatch: "a privacidade pedida n\xE3o est\xE1 entre as op\xE7\xF5es da conta (privacy_level_options).",
+  access_token_invalid: "token do TikTok inv\xE1lido ou expirado: reconecte o canal (praeko conta tiktok conectar).",
+  scope_not_authorized: "falta autorizar um escopo no TikTok (video.upload, video.publish, video.list\u2026): reconecte o canal e aceite todos.",
+  scope_permission_missed: "falta autorizar um escopo no TikTok: reconecte o canal e aceite todos.",
+  rate_limit_exceeded: "limite de requisi\xE7\xF5es do TikTok; tente de novo em um minuto.",
+  file_format_check_failed: "o TikTok n\xE3o aceitou o formato do arquivo (use MP4/MOV com H.264 e AAC).",
+  duration_check_failed: "a dura\xE7\xE3o do v\xEDdeo passa do que esta conta pode postar no TikTok.",
+  frame_rate_check_failed: "a taxa de quadros do v\xEDdeo n\xE3o \xE9 aceita pelo TikTok (use de 23 a 60 fps).",
+  picture_size_check_failed: "a resolu\xE7\xE3o do v\xEDdeo n\xE3o \xE9 aceita pelo TikTok.",
+  video_pull_failed: "o TikTok n\xE3o conseguiu baixar o v\xEDdeo pela URL p\xFAblica.",
+  publish_cancelled: "a publica\xE7\xE3o foi cancelada no TikTok.",
+  auth_removed: "o acesso do Praeko \xE0 conta foi removido no TikTok: reconecte o canal.",
+  invalid_publish_id: "o TikTok n\xE3o reconhece este envio (publish_id inv\xE1lido ou vencido).",
+  invalid_file_upload: "o TikTok recusou o envio do arquivo em partes."
+};
+var mensagemErro = (cod, msg) => ERROS[cod] ? `${ERROS[cod]} [${cod}]` : `TikTok recusou: ${cod || "erro"}${msg ? ` (${String(msg).slice(0, 160)})` : ""}`;
+var CODIGOS_TRANSITORIOS = ["internal_error", "rate_limit_exceeded", "service_unavailable", "timeout"];
+function falha(status2, codigo, msg) {
+  const e = new Error(mensagemErro(codigo, msg));
+  return Object.assign(e, { status: status2 || 502, codigo: codigo || null, transitorio: !status2 || status2 >= 500 || status2 === 429 || CODIGOS_TRANSITORIOS.includes(codigo) });
+}
+var transitorio = (e) => !e?.status || !!e.transitorio;
+async function cliente(ctx) {
+  const salvo = await ctx.segredos.obter(REF_CLIENTE);
+  if (salvo) {
+    const j = typeof salvo === "string" ? JSON.parse(salvo) : salvo;
+    if (j.client_key && j.client_secret) return j;
+  }
+  throw Object.assign(new Error("sem credencial do TikTok: defina os secrets TIKTOK_CLIENT_KEY e TIKTOK_CLIENT_SECRET do Worker (docs/tiktok.md)"), { status: 409, codigo: "sem_credencial" });
+}
+function urlAutorizacao({ clientKey, redirect, desafio, estado }) {
+  const q = new URLSearchParams({ client_key: clientKey, scope: ESCOPOS.join(","), response_type: "code", redirect_uri: redirect, state: estado, code_challenge: desafio, code_challenge_method: "S256" });
+  return `${AUTH}?${q}`;
+}
+async function pedirToken(ctx, corpo) {
+  const r = await ctx.fetchFn(`${HOST}/v2/oauth/token/`, { method: "POST", headers: { "content-type": "application/x-www-form-urlencoded", "cache-control": "no-cache" }, body: new URLSearchParams(corpo).toString() });
+  const txt = await r.text();
+  let j = {};
+  try {
+    j = txt ? JSON.parse(txt) : {};
+  } catch {
+  }
+  if (!r.ok || j.error || !j.access_token) {
+    const e = falha(r.status, j.error, j.error_description);
+    e.message = `${j.error === "invalid_grant" ? "o TikTok recusou o c\xF3digo/refresh token (vencido ou j\xE1 usado)" : "TikTok recusou o token"}: ${j.error_description || j.error || `HTTP ${r.status}`}`;
+    throw e;
+  }
+  return j;
+}
+async function trocarCodigo(ctx, cl, { codigo, verificador, redirect }) {
+  return pedirToken(ctx, { client_key: cl.client_key, client_secret: cl.client_secret, code: codigo, grant_type: "authorization_code", redirect_uri: redirect, code_verifier: verificador });
+}
+function registroToken(j, agora) {
+  return JSON.stringify({ access_token: j.access_token, refresh_token: j.refresh_token, expiry: agora + (j.expires_in || 86400) * 1e3, refreshExpiry: agora + (j.refresh_expires_in || 365 * 86400) * 1e3, openId: j.open_id || null, escopos: String(j.scope || ESCOPOS.join(",")).split(",") });
+}
+async function tokenValido(ctx) {
+  const agora = (ctx.deps?.agora || Date.now)(), bruto = await ctx.segredos.obter(REF_TOKEN);
+  if (!bruto) throw Object.assign(new Error("TikTok n\xE3o conectado: praeko conta tiktok conectar"), { status: 409, codigo: "tiktok_nao_conectado" });
+  const t = typeof bruto === "string" ? JSON.parse(bruto) : bruto;
+  if (t.access_token && t.expiry - MARGEM_RENOVAR_MS > agora) return t.access_token;
+  if (!t.refresh_token || t.refreshExpiry && t.refreshExpiry < agora) throw Object.assign(new Error("o refresh token do TikTok venceu (vale ~365 dias): reconecte o canal"), { status: 409, codigo: "tiktok_nao_conectado" });
+  const cl = await cliente(ctx);
+  const j = await pedirToken(ctx, { client_key: cl.client_key, client_secret: cl.client_secret, grant_type: "refresh_token", refresh_token: t.refresh_token });
+  const novo = JSON.parse(registroToken({ ...j, refresh_token: j.refresh_token || t.refresh_token, open_id: j.open_id || t.openId }, agora));
+  await ctx.segredos.guardar(REF_TOKEN, JSON.stringify({ ...t, ...novo }));
+  return novo.access_token;
+}
+async function revogar(ctx) {
+  try {
+    const bruto = await ctx.segredos.obter(REF_TOKEN), cl = await cliente(ctx);
+    if (!bruto) return false;
+    const t = JSON.parse(bruto), r = await ctx.fetchFn(`${HOST}/v2/oauth/revoke/`, { method: "POST", headers: { "content-type": "application/x-www-form-urlencoded" }, body: new URLSearchParams({ client_key: cl.client_key, client_secret: cl.client_secret, token: t.access_token }).toString() });
+    return r.ok;
+  } catch {
+    return false;
+  }
+}
+async function chamar(ctx, caminho, { metodo = "GET", query, corpo } = {}) {
+  const token = await tokenValido(ctx), q = query ? `?${new URLSearchParams(query)}` : "";
+  let r;
+  try {
+    r = await ctx.fetchFn(`${HOST}${caminho}${q}`, { method: metodo, headers: { authorization: `Bearer ${token}`, ...corpo !== void 0 ? { "content-type": "application/json; charset=UTF-8" } : {} }, ...corpo !== void 0 ? { body: JSON.stringify(corpo) } : {} });
+  } catch (e) {
+    throw Object.assign(new Error(`falha de rede com o TikTok: ${e.message}`), { transitorio: true });
+  }
+  const txt = await r.text();
+  let j = {};
+  try {
+    j = txt ? JSON.parse(txt) : {};
+  } catch {
+  }
+  const cod = j.error?.code;
+  if (!r.ok || cod && cod !== "ok") throw falha(r.status, cod && cod !== "ok" ? cod : null, j.error?.message || txt.slice(0, 160));
+  return j.data ?? {};
+}
+var num = (x) => x != null && x !== "" && !Number.isNaN(+x) ? +x : null;
+async function perfil({ ctx }) {
+  const j = await chamar(ctx, "/v2/user/info/", { query: { fields: CAMPOS_PERFIL.join(",") } });
+  const u = j.user || {};
+  return { id: u.open_id || null, nome: u.display_name || null, usuario: u.username || null, avatar: u.avatar_url || null, seguidores: num(u.follower_count), seguindo: num(u.following_count), curtidas: num(u.likes_count), videos: num(u.video_count) };
+}
+async function status({ ctx }) {
+  if (!await ctx.segredos.obter(REF_TOKEN)) return { conectado: false, detalhe: "rode: praeko conta tiktok conectar" };
+  try {
+    const p = await perfil({ ctx });
+    return { conectado: true, detalhe: p.nome || p.usuario || "TikTok", ...p.id ? { canalId: p.id } : {} };
+  } catch (e) {
+    return { conectado: false, detalhe: String(e.message).slice(0, 200) };
+  }
+}
+var primeiraLinha = (t, max = 120) => {
+  const l = String(t || "").split("\n").map((x) => x.trim()).find(Boolean) || "";
+  return l.length > max ? `${l.slice(0, max - 1)}\u2026` : l;
+};
+var videoDe = (v) => ({
+  id: String(v.id),
+  rede: "tiktok",
+  titulo: primeiraLinha(v.title || v.video_description),
+  legenda: v.video_description || v.title || "",
+  publicadoEm: v.create_time ? new Date(Number(v.create_time) * 1e3).toISOString() : null,
+  thumbnail: v.cover_image_url || null,
+  permalink: v.share_url || null,
+  duracao: num(v.duration),
+  views: num(v.view_count),
+  curtidas: num(v.like_count),
+  comentarios: num(v.comment_count),
+  compartilhamentos: num(v.share_count)
+});
+async function listarVideos({ ctx, max = 20, cursor }) {
+  const j = await chamar(ctx, "/v2/video/list/", { metodo: "POST", query: { fields: CAMPOS_VIDEO }, corpo: { max_count: Math.max(1, Math.min(20, Math.floor(+max) || 20)), ...cursor != null ? { cursor: Number(cursor) } : {} } });
+  return { videos: (j.videos || []).map(videoDe), proxima: j.has_more && j.cursor != null ? String(j.cursor) : null };
+}
+async function consultarVideos({ ctx, ids }) {
+  const mapa = /* @__PURE__ */ new Map();
+  for (let i = 0; i < ids.length; i += 20) {
+    const j = await chamar(ctx, "/v2/video/query/", { metodo: "POST", query: { fields: CAMPOS_VIDEO }, corpo: { filters: { video_ids: ids.slice(i, i + 20) } } });
+    for (const v of j.videos || []) mapa.set(String(v.id), videoDe(v));
+  }
+  return mapa;
+}
+async function infoCriador({ ctx }) {
+  const j = await chamar(ctx, "/v2/post/publish/creator_info/query/", { metodo: "POST", corpo: {} });
+  return { privacidades: j.privacy_level_options || [], duracaoMaxSeg: num(j.max_video_post_duration_sec), comentarioDesabilitado: !!j.comment_disabled, duetoDesabilitado: !!j.duet_disabled, stitchDesabilitado: !!j.stitch_disabled, usuario: j.creator_username || null, nome: j.creator_nickname || null };
+}
+function modoDe(item) {
+  const m = item.opcoes?.modo || "rascunho";
+  if (!MODOS.includes(m)) throw new Error(`modo do TikTok inv\xE1lido: ${m} (use rascunho ou direto)`);
+  return m;
+}
+function privacidadeDe(item) {
+  const p = item.opcoes?.privacidade || "SELF_ONLY";
+  if (!PRIVACIDADES.includes(p)) throw new Error(`privacidade do TikTok inv\xE1lida: ${p} (use ${PRIVACIDADES.join(", ")})`);
+  return p;
+}
+function montarPostInfo(item, info) {
+  const o = item.opcoes || {}, privacy_level = privacidadeDe(item);
+  if (info && !info.privacidades.includes(privacy_level)) throw Object.assign(new Error(`a privacidade ${privacy_level} n\xE3o est\xE1 entre as op\xE7\xF5es desta conta (${info.privacidades.join(", ") || "nenhuma"}): ${mensagemErro("privacy_level_option_mismatch")}`), { status: 422, codigo: "privacy_level_option_mismatch" });
+  const titulo = truncar(item.textos?.texto || item.titulo || "");
+  return {
+    title: titulo,
+    privacy_level,
+    disable_duet: !!(o.desabilitarDueto || info?.duetoDesabilitado),
+    disable_comment: !!(o.desabilitarComentarios || info?.comentarioDesabilitado),
+    disable_stitch: !!(o.desabilitarStitch || info?.stitchDesabilitado),
+    ...Number.isFinite(+o.miniaturaMs) && o.miniaturaMs != null ? { video_cover_timestamp_ms: Math.max(0, Math.floor(+o.miniaturaMs)) } : {},
+    ...o.conteudoIA != null ? { is_aigc: !!o.conteudoIA } : {},
+    ...postInfoComercial(o, privacy_level)
+  };
+}
+function postInfoComercial(o = {}, privacidade) {
+  const ligado = o.conteudoComercial === true;
+  if (ligado && !o.marcaPropria && !o.marcaTerceiros) throw Object.assign(new Error("conte\xFAdo comercial: escolha \u201CSua marca\u201D ou \u201CMarca de terceiros\u201D (ou desligue a divulga\xE7\xE3o)"), { status: 422, codigo: "marca_nao_escolhida" });
+  if (ligado && o.marcaTerceiros && privacidade === "SELF_ONLY") throw Object.assign(new Error("o TikTok n\xE3o aceita conte\xFAdo de marca de terceiros como privado (S\xF3 eu): escolha outra visibilidade"), { status: 422, codigo: "marca_nao_pode_ser_privada" });
+  return { brand_content_toggle: ligado && !!o.marcaTerceiros, brand_organic_toggle: ligado && !!o.marcaPropria };
+}
+async function iniciarPublicacao({ ctx, modo, postInfo, fonte }) {
+  const source_info = fonte.url ? { source: "PULL_FROM_URL", video_url: fonte.url } : { source: "FILE_UPLOAD", video_size: fonte.tamanho, chunk_size: fonte.chunk, total_chunk_count: fonte.total };
+  const corpo = modo === "direto" ? { post_info: postInfo, source_info } : { source_info };
+  const j = await chamar(ctx, modo === "direto" ? "/v2/post/publish/video/init/" : "/v2/post/publish/inbox/video/init/", { metodo: "POST", corpo });
+  if (!j.publish_id) throw new Error("o TikTok n\xE3o devolveu o publish_id");
+  return { publishId: String(j.publish_id), uploadUrl: j.upload_url || null };
+}
+async function enviarParte({ ctx, uploadUrl, bytes, parte, total, mime = "video/mp4" }) {
+  let r;
+  try {
+    r = await ctx.fetchFn(uploadUrl, { method: "PUT", headers: { "content-type": mime, "content-length": String(bytes.length), "content-range": `bytes ${parte.a}-${parte.b}/${total}` }, body: bytes });
+  } catch (e) {
+    throw Object.assign(new Error(`falha de rede ao enviar a parte ao TikTok: ${e.message}`), { transitorio: true });
+  }
+  if (r.status < 200 || r.status > 299) {
+    const txt = await r.text().catch(() => "");
+    throw falha(r.status, r.status >= 500 ? null : "invalid_file_upload", txt.slice(0, 160));
+  }
+  return { status: r.status };
+}
+async function statusPublicacao({ ctx, publishId }) {
+  const j = await chamar(ctx, "/v2/post/publish/status/fetch/", { metodo: "POST", corpo: { publish_id: publishId } });
+  const ids = j.publicaly_available_post_id || j.publicly_available_post_id || [];
+  return { codigo: String(j.status || "").toUpperCase(), motivo: j.fail_reason || null, videoIds: ids.map(String), enviadoBytes: num(j.uploaded_bytes) };
+}
+async function publicar() {
+  throw new Error("o TikTok publica em passos pelo Workflow do servidor (tiktok-publicar.js)");
+}
+export {
+  AUTH,
+  ESCOPOS,
+  HOST,
+  LIMITES,
+  MB,
+  MODOS,
+  PRIVACIDADES,
+  REF_CLIENTE,
+  REF_TOKEN,
+  b64url,
+  chamar,
+  cliente,
+  consultarVideos,
+  desafioPkceHex,
+  enviarParte,
+  falha,
+  imediato,
+  infoCriador,
+  iniciarPublicacao,
+  listarVideos,
+  mensagemErro,
+  modoDe,
+  montarPostInfo,
+  nome,
+  novoVerificador,
+  perfil,
+  planoChunks,
+  postInfoComercial,
+  privacidadeDe,
+  publicar,
+  rede,
+  registroToken,
+  revogar,
+  status,
+  statusPublicacao,
+  tokenValido,
+  transitorio,
+  trocarCodigo,
+  truncar,
+  urlAutorizacao,
+  videoDe
+};