@rackbops/plugin-warbandeer 0.0.0

package/dist/plugin.js

@@ -0,0 +1,522 @@
+// @bun
+// plugins/warbandeer/src/links.ts
+import { createHash, randomBytes, timingSafeEqual } from "crypto";
+import { join } from "path";
+var LINK_CODE_TTL_MS = 10 * 60 * 1000;
+var MAX_LINKED_ACCOUNTS_PER_USER = 20;
+function generateLinkCode() {
+  return randomBytes(4).toString("hex").toUpperCase();
+}
+function generateDeviceToken() {
+  return randomBytes(32).toString("base64url");
+}
+function hashToken(token) {
+  return createHash("sha256").update(token).digest("hex");
+}
+function hashesMatch(a, b) {
+  const bufA = Buffer.from(a);
+  const bufB = Buffer.from(b);
+  return bufA.length === bufB.length && timingSafeEqual(bufA, bufB);
+}
+function mintLinkCode(state, discordUserId, now, generateCode = generateLinkCode) {
+  const others = state.pending.filter((p) => p.discordUserId !== discordUserId);
+  let code = generateCode();
+  while (others.some((p) => p.code === code)) {
+    code = generateCode();
+  }
+  const pending = others.concat({ code, discordUserId, expiresAt: now + LINK_CODE_TTL_MS });
+  return { code, state: { ...state, pending } };
+}
+function redeemLinkCode(state, code, now) {
+  const match = state.pending.find((p) => p.code === code);
+  const nextState = { ...state, pending: state.pending.filter((p) => p.code !== code) };
+  if (!match)
+    return { ok: false, reason: "not-found", state: nextState };
+  if (match.expiresAt < now)
+    return { ok: false, reason: "expired", state: nextState };
+  return { ok: true, discordUserId: match.discordUserId, state: nextState };
+}
+function upsertLinkedAccount(state, discordUserId, accountLabel, tokenHash, now) {
+  const existing = state.accounts[discordUserId] ?? [];
+  const current = existing.find((a) => a.accountLabel === accountLabel);
+  const entry = current ? { ...current, tokenHash, updatedAt: now } : { accountLabel, tokenHash, linkedAt: now, updatedAt: now };
+  const accounts = current ? existing.map((a) => a.accountLabel === accountLabel ? entry : a) : [...existing, entry];
+  return { ...state, accounts: { ...state.accounts, [discordUserId]: accounts } };
+}
+function removeLinkedAccount(state, discordUserId, accountLabel) {
+  const existing = state.accounts[discordUserId] ?? [];
+  const removed = existing.find((a) => a.accountLabel === accountLabel);
+  if (!removed)
+    return;
+  const remaining = existing.filter((a) => a.accountLabel !== accountLabel);
+  const accounts = { ...state.accounts };
+  if (remaining.length > 0)
+    accounts[discordUserId] = remaining;
+  else
+    delete accounts[discordUserId];
+  return { removed, state: { ...state, accounts } };
+}
+function touchLinkedAccount(state, discordUserId, accountLabel, now) {
+  const existing = state.accounts[discordUserId];
+  if (!existing)
+    return state;
+  const accounts = existing.map((a) => a.accountLabel === accountLabel ? { ...a, updatedAt: now } : a);
+  return { ...state, accounts: { ...state.accounts, [discordUserId]: accounts } };
+}
+function findAccountByToken(state, token) {
+  const hash = hashToken(token);
+  for (const [discordUserId, accounts] of Object.entries(state.accounts)) {
+    const account = accounts.find((a) => hashesMatch(hash, a.tokenHash));
+    if (account)
+      return { discordUserId, account };
+  }
+  return;
+}
+function normalizeLinksState(raw) {
+  const pending = Array.isArray(raw?.pending) ? raw.pending : [];
+  const accountsRaw = raw?.accounts;
+  const accounts = accountsRaw && typeof accountsRaw === "object" && !Array.isArray(accountsRaw) ? Object.fromEntries(Object.entries(accountsRaw).filter(([, v]) => Array.isArray(v))) : {};
+  return { pending, accounts };
+}
+async function loadLinksFrom(path, storage) {
+  const raw = await storage.readJsonOrFresh(path, () => ({ pending: [], accounts: {} }), "links");
+  return normalizeLinksState(raw);
+}
+var links = { pending: [], accounts: {} };
+var linksWriter;
+async function loadLinks(dataDir, storage) {
+  const path = join(dataDir, "links.json");
+  linksWriter = storage.createJsonWriter(path);
+  const loaded = await loadLinksFrom(path, storage);
+  links.pending = loaded.pending;
+  links.accounts = loaded.accounts;
+}
+function saveLinks() {
+  if (!linksWriter)
+    throw new Error("warbandeer: saveLinks() called before loadLinks()");
+  return linksWriter.save(links);
+}
+
+// plugins/warbandeer/src/characters.ts
+import { join as join2 } from "path";
+var MAX_ACCOUNT_LABEL_LENGTH = 64;
+var MAX_CHARACTERS_PER_SNAPSHOT = 60;
+var MAX_STRING_FIELD_LENGTH = 256;
+function validateAccountLabel(accountLabel) {
+  const trimmed = accountLabel.trim();
+  if (trimmed.length === 0)
+    return { ok: false, error: "accountLabel must not be empty" };
+  if (trimmed.length > MAX_ACCOUNT_LABEL_LENGTH) {
+    return { ok: false, error: `accountLabel exceeds ${MAX_ACCOUNT_LABEL_LENGTH} characters` };
+  }
+  if (/[\x00-\x1f\x7f]/.test(trimmed)) {
+    return { ok: false, error: "accountLabel must not contain control characters" };
+  }
+  return { ok: true, accountLabel: trimmed };
+}
+var MAX_SHAPE_DEPTH = 6;
+var MAX_ARRAY_LENGTH = 200;
+var MAX_OBJECT_KEYS = 100;
+function checkBoundedShape(value, path, depth) {
+  if (depth > MAX_SHAPE_DEPTH)
+    return `${path}: nested too deeply`;
+  if (typeof value === "string") {
+    return value.length > MAX_STRING_FIELD_LENGTH ? `${path}: exceeds ${MAX_STRING_FIELD_LENGTH} characters` : undefined;
+  }
+  if (typeof value === "number" || typeof value === "boolean" || value === null)
+    return;
+  if (Array.isArray(value)) {
+    if (value.length > MAX_ARRAY_LENGTH)
+      return `${path}: array exceeds ${MAX_ARRAY_LENGTH} entries`;
+    for (const [i, item] of value.entries()) {
+      const err = checkBoundedShape(item, `${path}[${i}]`, depth + 1);
+      if (err)
+        return err;
+    }
+    return;
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj);
+    if (keys.length > MAX_OBJECT_KEYS)
+      return `${path}: object exceeds ${MAX_OBJECT_KEYS} keys`;
+    for (const key of keys) {
+      if (key.length > MAX_STRING_FIELD_LENGTH)
+        return `${path}: an object key exceeds ${MAX_STRING_FIELD_LENGTH} characters`;
+      const err = checkBoundedShape(obj[key], `${path}.${key}`, depth + 1);
+      if (err)
+        return err;
+    }
+    return;
+  }
+  return `${path}: unsupported value type`;
+}
+function validateCharacterPayload(raw, accountLabel) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return { ok: false, error: "payload must be a JSON object" };
+  }
+  const obj = raw;
+  const characters = obj.characters;
+  if (!Array.isArray(characters)) {
+    return { ok: false, error: "characters must be an array" };
+  }
+  if (characters.length > MAX_CHARACTERS_PER_SNAPSHOT) {
+    return { ok: false, error: `characters exceeds ${MAX_CHARACTERS_PER_SNAPSHOT} entries` };
+  }
+  for (const [i, c] of characters.entries()) {
+    if (typeof c !== "object" || c === null || Array.isArray(c)) {
+      return { ok: false, error: `characters[${i}] must be an object` };
+    }
+  }
+  const shapeError = checkBoundedShape(obj, "payload", 0);
+  if (shapeError)
+    return { ok: false, error: shapeError };
+  const warband = obj.warband;
+  const bankGold = warband && typeof warband === "object" && typeof warband.bankGold === "number" ? warband.bankGold : 0;
+  return {
+    ok: true,
+    snapshot: { accountLabel, warband: { bankGold }, characters }
+  };
+}
+var charactersDirValue = "";
+var storageRef;
+var charactersMutator;
+function initCharacters(dataDir, storage) {
+  charactersDirValue = join2(dataDir, "characters");
+  storageRef = storage;
+  charactersMutator = storage.createKeyedJsonMutator();
+}
+function charactersDir() {
+  return charactersDirValue;
+}
+function requireMutator() {
+  if (!charactersMutator)
+    throw new Error("warbandeer: characters storage used before initCharacters()");
+  return charactersMutator;
+}
+function charactersFilePathIn(baseDir, discordUserId) {
+  if (!/^\d{1,25}$/.test(discordUserId)) {
+    throw new Error(`refusing to build a characters path from a non-snowflake id: "${discordUserId}"`);
+  }
+  return join2(baseDir, `${discordUserId}.json`);
+}
+async function saveCharacterSnapshotTo(baseDir, discordUserId, snapshot, now = Date.now()) {
+  const path = charactersFilePathIn(baseDir, discordUserId);
+  await requireMutator().update(path, () => ({ snapshots: [] }), (current) => {
+    const withoutLabel = current.snapshots.filter((s) => s.accountLabel !== snapshot.accountLabel);
+    return { snapshots: [...withoutLabel, { ...snapshot, receivedAt: now }] };
+  }, "characters");
+}
+async function deleteCharacterSnapshotFrom(baseDir, discordUserId, accountLabel) {
+  const path = charactersFilePathIn(baseDir, discordUserId);
+  await requireMutator().update(path, () => ({ snapshots: [] }), (current) => ({ snapshots: current.snapshots.filter((s) => s.accountLabel !== accountLabel) }), "characters");
+}
+
+// plugins/warbandeer/src/link-command.ts
+import { MessageFlags } from "discord.js";
+
+// plugins/warbandeer/src/server.ts
+var configured = false;
+function setConnectorConfigured(value) {
+  configured = value;
+}
+function warbandeerConnectorConfigured() {
+  return configured;
+}
+var serverRunning = false;
+function warbandeerServerRunning() {
+  return serverRunning;
+}
+var PRUNE_THRESHOLD = 1e4;
+function createRateLimiter(opts) {
+  const now = opts.now ?? Date.now;
+  const windows = new Map;
+  return {
+    allow(key) {
+      const t = now();
+      if (windows.size > PRUNE_THRESHOLD) {
+        for (const [k, w2] of windows) {
+          if (t >= w2.resetAt)
+            windows.delete(k);
+        }
+      }
+      const w = windows.get(key);
+      if (!w || t >= w.resetAt) {
+        windows.set(key, { count: 1, resetAt: t + opts.windowMs });
+        return true;
+      }
+      if (w.count >= opts.max)
+        return false;
+      w.count += 1;
+      return true;
+    }
+  };
+}
+var DEFAULT_MAX_BODY_BYTES = 512 * 1024;
+function extractBearerToken(authHeader) {
+  const m = authHeader?.match(/^Bearer (.+)$/);
+  return m?.[1];
+}
+function jsonResponse(body, status = 200) {
+  return new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json" } });
+}
+async function readBodyWithCap(req, maxBytes) {
+  const declared = req.headers.get("Content-Length");
+  if (declared && Number(declared) > maxBytes)
+    return;
+  if (!req.body)
+    return "";
+  const reader = req.body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    total += value.byteLength;
+    if (total > maxBytes) {
+      await reader.cancel().catch(() => {});
+      return;
+    }
+    chunks.push(value);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function parseJsonObjectBody(text) {
+  try {
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+async function handleRequest(req, clientIp, deps) {
+  const url = new URL(req.url);
+  if (req.method === "POST" && url.pathname === "/link") {
+    if (!deps.rateLimiter.allow(`link:${clientIp}`)) {
+      return new Response("too many requests", { status: 429 });
+    }
+    const body = await readBodyWithCap(req, deps.maxBodyBytes);
+    if (body === undefined)
+      return new Response("payload too large", { status: 413 });
+    const parsed = parseJsonObjectBody(body);
+    const code = typeof parsed?.code === "string" ? parsed.code.trim().toUpperCase() : undefined;
+    const rawAccountLabel = typeof parsed?.accountLabel === "string" ? parsed.accountLabel : undefined;
+    if (!code || !rawAccountLabel) {
+      return new Response("code and accountLabel are required", { status: 400 });
+    }
+    const labelResult = validateAccountLabel(rawAccountLabel);
+    if (!labelResult.ok)
+      return new Response(labelResult.error, { status: 400 });
+    const result = await deps.redeemCode(code, labelResult.accountLabel);
+    if (!result.ok)
+      return new Response(result.error, { status: 400 });
+    return jsonResponse({ token: result.token });
+  }
+  if (req.method === "POST" && url.pathname === "/characters") {
+    if (!deps.authFailureLimiter.allow(`characters-ip:${clientIp}`)) {
+      return new Response("too many requests", { status: 429 });
+    }
+    const token = extractBearerToken(req.headers.get("Authorization"));
+    if (!token)
+      return new Response("unauthorized", { status: 401 });
+    const owner = deps.authenticate(token);
+    if (!owner)
+      return new Response("unauthorized", { status: 401 });
+    if (!deps.rateLimiter.allow(`push:${token}`)) {
+      return new Response("too many requests", { status: 429 });
+    }
+    const body = await readBodyWithCap(req, deps.maxBodyBytes);
+    if (body === undefined)
+      return new Response("payload too large", { status: 413 });
+    const parsed = parseJsonObjectBody(body);
+    if (parsed === undefined)
+      return new Response("invalid JSON", { status: 400 });
+    const result = await deps.storeCharacters(owner.discordUserId, owner.accountLabel, parsed);
+    if (!result.ok)
+      return new Response(result.error, { status: 400 });
+    return new Response(null, { status: 204 });
+  }
+  return new Response("not found", { status: 404 });
+}
+function createProductionDeps(overrides) {
+  const state = overrides?.linksState ?? links;
+  const persistLinks = overrides?.persistLinks ?? saveLinks;
+  const charactersBaseDir = overrides?.charactersBaseDir ?? charactersDir();
+  return {
+    maxBodyBytes: DEFAULT_MAX_BODY_BYTES,
+    rateLimiter: createRateLimiter({ windowMs: 60000, max: 30 }),
+    authFailureLimiter: createRateLimiter({ windowMs: 60000, max: 300 }),
+    redeemCode: async (code, accountLabel) => {
+      const now = Date.now();
+      const redeemed = redeemLinkCode(state, code, now);
+      state.pending = redeemed.state.pending;
+      state.accounts = redeemed.state.accounts;
+      if (!redeemed.ok) {
+        await persistLinks();
+        console.error(`[warbandeer] /link redeem failed (${redeemed.reason})`);
+        return { ok: false, error: redeemed.reason === "expired" ? "code expired" : "unknown code" };
+      }
+      const existingCount = state.accounts[redeemed.discordUserId]?.length ?? 0;
+      const alreadyLinked = state.accounts[redeemed.discordUserId]?.some((a) => a.accountLabel === accountLabel) ?? false;
+      if (!alreadyLinked && existingCount >= MAX_LINKED_ACCOUNTS_PER_USER) {
+        await persistLinks();
+        return {
+          ok: false,
+          error: `you already have ${MAX_LINKED_ACCOUNTS_PER_USER} linked accounts \u2014 unlink one before adding another`
+        };
+      }
+      const token = generateDeviceToken();
+      const next = upsertLinkedAccount(state, redeemed.discordUserId, accountLabel, hashToken(token), now);
+      state.accounts = next.accounts;
+      await persistLinks();
+      console.log(`[warbandeer] linked accountLabel="${accountLabel}" for discord user ${redeemed.discordUserId}`);
+      return { ok: true, token };
+    },
+    authenticate: (token) => {
+      const match = findAccountByToken(state, token);
+      return match ? { discordUserId: match.discordUserId, accountLabel: match.account.accountLabel } : undefined;
+    },
+    storeCharacters: async (discordUserId, accountLabel, raw) => {
+      const validated = validateCharacterPayload(raw, accountLabel);
+      if (!validated.ok) {
+        console.error(`[warbandeer] rejected a push for discord user ${discordUserId}: ${validated.error}`);
+        return validated;
+      }
+      await saveCharacterSnapshotTo(charactersBaseDir, discordUserId, validated.snapshot);
+      const next = touchLinkedAccount(state, discordUserId, accountLabel, Date.now());
+      state.accounts = next.accounts;
+      await persistLinks();
+      return { ok: true };
+    }
+  };
+}
+function startWarbandeerServer(port, deps = createProductionDeps()) {
+  const server = Bun.serve({
+    port,
+    maxRequestBodySize: deps.maxBodyBytes * 4,
+    idleTimeout: 30,
+    fetch: (req, srv) => {
+      const clientIp = req.headers.get("CF-Connecting-IP") ?? srv.requestIP(req)?.address ?? "unknown";
+      return handleRequest(req, clientIp, deps);
+    }
+  });
+  serverRunning = true;
+  const boundPort = server.port ?? port;
+  console.log(`[warbandeer] ingest server listening on :${boundPort}`);
+  return {
+    port: boundPort,
+    stop: () => {
+      serverRunning = false;
+      server.stop();
+    }
+  };
+}
+
+// plugins/warbandeer/src/link-command.ts
+var LINK_CODE_TTL_MINUTES = 10;
+function linkReply(code) {
+  return `\uD83D\uDD17 Your link code is **${code}**. Enter it in the Warbandeer desktop app within ` + `${LINK_CODE_TTL_MINUTES} minutes to connect your character data to this Discord account.`;
+}
+function linkAvailability(configured2, running) {
+  if (!configured2) {
+    return {
+      available: false,
+      message: "Character linking isn't configured on this bot \u2014 set `WARBANDEER_INGEST_PORT` to enable it."
+    };
+  }
+  if (!running) {
+    return {
+      available: false,
+      message: "Character linking is configured but the connector failed to start \u2014 check the bot's logs (see `WARBANDEER_INGEST_PORT`)."
+    };
+  }
+  return { available: true };
+}
+async function handleLinkCommand(interaction) {
+  const availability = linkAvailability(warbandeerConnectorConfigured(), warbandeerServerRunning());
+  if (!availability.available) {
+    await interaction.reply({ content: availability.message, flags: MessageFlags.Ephemeral });
+    return;
+  }
+  await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+  const { code, state } = mintLinkCode(links, interaction.user.id, Date.now());
+  links.pending = state.pending;
+  links.accounts = state.accounts;
+  await saveLinks();
+  await interaction.editReply({ content: linkReply(code) });
+}
+function unlinkReply(accounts, accountLabel) {
+  if (accounts.length === 0) {
+    return { message: "You don't have any linked accounts." };
+  }
+  if (!accountLabel) {
+    const only = accounts[0];
+    if (accounts.length === 1 && only) {
+      return { message: `\uD83D\uDD13 Unlinked \`${only.accountLabel}\`.`, remove: only.accountLabel };
+    }
+    const labels = accounts.map((a) => `\`${a.accountLabel}\``).join(", ");
+    return { message: `You have multiple linked accounts (${labels}) \u2014 specify which one with \`account_label\`.` };
+  }
+  if (!accounts.some((a) => a.accountLabel === accountLabel)) {
+    return { message: `You don't have an account named \`${accountLabel}\`.` };
+  }
+  return { message: `\uD83D\uDD13 Unlinked \`${accountLabel}\`.`, remove: accountLabel };
+}
+async function handleUnlinkCommand(interaction) {
+  await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+  const accountLabel = interaction.options.getString("account_label") ?? undefined;
+  const accounts = links.accounts[interaction.user.id] ?? [];
+  const decision = unlinkReply(accounts, accountLabel);
+  if (decision.remove) {
+    const result = removeLinkedAccount(links, interaction.user.id, decision.remove);
+    if (result) {
+      links.accounts = result.state.accounts;
+      await saveLinks();
+      await deleteCharacterSnapshotFrom(charactersDir(), interaction.user.id, decision.remove);
+    }
+  }
+  await interaction.editReply({ content: decision.message });
+}
+
+// plugins/warbandeer/src/index.ts
+function createPlugin(host) {
+  const portRaw = host.env.WARBANDEER_INGEST_PORT;
+  let port;
+  if (portRaw !== undefined) {
+    const n = Number(portRaw);
+    if (!Number.isInteger(n) || n <= 0 || n > 65535) {
+      throw new Error(`WARBANDEER_INGEST_PORT must be a valid port number, got "${portRaw}"`);
+    }
+    port = n;
+  }
+  setConnectorConfigured(port !== undefined);
+  return {
+    commands: [
+      {
+        name: "link",
+        build: (builder) => builder.setDescription("Link the Warbandeer desktop app to your Discord account"),
+        handle: handleLinkCommand
+      },
+      {
+        name: "unlink",
+        build: (builder) => builder.setDescription("Unlink a Warbandeer desktop account from your Discord account").addStringOption((o) => o.setName("account_label").setDescription("Which linked account (only needed if you have more than one)").setRequired(false).setMaxLength(MAX_ACCOUNT_LABEL_LENGTH)),
+        handle: handleUnlinkCommand
+      }
+    ],
+    async activate() {
+      await loadLinks(host.dataDir, host.storage);
+      initCharacters(host.dataDir, host.storage);
+      if (port !== undefined) {
+        try {
+          startWarbandeerServer(port);
+        } catch (err) {
+          host.log.error(`connector failed to start on :${port} \u2014 the bot keeps running without it; /link will report the feature disabled. ` + "Check the port isn't already in use and isn't a privileged one the container's non-root user can't bind.", err);
+        }
+      }
+    }
+  };
+}
+export {
+  createPlugin
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@rackbops/plugin-warbandeer",
+  "version": "0.0.0",
+  "description": "Warbandeer desktop-app character linking (/link, /unlink, ingest endpoint)",
+  "type": "module",
+  "main": "dist/plugin.js",
+  "files": ["dist"],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rackbops/rackbops-bot-plugins.git",
+    "directory": "plugins/warbandeer"
+  },
+  "peerDependencies": {
+    "discord.js": "^14.27.0"
+  },
+  "botPlugin": {
+    "hostApiVersion": 1,
+    "intents": [],
+    "commands": ["link", "unlink"],
+    "env": [
+      {
+        "key": "WARBANDEER_INGEST_PORT",
+        "format": "^([1-9][0-9]{0,3}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5])$",
+        "required": false,
+        "secret": false,
+        "description": "Port the ingest server binds inside the container; unset = connector off (never published to the host; reachable only through the Cloudflare Tunnel)"
+      }
+    ]
+  }
+}