Hapi
Blog

· 7 min de leitura

Como criar um clone do Buffer em um fim de semana (com a Hapi como backend)

Monte seu próprio agendador em fila no estilo Buffer: horários de postagem, uma fila que se preenche sozinha e publicação no X, no LinkedIn e no Bluesky. Cerca de 120 linhas de Node, com a Hapi como infraestrutura social.

A grande ideia do Buffer é a fila: você define os horários uma vez (“dias de semana às 9:00, 12:30 e 17:00”) e depois é só escrever. Cada post novo cai no próximo horário livre.

Essa ideia cabe em umas 50 linhas. A parte difícil de um agendador é tudo o que está embaixo: OAuth de cada rede, renovação de tokens, regras de mídia, publicar na hora, novas tentativas. É isso que a Hapi faz. Você constrói o produto; a hapi.tools é a infraestrutura.

No fim você vai ter:

  • Um compositor que posta no X, no LinkedIn e no Bluesky (e também no Discord, no Slack e no Telegram) de uma vez
  • Add to queue, que coloca cada post no próximo horário livre, no seu fuso, horário de verão incluído
  • Uma visão da fila com botões para cancelar
  • Proteção por senha, para compartilhar com a equipe ou com clientes

É um arquivo só, Node 22 ou mais recente, sem dependências.

1. Configure a Hapi

  1. Comece um teste da Hapi (15 dias por US$ 5).
  2. Conecte suas contas em Accounts: X e LinkedIn em um clique (OAuth), Bluesky com uma senha de app.
  3. Crie uma chave de API em API keys e deixe ela à mão.

2. A lógica da fila

A grade de horários é só dado:

js
const SLOTS = { days: [1, 2, 3, 4, 5], times: ["09:00", "12:30", "17:00"] }; // Mon–Fri

Para encaixar um post você precisa de duas coisas: os próximos horários no seu fuso e quais deles já estão ocupados. Os ocupados vêm direto da Hapi, porque todo post agendado tem um scheduledAt. Por isso o clone não precisa do próprio banco.

O detalhe sutil é transformar “09:00 em Nova York” em um instante exato, porque o offset muda com o horário de verão. O Intl.DateTimeFormat faz isso sem biblioteca:

js
function zonedTime(y, m, d, hh, mm) {
  const guess = Date.UTC(y, m - 1, d, hh, mm);
  const p = Object.fromEntries(
    new Intl.DateTimeFormat("en-US", { timeZone: TZ, hourCycle: "h23", year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit" })
      .formatToParts(new Date(guess))
      .map((x) => [x.type, x.value]),
  );
  const shownAs = Date.UTC(+p.year, p.month - 1, +p.day, +p.hour, +p.minute);
  return new Date(guess - (shownAs - guess)); // shift by the zone's offset on that date
}

3. O app inteiro

js
// buffer-clone.mjs: a Buffer-style queue scheduler built on Hapi.
// Run: HAPI_API_KEY=hapi_live_... APP_PASSWORD=pick-one node buffer-clone.mjs
import http from "node:http";

const API = process.env.HAPI_API_BASE ?? "https://hapi.tools/v1";
const { HAPI_API_KEY, APP_PASSWORD, PORT = 3000 } = process.env;
const TZ = process.env.QUEUE_TZ ?? "America/New_York";
const SLOTS = { days: [1, 2, 3, 4, 5], times: ["09:00", "12:30", "17:00"] }; // 1 = Monday … 7 = Sunday

async function hapi(path, options = {}) {
  const res = await fetch(API + path, {
    ...options,
    headers: { Authorization: `Bearer ${HAPI_API_KEY}`, "Content-Type": "application/json" },
  });
  if (res.status === 204) return null;
  const body = await res.json();
  if (!res.ok) throw new Error(body.error?.message ?? `Hapi returned ${res.status}`);
  return body;
}

// "09:00 on 2026-11-20 in TZ" → the exact moment, daylight saving included.
function zonedTime(y, m, d, hh, mm) {
  const guess = Date.UTC(y, m - 1, d, hh, mm);
  const p = Object.fromEntries(
    new Intl.DateTimeFormat("en-US", { timeZone: TZ, hourCycle: "h23", year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit" })
      .formatToParts(new Date(guess))
      .map((x) => [x.type, x.value]),
  );
  const shownAs = Date.UTC(+p.year, p.month - 1, +p.day, +p.hour, +p.minute);
  return new Date(guess - (shownAs - guess));
}

function* upcomingSlots(after) {
  const [y, m, d] = new Intl.DateTimeFormat("en-CA", { timeZone: TZ }).format(after).split("-").map(Number);
  for (let i = 0; i < 60; i++) {
    const day = new Date(Date.UTC(y, m - 1, d + i));
    if (!SLOTS.days.includes(day.getUTCDay() || 7)) continue;
    for (const time of SLOTS.times) {
      const [hh, mm] = time.split(":").map(Number);
      const at = zonedTime(day.getUTCFullYear(), day.getUTCMonth() + 1, day.getUTCDate(), hh, mm);
      if (at > after) yield at;
    }
  }
}

async function nextFreeSlot() {
  const { data } = await hapi("/posts?status=scheduled&limit=100");
  const taken = new Set(data.map((p) => new Date(p.scheduledAt).getTime()));
  for (const at of upcomingSlots(new Date(Date.now() + 60_000))) {
    if (!taken.has(at.getTime())) return at;
  }
  throw new Error("The queue is full for the next 60 days");
}

const esc = (s = "") => String(s).replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]);
const when = (iso) => new Date(iso).toLocaleString("en-US", { timeZone: TZ, weekday: "short", month: "short", day: "numeric", hour: "numeric", minute: "2-digit" });

async function page(message = "") {
  const [{ data: accounts }, { data: queued }] = await Promise.all([hapi("/accounts"), hapi("/posts?status=scheduled&limit=100")]);
  queued.sort((a, b) => new Date(a.scheduledAt) - new Date(b.scheduledAt));
  return `<!doctype html><meta charset="utf-8"><title>Queue</title>
  <style>body{font:16px system-ui;max-width:640px;margin:40px auto;padding:0 16px}textarea{width:100%;height:110px}li{margin:10px 0}small{color:#666}</style>
  <h1>Queue</h1>${message ? `<p><b>${esc(message)}</b></p>` : ""}
  <form method="post" action="/post">
    <textarea name="content" required placeholder="What do you want to share?"></textarea>
    <p>${accounts.map((a) => `<label><input type="checkbox" name="accountId" value="${esc(a.id)}" checked> ${esc(a.platform)} · ${esc(a.username ?? a.displayName)}</label>`).join("<br>")}</p>
    <button name="action" value="queue">Add to queue</button> <button name="action" value="now">Post now</button>
  </form>
  <h2>Up next <small>(${esc(TZ)})</small></h2>
  <ul>${queued.map((p) => `<li><small>${esc(when(p.scheduledAt))}</small><br>${esc(p.content)}
    <form method="post" action="/cancel/${esc(p.id)}" style="display:inline"><button>Remove</button></form></li>`).join("") || "<li>Your queue is empty.</li>"}</ul>`;
}

function readBody(req) {
  return new Promise((resolve) => {
    let data = "";
    req.on("data", (chunk) => (data += chunk));
    req.on("end", () => resolve(data));
  });
}

http
  .createServer(async (req, res) => {
    // One shared password keeps the app, and your API key, private.
    const encoded = (req.headers.authorization ?? "").split(" ")[1] ?? "";
    const password = Buffer.from(encoded, "base64").toString().split(":").slice(1).join(":");
    if (!APP_PASSWORD || password !== APP_PASSWORD) {
      res.writeHead(401, { "WWW-Authenticate": 'Basic realm="queue"' }).end("Password required");
      return;
    }
    let message = "";
    try {
      if (req.method === "POST" && req.url === "/post") {
        const form = new URLSearchParams(await readBody(req));
        const scheduledAt = form.get("action") === "now" ? null : (await nextFreeSlot()).toISOString();
        await hapi("/posts", {
          method: "POST",
          body: JSON.stringify({ content: form.get("content"), accountIds: form.getAll("accountId"), scheduledAt }),
        });
        message = scheduledAt ? `Queued for ${when(scheduledAt)} ✓` : "Posted ✓";
      } else if (req.method === "POST" && req.url.startsWith("/cancel/")) {
        await hapi(`/posts/${encodeURIComponent(req.url.slice("/cancel/".length))}`, { method: "DELETE" });
        message = "Removed from the queue.";
      }
    } catch (err) {
      message = `Error: ${err.message}`;
    }
    try {
      const html = await page(message);
      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" }).end(html);
    } catch (err) {
      res.writeHead(502, { "Content-Type": "text/plain; charset=utf-8" }).end(`Couldn't reach Hapi: ${err.message}`);
    }
  })
  .listen(PORT, () => console.log(`Your Buffer clone is on http://localhost:${PORT}`));

Para rodar:

bash
HAPI_API_KEY=hapi_live_... APP_PASSWORD=pick-one QUEUE_TZ=Europe/Berlin node buffer-clone.mjs

Escreva três posts, clique em Add to queue três vezes, e eles se enfileiram nos três próximos horários. Remova um, e o próximo post que você adicionar ocupa o buraco.

O que a Hapi resolveu por você

Olhe o que não está nessas 120 linhas:

  • Fluxos de OAuth e renovação de token do X e do LinkedIn, e sessões do Bluesky
  • Limites de caracteres, regras de mídia e validação por rede (a Hapi rejeita um post longo demais antes de ele entrar na fila)
  • Um job que publica no minuto exato
  • Novas tentativas, sem publicar em dobro quando algo é repetido (envie o header Idempotency-Key)
  • Armazenamento criptografado das credenciais

Essa é a infraestrutura. É também o motivo de a maioria dos fins de semana “vou criar meu Buffer” virar meses.

Transforme em um produto de verdade

  • Texto por rede: passe platformOptions para uma versão mais longa no LinkedIn e uma de 300 caracteres no Bluesky.
  • Imagens: envie com POST /v1/media e depois mande mediaIds junto com o post.
  • Alertas de falha: registre um webhook de post.failed e mostre um selo vermelho na fila.
  • Rascunhos e aprovação: crie com "draft": true e aprove com PATCH /v1/posts/{id}.
  • Texto com IA: deixe o Claude rascunhar posts pelo servidor MCP da Hapi (https://hapi.tools/mcp) e coloque os bons na fila.
  • Clientes: no Hapi Pro, dê a cada cliente o próprio perfil e uma chave restrita a ele, e rode uma fila por cliente.

Quem pode usar

Do jeito que está aqui, o clone roda no seu workspace da Hapi: as contas são as que você conecta no painel. Serve muito bem para a sua marca, para a equipe ou para uma agência que opera as contas dos clientes. Transformar isso em um SaaS público, em que desconhecidos se cadastram e conectam as próprias contas, exige conexão de contas pela API, e a Hapi ainda não oferece isso.

Crie o seu: 15 dias por US$ 5 → Cinco contas e 300 posts: o bastante para construir o clone e rodar de verdade.

Buffer é marca registrada do seu dono. Este tutorial não é afiliado nem endossado pelo Buffer; “clone do Buffer” descreve o fluxo de agendamento em fila que ele recria.