npm module: @flitt/api

npm install @flitt/api
# pnpm add @flitt/api · yarn add @flitt/api · bun add @flitt/api

import { Flitt } from "@flitt/api";

const flitt = new Flitt({ apiKey: process.env.FLITT_API_KEY });

const { data: servers } = await flitt.servers.list();
for (const server of servers) {
  console.log(`${server.name}: ${server.playersOnline} players (${server.status})`);
}

const { Flitt } = require("@flitt/api");

FLITT_API_KEY=flt_...
FLITT_SERVER_TOKEN=flv_...

const flitt = new Flitt({ serverToken: process.env.FLITT_SERVER_TOKEN });

const claim = await flitt.votes.claim("srv_123", { player: "Alex_RP" });

const flitt = new Flitt({
  apiKey: process.env.FLITT_API_KEY,
  onRateLimit: ({ limit, remaining, reset }) => console.log(remaining, "/", limit, "until", reset),
});

await flitt.servers.list();
console.log(flitt.rateLimit);

await flitt.firewall.update("srv_123", { enabled: true, blockVpn: true, kickMessage: "VPN not allowed" });

const result = await flitt.firewall.rules.create("srv_123", [
  { action: "DENY", kind: "IDENTIFIER", value: "76561198000000000", note: "Cheater" },
  { action: "DENY", kind: "COUNTRY", value: "XX" },
]);
for (const e of result.errors) console.warn(e.index, e.code, e.message);

await flitt.commands.chat("srv_123", "Restart in 5 minutes!");
const res = await flitt.commands.ban("srv_123", "76561198000000000", { reason: "RDM", durationSeconds: 86_400 }, { waitMs: 5000 });
console.log(res.result?.ok, res.result?.output);

const page = await flitt.servers.list({ page: 1, limit: 25 });
console.log(page.data, page.pagination);

for await (const player of flitt.players.listAll("srv_123", { status: "all" })) {
  console.log(player.name, player.totalPlaySeconds);
}

const flitt = new Flitt({ serverToken: process.env.FLITT_SERVER_TOKEN });

const claim = await flitt.votes.claim("srv_123", { player: "Alex_RP" });
if (claim.status === "CLAIMED_NOW") {
  giveReward("Alex_RP");
  for (const bonus of claim.rewards ?? []) giveBonus("Alex_RP", bonus.id);
}

const stream = flitt.events.connect({ events: ["vote_created", "player_joined"] });

stream.on("ready", ({ servers }) => console.log("following", servers));
stream.on("vote_created", (e) => console.log(`${e.data?.player} voted for ${e.server.name}`));
stream.on("player_joined", (e) => console.log("join", e.data));
stream.on("reconnecting", ({ delayMs }) => console.log("reconnecting in", delayMs, "ms"));
stream.on("error", (err) => console.error(err.message));

for await (const event of flitt.events.connect({ servers: ["srv_123"] })) {
  if (event.event === "player_chat") relayToDiscord(event);
}

import { readFile, writeFile } from "node:fs/promises";

const saved = JSON.parse(await readFile("positions.json", "utf8").catch(() => "{}"));
const stream = flitt.events.connect({ lastEventIds: saved });

process.on("SIGTERM", async () => {
  await writeFile("positions.json", JSON.stringify(stream.lastEventIds));
  stream.close();
});

import WebSocket from "ws";

const stream = flitt.events.connect({ WebSocket });

import express from "express";
import { verifyWebhook, FlittWebhookError } from "@flitt/api";

const app = express();

app.post("/flitt-webhook", express.raw({ type: "application/json" }), async (req, res) => {
  try {
    const event = await verifyWebhook({
      payload: req.body,
      headers: req.headers,
      secret: process.env.FLITT_WEBHOOK_SECRET!,
      isReplay: (nonce) => seenBefore(nonce),
    });
    if (event.event === "server_down") console.log(`${event.server.name} is down`);
    res.sendStatus(204);
  } catch (err) {
    res.sendStatus(err instanceof FlittWebhookError ? 400 : 500);
  }
});

export async function POST(request: Request) {
  const event = await verifyWebhook({
    payload: await request.text(),
    headers: request.headers,
    secret: process.env.FLITT_WEBHOOK_SECRET!,
  });
  return new Response(null, { status: 204 });
}

import { FlittNotFoundError, FlittRateLimitError } from "@flitt/api";

try {
  await flitt.servers.get("srv_123");
} catch (err) {
  if (err instanceof FlittNotFoundError) console.log("Unknown server");
  else if (err instanceof FlittRateLimitError) console.log(`Retry in ${err.retryAfterMs} ms`);
  else throw err;
}

new Flitt({
  apiKey: "flt_...",
  serverToken: "flv_...",
  baseUrl: "https://api.flitt.me",
  timeoutMs: 15_000,
  maxRetries: 2,
  maxRetryDelayMs: 30_000,
  fetch: customFetch,
  userAgent: "my-bot/1.0",
  onRateLimit: (rl) => metrics.gauge("flitt.remaining", rl.remaining ?? Infinity),
  dangerouslyAllowBrowser: false,
});

const controller = new AbortController();
setTimeout(() => controller.abort(), 2000);

await flitt.servers.list({}, { signal: controller.signal, timeoutMs: 5000, maxRetries: 0 });

npm install @flitt/api@latest
npm ls @flitt/api

const votes = new FlittVotes({ token: process.env.FLITT_VOTE_TOKEN });
await votes.claim({ player: "Alex_RP" });

const flitt = new Flitt({ serverToken: process.env.FLITT_VOTE_TOKEN });
await flitt.votes.claim("srv_123", { player: "Alex_RP" });

import { VERSION } from "@flitt/api";
console.log(VERSION);