Crie o bot do seu servidor.

// bot.mjs: Node 22 e o pacote ws, sem SDK
// npm i ws
// FALAFY_TOKEN=... SERVER_ID=... node bot.mjs
import WebSocket from 'ws';

const TOKEN = process.env.FALAFY_TOKEN; // Configurações > Desenvolvedor
const SERVER_ID = process.env.SERVER_ID;
const API = 'https://falafy.com.br/api/v1';

const api = (method, path, body) =>
  fetch(API + path, {
    method,
    headers: { authorization: `Bot ${TOKEN}`, 'content-type': 'application/json' },
    body: body && JSON.stringify(body),
  }).then((r) => (r.status === 204 ? null : r.json()));

// responde a uma interação (sem Authorization: o token da interação é a credencial)
const reply = (i, body) =>
  fetch(`${API}/interactions/${i.id}/${i.token}/callback`, {
    method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify(body),
  });

// registra os comandos só neste servidor (valem na hora)
const me = await api('GET', '/users/@me');
await api('PUT', `/applications/${me.id}/servers/${SERVER_ID}/commands`, [
  { name: 'ping', description: 'Responde pong' },
  { name: 'dado', description: 'Rola um dado',
    options: [{ type: 4, name: 'lados', description: 'Quantos lados', minValue: 2, maxValue: 100 }] },
]);

const roll = (lados) => ({
  content: `🎲 ${1 + Math.floor(Math.random() * lados)} (d${lados})`,
  components: [{ type: 1, components: [{ type: 2, style: 1, label: 'Rolar de novo', customId: `dado:${lados}` }] }],
});

const { url } = await api('GET', '/gateway/bot');
function connect() {
  const ws = new WebSocket(url);
  let ping;
  ws.on('open', () => {
    ws.send(JSON.stringify({ op: 'IDENTIFY', token: `Bot ${TOKEN}`, intents: 1 })); // SERVERS
    ping = setInterval(() => ws.send(JSON.stringify({ op: 'PING' })), 30_000);
  });
  ws.on('close', () => { clearInterval(ping); setTimeout(connect, 5_000); }); // caiu? reconecta
  ws.on('message', (raw) => {
    const f = JSON.parse(raw);
    if (f.op === 'READY') console.log('online como', f.d.user.displayName);
    if (f.op !== 'EVENT' || f.event.t !== 'INTERACTION_CREATE') return;
    const i = f.event.d;
    // flags 64 = efêmera: só quem usou o comando vê
    if (i.type === 2 && i.data.name === 'ping') reply(i, { type: 4, data: { content: 'pong', flags: 64 } });
    if (i.type === 2 && i.data.name === 'dado') {
      const lados = i.data.options.find((o) => o.name === 'lados')?.value ?? 6;
      reply(i, { type: 4, data: roll(lados) });
    }
    // clique no botão: tipo 7 edita a mesma mensagem
    if (i.type === 3 && i.data.customId.startsWith('dado:')) reply(i, { type: 7, data: roll(Number(i.data.customId.slice(5))) });
  });
}
connect();

Escreva um bot para o Falafy em um único arquivo bot.mjs (Node 22, ESM, só a dependência ws; use o fetch nativo). O token fica em process.env.FALAFY_TOKEN e nunca aparece no código nem em logs. O Falafy não é o Discord: use só a API descrita aqui e não invente rotas.

API do Falafy
- REST: base https://falafy.com.br/api/v1, header Authorization: Bot <token>, corpo JSON, campos em camelCase. IDs são strings UUID. Respostas 204 vêm sem corpo.
- GET /users/@me devolve o usuário do bot. O id dele também é o applicationId (appId).
- GET /gateway/bot devolve { url } do WebSocket do gateway.
- Comandos de barra: PUT /applications/{appId}/servers/{serverId}/commands com uma lista que substitui todos os comandos do bot nesse servidor (valem na hora). Comando: { name (a-z, 0-9, _ e -, até 32), description (até 100), options?: [{ type, name, description, required?, choices?: [{ name, value }], minValue?, maxValue?, minLength?, maxLength?, autocomplete? }] }. Tipos de opção: 3 texto, 4 inteiro, 5 booleano, 6 usuário, 7 canal, 8 cargo, 10 número. Opções obrigatórias vêm antes das opcionais.
- Gateway: conecte na url e, ao abrir, envie {"op":"IDENTIFY","token":"Bot <token>","intents":N}. Chega {"op":"READY","d":{ user, servers, channels, roles, resumeId }}. Envie {"op":"PING"} a cada 30 s (a resposta é {"op":"PONG"}). Eventos chegam como {"op":"EVENT","event":{"t":"NOME","d":{...}},"seq":n}. Se a conexão cair, espere uns segundos, reconecte e envie IDENTIFY de novo.
- Intents (some os valores): SERVERS 1, SERVER_MEMBERS 2 (privilegiada), SERVER_MESSAGES 512, SERVER_MESSAGE_REACTIONS 1024, DIRECT_MESSAGES 4096, MESSAGE_CONTENT 32768 (privilegiada). As privilegiadas precisam ser ativadas antes no portal (Configurações > Desenvolvedor). Sem MESSAGE_CONTENT o bot só vê o texto de DMs e de mensagens que mencionam o bot. INTERACTION_CREATE chega sempre, sem intent.
- Eventos úteis: MESSAGE_CREATE (d: { id, channelId, author: { id, username, displayName }, content, mentions }), MEMBER_JOIN (d: { serverId, user }), INTERACTION_CREATE.
- INTERACTION_CREATE (d): { id, token, type (2 comando, 3 componente, 4 autocomplete, 5 modal), applicationId, serverId, channelId, user: { id, username, displayName }, member: { roleIds, permissions } ou null, data, message? }. data de comando: { name, options: [{ name, type, value }] }. data de componente: { customId, values? }. data de modal: { customId, fields: [{ customId, value }] }.
- Responder: POST /interactions/{id}/{token}/callback, sem Authorization, uma única vez e em até 3 segundos. Corpo { type, data }: 4 mensagem; 5 "pensando…" (depois edite com PATCH /webhooks/{appId}/{token}/messages/@original); 6 confirma o clique sem mudar nada; 7 edita a mensagem do componente; 8 escolhas do autocomplete ({ choices: [{ name, value }] }); 9 abre um modal ({ customId, title, components: [{ type: 1, components: [{ type: 4, customId, label, style: 1 curto ou 2 parágrafo }] }] }). data.flags = 64 deixa a resposta efêmera (só quem usou vê). Follow-ups: POST /webhooks/{appId}/{token} por até 15 minutos.
- Mensagem: content (até 2000), embeds (até 10), components (até 5 linhas). Embed: { title, description, url, color (inteiro), fields: [{ name, value, inline }], footer: { text }, image: { url }, thumbnail: { url } }, URLs só https. Linha { type: 1, components } com até 5 botões ou 1 menu. Botão { type: 2, style, label }: style 1 primário, 2 secundário, 3 sucesso, 4 perigo (com customId) ou 5 link (com url e sem customId; não gera interação). Menu { type: 3, customId, placeholder, options: [{ label, value, description? }], minValues?, maxValues? }.
- Mensagens: POST /channels/{channelId}/messages { content, embeds, components, replyToId }; PATCH e DELETE /channels/{channelId}/messages/{messageId}; reação: PUT /channels/{channelId}/messages/{messageId}/reactions/{emoji}/@me.
- Cargos: GET /servers/{serverId}/roles; PUT e DELETE /servers/{serverId}/members/{userId}/roles/{roleId}. O bot precisa da permissão Gerenciar cargos e de um cargo acima do cargo que vai dar.
- DM: POST /users/@me/channels { recipientId } devolve o canal; depois POST /channels/{id}/messages. Só funciona com quem divide um servidor com o bot.
- Limites: em 429, espere body.retryAfter segundos e tente de novo. Erros vêm como { code, message, status }.
- Não existe (não tente): entrar em canal de voz, expulsar, banir ou silenciar membros, criar canais ou tópicos, enviar arquivos ou anexos.

Requisitos: registre os comandos no SERVER_ID ao iniciar; trate erros sem derrubar o processo; no topo do arquivo, explique como rodar (npm i ws e FALAFY_TOKEN=... node bot.mjs) e quais permissões e intents ativar no portal.

O bot que eu quero: /enquete com uma pergunta e opções, um botão por opção e a contagem atualizando ao vivo.
SERVER_ID: [cole aqui o ID do servidor]