Build the bot for your server.

// bot.mjs: Node 22 and the ws package, no SDK
// npm i ws
// FALAFY_TOKEN=... SERVER_ID=... node bot.mjs
import WebSocket from 'ws';

const TOKEN = process.env.FALAFY_TOKEN; // Settings > Developer
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()));

// answers an interaction (no Authorization: the interaction token is the credential)
const reply = (i, body) =>
  fetch(`${API}/interactions/${i.id}/${i.token}/callback`, {
    method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify(body),
  });

// registers the commands only in this server (they work at once)
const me = await api('GET', '/users/@me');
await api('PUT', `/applications/${me.id}/servers/${SERVER_ID}/commands`, [
  { name: 'ping', description: 'Replies pong' },
  { name: 'dado', description: 'Rolls a die',
    options: [{ type: 4, name: 'lados', description: 'How many sides', 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: 'Roll again', 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); }); // dropped? reconnect
  ws.on('message', (raw) => {
    const f = JSON.parse(raw);
    if (f.op === 'READY') console.log('online as', f.d.user.displayName);
    if (f.op !== 'EVENT' || f.event.t !== 'INTERACTION_CREATE') return;
    const i = f.event.d;
    // flags 64 = ephemeral: only the person who used the command sees it
    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) });
    }
    // button click: type 7 edits the same message
    if (i.type === 3 && i.data.customId.startsWith('dado:')) reply(i, { type: 7, data: roll(Number(i.data.customId.slice(5))) });
  });
}
connect();

Write a bot for Falafy in a single bot.mjs file (Node 22, ESM, only the ws dependency; use the built-in fetch). The token lives in process.env.FALAFY_TOKEN and never appears in the code or in logs. Falafy is not Discord: use only the API described here and do not invent routes.

Falafy API
- REST: base https://falafy.com.br/api/v1, header Authorization: Bot <token>, JSON body, camelCase fields. IDs are UUID strings. 204 responses have no body.
- GET /users/@me returns the bot user. Its id is also the applicationId (appId).
- GET /gateway/bot returns { url } of the gateway WebSocket.
- Slash commands: PUT /applications/{appId}/servers/{serverId}/commands with a list that replaces all of the bot's commands in that server (they work at once). Command: { name (a-z, 0-9, _ and -, up to 32), description (up to 100), options?: [{ type, name, description, required?, choices?: [{ name, value }], minValue?, maxValue?, minLength?, maxLength?, autocomplete? }] }. Option types: 3 string, 4 integer, 5 boolean, 6 user, 7 channel, 8 role, 10 number. Required options come before optional ones.
- Gateway: connect to url and, on open, send {"op":"IDENTIFY","token":"Bot <token>","intents":N}. You get {"op":"READY","d":{ user, servers, channels, roles, resumeId }}. Send {"op":"PING"} every 30 s (the answer is {"op":"PONG"}). Events arrive as {"op":"EVENT","event":{"t":"NAME","d":{...}},"seq":n}. If the connection drops, wait a few seconds, reconnect and send IDENTIFY again.
- Intents (add the values): SERVERS 1, SERVER_MEMBERS 2 (privileged), SERVER_MESSAGES 512, SERVER_MESSAGE_REACTIONS 1024, DIRECT_MESSAGES 4096, MESSAGE_CONTENT 32768 (privileged). Privileged intents must be enabled first in the portal (Settings > Developer). Without MESSAGE_CONTENT the bot only sees the text of DMs and of messages that mention it. INTERACTION_CREATE always arrives, no intent needed.
- Useful events: 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 command, 3 component, 4 autocomplete, 5 modal), applicationId, serverId, channelId, user: { id, username, displayName }, member: { roleIds, permissions } or null, data, message? }. Command data: { name, options: [{ name, type, value }] }. Component data: { customId, values? }. Modal data: { customId, fields: [{ customId, value }] }.
- Replying: POST /interactions/{id}/{token}/callback, without Authorization, only once and within 3 seconds. Body { type, data }: 4 message; 5 "thinking…" (then edit with PATCH /webhooks/{appId}/{token}/messages/@original); 6 acknowledge the click without changing anything; 7 edit the component's message; 8 autocomplete choices ({ choices: [{ name, value }] }); 9 open a modal ({ customId, title, components: [{ type: 1, components: [{ type: 4, customId, label, style: 1 short or 2 paragraph }] }] }). data.flags = 64 makes the reply ephemeral (only the user who used it sees it). Follow-ups: POST /webhooks/{appId}/{token} for up to 15 minutes.
- Message: content (up to 2000), embeds (up to 10), components (up to 5 rows). Embed: { title, description, url, color (integer), fields: [{ name, value, inline }], footer: { text }, image: { url }, thumbnail: { url } }, https URLs only. Row { type: 1, components } with up to 5 buttons or 1 select menu. Button { type: 2, style, label }: style 1 primary, 2 secondary, 3 success, 4 danger (with customId) or 5 link (with url and no customId; it does not create an interaction). Select menu { type: 3, customId, placeholder, options: [{ label, value, description? }], minValues?, maxValues? }.
- Messages: POST /channels/{channelId}/messages { content, embeds, components, replyToId }; PATCH and DELETE /channels/{channelId}/messages/{messageId}; reaction: PUT /channels/{channelId}/messages/{messageId}/reactions/{emoji}/@me.
- Roles: GET /servers/{serverId}/roles; PUT and DELETE /servers/{serverId}/members/{userId}/roles/{roleId}. The bot needs the Manage roles permission and a role above the role it gives.
- DM: POST /users/@me/channels { recipientId } returns the channel; then POST /channels/{id}/messages. Only works with people who share a server with the bot.
- Limits: on 429, wait body.retryAfter seconds and try again. Errors come as { code, message, status }.
- Does not exist (do not try): joining a voice channel, kicking, banning or muting members, creating channels or threads, sending files or attachments.

Requirements: register the commands in SERVER_ID on startup; handle errors without crashing the process; at the top of the file, explain how to run it (npm i ws and FALAFY_TOKEN=... node bot.mjs) and which permissions and intents to enable in the portal.

The bot I want: /poll with a question and options, one button per option and the count updating live.
SERVER_ID: [paste the server ID here]