Discord: add reactions, stickers, and polls skill

src/discord/send.test.ts

@@ -1,7 +1,27 @@
-import { Routes } from "discord.js";
+import { PermissionsBitField, Routes } from "discord.js";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
-import { sendMessageDiscord } from "./send.js";
+import {
+  addRoleDiscord,
+  banMemberDiscord,
+  createThreadDiscord,
+  deleteMessageDiscord,
+  editMessageDiscord,
+  fetchChannelPermissionsDiscord,
+  fetchReactionsDiscord,
+  listGuildEmojisDiscord,
+  listThreadsDiscord,
+  pinMessageDiscord,
+  reactMessageDiscord,
+  readMessagesDiscord,
+  removeRoleDiscord,
+  searchMessagesDiscord,
+  sendMessageDiscord,
+  sendPollDiscord,
+  sendStickerDiscord,
+  timeoutMemberDiscord,
+  unpinMessageDiscord,
+} from "./send.js";
 
 vi.mock("../web/media.js", () => ({
   loadWebMedia: vi.fn().mockResolvedValue({
@@ -14,11 +34,23 @@ vi.mock("../web/media.js", () => ({
 
 const makeRest = () => {
   const postMock = vi.fn();
+  const putMock = vi.fn();
+  const getMock = vi.fn();
+  const patchMock = vi.fn();
+  const deleteMock = vi.fn();
   return {
     rest: {
       post: postMock,
+      put: putMock,
+      get: getMock,
+      patch: patchMock,
+      delete: deleteMock,
     } as unknown as import("discord.js").REST,
     postMock,
+    putMock,
+    getMock,
+    patchMock,
+    deleteMock,
   };
 };
 
@@ -116,3 +148,369 @@ describe("sendMessageDiscord", () => {
     expect(secondBody?.message_reference).toBeUndefined();
   });
 });
+
+describe("reactMessageDiscord", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("reacts with unicode emoji", async () => {
+    const { rest, putMock } = makeRest();
+    await reactMessageDiscord("chan1", "msg1", "✅", { rest, token: "t" });
+    expect(putMock).toHaveBeenCalledWith(
+      Routes.channelMessageOwnReaction("chan1", "msg1", "%E2%9C%85"),
+    );
+  });
+
+  it("normalizes variation selectors in unicode emoji", async () => {
+    const { rest, putMock } = makeRest();
+    await reactMessageDiscord("chan1", "msg1", "⭐️", { rest, token: "t" });
+    expect(putMock).toHaveBeenCalledWith(
+      Routes.channelMessageOwnReaction("chan1", "msg1", "%E2%AD%90"),
+    );
+  });
+
+  it("reacts with custom emoji syntax", async () => {
+    const { rest, putMock } = makeRest();
+    await reactMessageDiscord("chan1", "msg1", "<:party_blob:123>", {
+      rest,
+      token: "t",
+    });
+    expect(putMock).toHaveBeenCalledWith(
+      Routes.channelMessageOwnReaction("chan1", "msg1", "party_blob%3A123"),
+    );
+  });
+});
+
+describe("fetchReactionsDiscord", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("returns reactions with users", async () => {
+    const { rest, getMock } = makeRest();
+    getMock
+      .mockResolvedValueOnce({
+        reactions: [
+          { count: 2, emoji: { name: "✅", id: null } },
+          { count: 1, emoji: { name: "party_blob", id: "123" } },
+        ],
+      })
+      .mockResolvedValueOnce([
+        { id: "u1", username: "alpha", discriminator: "0001" },
+      ])
+      .mockResolvedValueOnce([{ id: "u2", username: "beta" }]);
+    const res = await fetchReactionsDiscord("chan1", "msg1", {
+      rest,
+      token: "t",
+    });
+    expect(res).toEqual([
+      {
+        emoji: { id: null, name: "✅", raw: "✅" },
+        count: 2,
+        users: [{ id: "u1", username: "alpha", tag: "alpha#0001" }],
+      },
+      {
+        emoji: { id: "123", name: "party_blob", raw: "party_blob:123" },
+        count: 1,
+        users: [{ id: "u2", username: "beta", tag: "beta" }],
+      },
+    ]);
+  });
+});
+
+describe("fetchChannelPermissionsDiscord", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("calculates permissions from guild roles", async () => {
+    const { rest, getMock } = makeRest();
+    const perms = new PermissionsBitField([
+      PermissionsBitField.Flags.ViewChannel,
+      PermissionsBitField.Flags.SendMessages,
+    ]);
+    getMock
+      .mockResolvedValueOnce({
+        id: "chan1",
+        guild_id: "guild1",
+        permission_overwrites: [],
+      })
+      .mockResolvedValueOnce({ id: "bot1" })
+      .mockResolvedValueOnce({
+        id: "guild1",
+        roles: [
+          { id: "guild1", permissions: perms.bitfield.toString() },
+          { id: "role2", permissions: "0" },
+        ],
+      })
+      .mockResolvedValueOnce({ roles: ["role2"] });
+    const res = await fetchChannelPermissionsDiscord("chan1", {
+      rest,
+      token: "t",
+    });
+    expect(res.guildId).toBe("guild1");
+    expect(res.permissions).toContain("ViewChannel");
+    expect(res.permissions).toContain("SendMessages");
+    expect(res.isDm).toBe(false);
+  });
+});
+
+describe("readMessagesDiscord", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("passes query params as URLSearchParams", async () => {
+    const { rest, getMock } = makeRest();
+    getMock.mockResolvedValue([]);
+    await readMessagesDiscord(
+      "chan1",
+      { limit: 5, before: "10" },
+      { rest, token: "t" },
+    );
+    const call = getMock.mock.calls[0];
+    const options = call?.[1] as { query?: URLSearchParams };
+    expect(options.query?.toString()).toBe("limit=5&before=10");
+  });
+});
+
+describe("edit/delete message helpers", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("edits message content", async () => {
+    const { rest, patchMock } = makeRest();
+    patchMock.mockResolvedValue({ id: "m1" });
+    await editMessageDiscord(
+      "chan1",
+      "m1",
+      { content: "hello" },
+      { rest, token: "t" },
+    );
+    expect(patchMock).toHaveBeenCalledWith(
+      Routes.channelMessage("chan1", "m1"),
+      expect.objectContaining({ body: { content: "hello" } }),
+    );
+  });
+
+  it("deletes message", async () => {
+    const { rest, deleteMock } = makeRest();
+    deleteMock.mockResolvedValue({});
+    await deleteMessageDiscord("chan1", "m1", { rest, token: "t" });
+    expect(deleteMock).toHaveBeenCalledWith(
+      Routes.channelMessage("chan1", "m1"),
+    );
+  });
+});
+
+describe("pin helpers", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("pins and unpins messages", async () => {
+    const { rest, putMock, deleteMock } = makeRest();
+    putMock.mockResolvedValue({});
+    deleteMock.mockResolvedValue({});
+    await pinMessageDiscord("chan1", "m1", { rest, token: "t" });
+    await unpinMessageDiscord("chan1", "m1", { rest, token: "t" });
+    expect(putMock).toHaveBeenCalledWith(Routes.channelPin("chan1", "m1"));
+    expect(deleteMock).toHaveBeenCalledWith(Routes.channelPin("chan1", "m1"));
+  });
+});
+
+describe("searchMessagesDiscord", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("uses URLSearchParams for search", async () => {
+    const { rest, getMock } = makeRest();
+    getMock.mockResolvedValue({ total_results: 0, messages: [] });
+    await searchMessagesDiscord(
+      { guildId: "g1", content: "hello", limit: 5 },
+      { rest, token: "t" },
+    );
+    const call = getMock.mock.calls[0];
+    const options = call?.[1] as { query?: URLSearchParams };
+    expect(options.query?.toString()).toBe("content=hello&limit=5");
+  });
+
+  it("supports channel/author arrays and clamps limit", async () => {
+    const { rest, getMock } = makeRest();
+    getMock.mockResolvedValue({ total_results: 0, messages: [] });
+    await searchMessagesDiscord(
+      {
+        guildId: "g1",
+        content: "hello",
+        channelIds: ["c1", "c2"],
+        authorIds: ["u1"],
+        limit: 99,
+      },
+      { rest, token: "t" },
+    );
+    const call = getMock.mock.calls[0];
+    const options = call?.[1] as { query?: URLSearchParams };
+    expect(options.query?.toString()).toBe(
+      "content=hello&channel_id=c1&channel_id=c2&author_id=u1&limit=25",
+    );
+  });
+});
+
+describe("threads and moderation helpers", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("creates a thread", async () => {
+    const { rest, postMock } = makeRest();
+    postMock.mockResolvedValue({ id: "t1" });
+    await createThreadDiscord(
+      "chan1",
+      { name: "thread", messageId: "m1" },
+      { rest, token: "t" },
+    );
+    expect(postMock).toHaveBeenCalledWith(
+      Routes.threads("chan1", "m1"),
+      expect.objectContaining({ body: { name: "thread" } }),
+    );
+  });
+
+  it("lists active threads by guild", async () => {
+    const { rest, getMock } = makeRest();
+    getMock.mockResolvedValue({ threads: [] });
+    await listThreadsDiscord({ guildId: "g1" }, { rest, token: "t" });
+    expect(getMock).toHaveBeenCalledWith(Routes.guildActiveThreads("g1"));
+  });
+
+  it("times out a member", async () => {
+    const { rest, patchMock } = makeRest();
+    patchMock.mockResolvedValue({ id: "m1" });
+    await timeoutMemberDiscord(
+      { guildId: "g1", userId: "u1", durationMinutes: 10 },
+      { rest, token: "t" },
+    );
+    expect(patchMock).toHaveBeenCalledWith(
+      Routes.guildMember("g1", "u1"),
+      expect.objectContaining({
+        body: expect.objectContaining({
+          communication_disabled_until: expect.any(String),
+        }),
+      }),
+    );
+  });
+
+  it("adds and removes roles", async () => {
+    const { rest, putMock, deleteMock } = makeRest();
+    putMock.mockResolvedValue({});
+    deleteMock.mockResolvedValue({});
+    await addRoleDiscord(
+      { guildId: "g1", userId: "u1", roleId: "r1" },
+      { rest, token: "t" },
+    );
+    await removeRoleDiscord(
+      { guildId: "g1", userId: "u1", roleId: "r1" },
+      { rest, token: "t" },
+    );
+    expect(putMock).toHaveBeenCalledWith(
+      Routes.guildMemberRole("g1", "u1", "r1"),
+    );
+    expect(deleteMock).toHaveBeenCalledWith(
+      Routes.guildMemberRole("g1", "u1", "r1"),
+    );
+  });
+
+  it("bans a member", async () => {
+    const { rest, putMock } = makeRest();
+    putMock.mockResolvedValue({});
+    await banMemberDiscord(
+      { guildId: "g1", userId: "u1", deleteMessageDays: 2 },
+      { rest, token: "t" },
+    );
+    expect(putMock).toHaveBeenCalledWith(
+      Routes.guildBan("g1", "u1"),
+      expect.objectContaining({ body: { delete_message_days: 2 } }),
+    );
+  });
+});
+
+describe("listGuildEmojisDiscord", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("lists emojis for a guild", async () => {
+    const { rest, getMock } = makeRest();
+    getMock.mockResolvedValue([{ id: "e1", name: "party" }]);
+    await listGuildEmojisDiscord("g1", { rest, token: "t" });
+    expect(getMock).toHaveBeenCalledWith(Routes.guildEmojis("g1"));
+  });
+});
+
+describe("sendStickerDiscord", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("sends sticker payloads", async () => {
+    const { rest, postMock } = makeRest();
+    postMock.mockResolvedValue({ id: "msg1", channel_id: "789" });
+    const res = await sendStickerDiscord("channel:789", ["123"], {
+      rest,
+      token: "t",
+      content: "hiya",
+    });
+    expect(res).toEqual({ messageId: "msg1", channelId: "789" });
+    expect(postMock).toHaveBeenCalledWith(
+      Routes.channelMessages("789"),
+      expect.objectContaining({
+        body: {
+          content: "hiya",
+          sticker_ids: ["123"],
+        },
+      }),
+    );
+  });
+});
+
+describe("sendPollDiscord", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("sends polls with answers", async () => {
+    const { rest, postMock } = makeRest();
+    postMock.mockResolvedValue({ id: "msg1", channel_id: "789" });
+    const res = await sendPollDiscord(
+      "channel:789",
+      {
+        question: "Lunch?",
+        answers: ["Pizza", "Sushi"],
+      },
+      {
+        rest,
+        token: "t",
+      },
+    );
+    expect(res).toEqual({ messageId: "msg1", channelId: "789" });
+    expect(postMock).toHaveBeenCalledWith(
+      Routes.channelMessages("789"),
+      expect.objectContaining({
+        body: expect.objectContaining({
+          poll: {
+            question: { text: "Lunch?" },
+            answers: [
+              { poll_media: { text: "Pizza" } },
+              { poll_media: { text: "Sushi" } },
+            ],
+            duration: 24,
+            allow_multiselect: false,
+            layout_type: 1,
+          },
+        }),
+      }),
+    );
+  });
+});

src/discord/send.ts

@@ -1,4 +1,16 @@
-import { REST, Routes } from "discord.js";
+import { PermissionsBitField, REST, Routes } from "discord.js";
+import { PollLayoutType } from "discord-api-types/payloads/v10";
+import type { RESTAPIPoll } from "discord-api-types/rest/v10";
+import type {
+  APIChannel,
+  APIGuild,
+  APIGuildMember,
+  APIGuildScheduledEvent,
+  APIMessage,
+  APIRole,
+  APIVoiceState,
+  RESTPostAPIGuildScheduledEventJSONBody,
+} from "discord-api-types/v10";
 
 import { chunkText } from "../auto-reply/chunk.js";
 import { loadConfig } from "../config/config.js";
@@ -6,6 +18,10 @@ import { loadWebMedia } from "../web/media.js";
 import { normalizeDiscordToken } from "./token.js";
 
 const DISCORD_TEXT_LIMIT = 2000;
+const DISCORD_MAX_STICKERS = 3;
+const DISCORD_POLL_MIN_ANSWERS = 2;
+const DISCORD_POLL_MAX_ANSWERS = 10;
+const DISCORD_POLL_MAX_DURATION_HOURS = 32 * 24;
 
 type DiscordRecipient =
   | {
@@ -30,11 +46,88 @@ export type DiscordSendResult = {
   channelId: string;
 };
 
+export type DiscordPollInput = {
+  question: string;
+  answers: string[];
+  allowMultiselect?: boolean;
+  durationHours?: number;
+};
+
 export type DiscordReactOpts = {
   token?: string;
   rest?: REST;
 };
 
+export type DiscordReactionUser = {
+  id: string;
+  username?: string;
+  tag?: string;
+};
+
+export type DiscordReactionSummary = {
+  emoji: { id?: string | null; name?: string | null; raw: string };
+  count: number;
+  users: DiscordReactionUser[];
+};
+
+export type DiscordPermissionsSummary = {
+  channelId: string;
+  guildId?: string;
+  permissions: string[];
+  raw: string;
+  isDm: boolean;
+};
+
+export type DiscordMessageQuery = {
+  limit?: number;
+  before?: string;
+  after?: string;
+  around?: string;
+};
+
+export type DiscordMessageEdit = {
+  content: string;
+};
+
+export type DiscordThreadCreate = {
+  name: string;
+  messageId?: string;
+  autoArchiveMinutes?: number;
+};
+
+export type DiscordThreadList = {
+  guildId: string;
+  channelId?: string;
+  includeArchived?: boolean;
+  before?: string;
+  limit?: number;
+};
+
+export type DiscordSearchQuery = {
+  guildId: string;
+  content: string;
+  channelIds?: string[];
+  authorIds?: string[];
+  limit?: number;
+};
+
+export type DiscordRoleChange = {
+  guildId: string;
+  userId: string;
+  roleId: string;
+};
+
+export type DiscordModerationTarget = {
+  guildId: string;
+  userId: string;
+  reason?: string;
+};
+
+export type DiscordTimeoutTarget = DiscordModerationTarget & {
+  durationMinutes?: number;
+  until?: string;
+};
+
 function resolveToken(explicit?: string) {
   const cfgToken = loadConfig().discord?.token;
   const token = normalizeDiscordToken(
@@ -56,7 +149,7 @@ function normalizeReactionEmoji(raw: string) {
   const customMatch = trimmed.match(/^<a?:([^:>]+):(\d+)>$/);
   const identifier = customMatch
     ? `${customMatch[1]}:${customMatch[2]}`
-    : trimmed;
+    : trimmed.replace(/[\uFE0E\uFE0F]/g, "");
   return encodeURIComponent(identifier);
 }
 
@@ -90,6 +183,49 @@ function parseRecipient(raw: string): DiscordRecipient {
   return { kind: "channel", id: trimmed };
 }
 
+function normalizeStickerIds(raw: string[]) {
+  const ids = raw.map((entry) => entry.trim()).filter(Boolean);
+  if (ids.length === 0) {
+    throw new Error("At least one sticker id is required");
+  }
+  if (ids.length > DISCORD_MAX_STICKERS) {
+    throw new Error("Discord supports up to 3 stickers per message");
+  }
+  return ids;
+}
+
+function normalizePollInput(input: DiscordPollInput): RESTAPIPoll {
+  const question = input.question.trim();
+  if (!question) {
+    throw new Error("Poll question is required");
+  }
+  const answers = (input.answers ?? [])
+    .map((answer) => answer.trim())
+    .filter(Boolean);
+  if (answers.length < DISCORD_POLL_MIN_ANSWERS) {
+    throw new Error("Polls require at least 2 answers");
+  }
+  if (answers.length > DISCORD_POLL_MAX_ANSWERS) {
+    throw new Error("Polls support up to 10 answers");
+  }
+  const durationRaw =
+    typeof input.durationHours === "number" &&
+    Number.isFinite(input.durationHours)
+      ? Math.floor(input.durationHours)
+      : 24;
+  const duration = Math.min(
+    Math.max(durationRaw, 1),
+    DISCORD_POLL_MAX_DURATION_HOURS,
+  );
+  return {
+    question: { text: question },
+    answers: answers.map((answer) => ({ poll_media: { text: answer } })),
+    duration,
+    allow_multiselect: input.allowMultiselect ?? false,
+    layout_type: PollLayoutType.Default,
+  };
+}
+
 async function resolveChannelId(
   rest: REST,
   recipient: DiscordRecipient,
@@ -176,6 +312,31 @@ async function sendDiscordMedia(
   return res;
 }
 
+function buildReactionIdentifier(emoji: {
+  id?: string | null;
+  name?: string | null;
+}) {
+  if (emoji.id && emoji.name) {
+    return `${emoji.name}:${emoji.id}`;
+  }
+  return emoji.name ?? "";
+}
+
+function formatReactionEmoji(emoji: {
+  id?: string | null;
+  name?: string | null;
+}) {
+  return buildReactionIdentifier(emoji);
+}
+
+async function fetchBotUserId(rest: REST) {
+  const me = (await rest.get(Routes.user("@me"))) as { id?: string };
+  if (!me?.id) {
+    throw new Error("Failed to resolve bot user id");
+  }
+  return me.id;
+}
+
 export async function sendMessageDiscord(
   to: string,
   text: string,
@@ -207,6 +368,52 @@ export async function sendMessageDiscord(
   };
 }
 
+export async function sendStickerDiscord(
+  to: string,
+  stickerIds: string[],
+  opts: DiscordSendOpts & { content?: string } = {},
+): Promise<DiscordSendResult> {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  const recipient = parseRecipient(to);
+  const { channelId } = await resolveChannelId(rest, recipient);
+  const content = opts.content?.trim();
+  const stickers = normalizeStickerIds(stickerIds);
+  const res = (await rest.post(Routes.channelMessages(channelId), {
+    body: {
+      content: content || undefined,
+      sticker_ids: stickers,
+    },
+  })) as { id: string; channel_id: string };
+  return {
+    messageId: res.id ? String(res.id) : "unknown",
+    channelId: String(res.channel_id ?? channelId),
+  };
+}
+
+export async function sendPollDiscord(
+  to: string,
+  poll: DiscordPollInput,
+  opts: DiscordSendOpts & { content?: string } = {},
+): Promise<DiscordSendResult> {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  const recipient = parseRecipient(to);
+  const { channelId } = await resolveChannelId(rest, recipient);
+  const content = opts.content?.trim();
+  const payload = normalizePollInput(poll);
+  const res = (await rest.post(Routes.channelMessages(channelId), {
+    body: {
+      content: content || undefined,
+      poll: payload,
+    },
+  })) as { id: string; channel_id: string };
+  return {
+    messageId: res.id ? String(res.id) : "unknown",
+    channelId: String(res.channel_id ?? channelId),
+  };
+}
+
 export async function reactMessageDiscord(
   channelId: string,
   messageId: string,
@@ -216,6 +423,428 @@ export async function reactMessageDiscord(
   const token = resolveToken(opts.token);
   const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
   const encoded = normalizeReactionEmoji(emoji);
-  await rest.put(Routes.channelMessageReaction(channelId, messageId, encoded));
+  await rest.put(
+    Routes.channelMessageOwnReaction(channelId, messageId, encoded),
+  );
+  return { ok: true };
+}
+
+export async function fetchReactionsDiscord(
+  channelId: string,
+  messageId: string,
+  opts: DiscordReactOpts & { limit?: number } = {},
+): Promise<DiscordReactionSummary[]> {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  const message = (await rest.get(
+    Routes.channelMessage(channelId, messageId),
+  )) as {
+    reactions?: Array<{
+      count: number;
+      emoji: { id?: string | null; name?: string | null };
+    }>;
+  };
+  const reactions = message.reactions ?? [];
+  if (reactions.length === 0) return [];
+  const limit =
+    typeof opts.limit === "number" && Number.isFinite(opts.limit)
+      ? Math.min(Math.max(Math.floor(opts.limit), 1), 100)
+      : 100;
+
+  const summaries: DiscordReactionSummary[] = [];
+  for (const reaction of reactions) {
+    const identifier = buildReactionIdentifier(reaction.emoji);
+    if (!identifier) continue;
+    const encoded = encodeURIComponent(identifier);
+    const users = (await rest.get(
+      Routes.channelMessageReaction(channelId, messageId, encoded),
+      { query: new URLSearchParams({ limit: String(limit) }) },
+    )) as Array<{ id: string; username?: string; discriminator?: string }>;
+    summaries.push({
+      emoji: {
+        id: reaction.emoji.id ?? null,
+        name: reaction.emoji.name ?? null,
+        raw: formatReactionEmoji(reaction.emoji),
+      },
+      count: reaction.count,
+      users: users.map((user) => ({
+        id: user.id,
+        username: user.username,
+        tag:
+          user.username && user.discriminator
+            ? `${user.username}#${user.discriminator}`
+            : user.username,
+      })),
+    });
+  }
+  return summaries;
+}
+
+export async function fetchChannelPermissionsDiscord(
+  channelId: string,
+  opts: DiscordReactOpts = {},
+): Promise<DiscordPermissionsSummary> {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  const channel = (await rest.get(Routes.channel(channelId))) as APIChannel;
+  const guildId = "guild_id" in channel ? channel.guild_id : undefined;
+  if (!guildId) {
+    return {
+      channelId,
+      permissions: [],
+      raw: "0",
+      isDm: true,
+    };
+  }
+
+  const botId = await fetchBotUserId(rest);
+  const [guild, member] = await Promise.all([
+    rest.get(Routes.guild(guildId)) as Promise<APIGuild>,
+    rest.get(Routes.guildMember(guildId, botId)) as Promise<APIGuildMember>,
+  ]);
+
+  const rolesById = new Map<string, APIRole>(
+    (guild.roles ?? []).map((role) => [role.id, role]),
+  );
+  const base = new PermissionsBitField();
+  const everyoneRole = rolesById.get(guildId);
+  if (everyoneRole?.permissions) {
+    base.add(BigInt(everyoneRole.permissions));
+  }
+  for (const roleId of member.roles ?? []) {
+    const role = rolesById.get(roleId);
+    if (role?.permissions) {
+      base.add(BigInt(role.permissions));
+    }
+  }
+
+  const permissions = new PermissionsBitField(base);
+  const overwrites =
+    "permission_overwrites" in channel
+      ? (channel.permission_overwrites ?? [])
+      : [];
+  for (const overwrite of overwrites) {
+    if (overwrite.id === guildId) {
+      permissions.remove(BigInt(overwrite.deny ?? "0"));
+      permissions.add(BigInt(overwrite.allow ?? "0"));
+    }
+  }
+  for (const overwrite of overwrites) {
+    if (member.roles?.includes(overwrite.id)) {
+      permissions.remove(BigInt(overwrite.deny ?? "0"));
+      permissions.add(BigInt(overwrite.allow ?? "0"));
+    }
+  }
+  for (const overwrite of overwrites) {
+    if (overwrite.id === botId) {
+      permissions.remove(BigInt(overwrite.deny ?? "0"));
+      permissions.add(BigInt(overwrite.allow ?? "0"));
+    }
+  }
+
+  return {
+    channelId,
+    guildId,
+    permissions: permissions.toArray(),
+    raw: permissions.bitfield.toString(),
+    isDm: false,
+  };
+}
+
+export async function readMessagesDiscord(
+  channelId: string,
+  query: DiscordMessageQuery = {},
+  opts: DiscordReactOpts = {},
+): Promise<APIMessage[]> {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  const limit =
+    typeof query.limit === "number" && Number.isFinite(query.limit)
+      ? Math.min(Math.max(Math.floor(query.limit), 1), 100)
+      : undefined;
+  const params = new URLSearchParams();
+  if (limit) params.set("limit", String(limit));
+  if (query.before) params.set("before", query.before);
+  if (query.after) params.set("after", query.after);
+  if (query.around) params.set("around", query.around);
+  return (await rest.get(Routes.channelMessages(channelId), {
+    query: params,
+  })) as APIMessage[];
+}
+
+export async function editMessageDiscord(
+  channelId: string,
+  messageId: string,
+  payload: DiscordMessageEdit,
+  opts: DiscordReactOpts = {},
+): Promise<APIMessage> {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  return (await rest.patch(Routes.channelMessage(channelId, messageId), {
+    body: { content: payload.content },
+  })) as APIMessage;
+}
+
+export async function deleteMessageDiscord(
+  channelId: string,
+  messageId: string,
+  opts: DiscordReactOpts = {},
+) {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  await rest.delete(Routes.channelMessage(channelId, messageId));
+  return { ok: true };
+}
+
+export async function pinMessageDiscord(
+  channelId: string,
+  messageId: string,
+  opts: DiscordReactOpts = {},
+) {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  await rest.put(Routes.channelPin(channelId, messageId));
+  return { ok: true };
+}
+
+export async function unpinMessageDiscord(
+  channelId: string,
+  messageId: string,
+  opts: DiscordReactOpts = {},
+) {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  await rest.delete(Routes.channelPin(channelId, messageId));
+  return { ok: true };
+}
+
+export async function listPinsDiscord(
+  channelId: string,
+  opts: DiscordReactOpts = {},
+): Promise<APIMessage[]> {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  return (await rest.get(Routes.channelPins(channelId))) as APIMessage[];
+}
+
+export async function createThreadDiscord(
+  channelId: string,
+  payload: DiscordThreadCreate,
+  opts: DiscordReactOpts = {},
+) {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  const body: Record<string, unknown> = { name: payload.name };
+  if (payload.autoArchiveMinutes) {
+    body.auto_archive_duration = payload.autoArchiveMinutes;
+  }
+  const route = Routes.threads(channelId, payload.messageId);
+  return await rest.post(route, { body });
+}
+
+export async function listThreadsDiscord(
+  payload: DiscordThreadList,
+  opts: DiscordReactOpts = {},
+) {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  if (payload.includeArchived) {
+    if (!payload.channelId) {
+      throw new Error("channelId required to list archived threads");
+    }
+    const params = new URLSearchParams();
+    if (payload.before) params.set("before", payload.before);
+    if (payload.limit) params.set("limit", String(payload.limit));
+    return await rest.get(Routes.channelThreads(payload.channelId, "public"), {
+      query: params,
+    });
+  }
+  return await rest.get(Routes.guildActiveThreads(payload.guildId));
+}
+
+export async function searchMessagesDiscord(
+  query: DiscordSearchQuery,
+  opts: DiscordReactOpts = {},
+) {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  const params = new URLSearchParams();
+  params.set("content", query.content);
+  if (query.channelIds?.length) {
+    for (const channelId of query.channelIds) {
+      params.append("channel_id", channelId);
+    }
+  }
+  if (query.authorIds?.length) {
+    for (const authorId of query.authorIds) {
+      params.append("author_id", authorId);
+    }
+  }
+  if (query.limit) {
+    const limit = Math.min(Math.max(Math.floor(query.limit), 1), 25);
+    params.set("limit", String(limit));
+  }
+  return await rest.get(`/guilds/${query.guildId}/messages/search`, {
+    query: params,
+  });
+}
+
+export async function listGuildEmojisDiscord(
+  guildId: string,
+  opts: DiscordReactOpts = {},
+) {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  return await rest.get(Routes.guildEmojis(guildId));
+}
+
+export async function fetchMemberInfoDiscord(
+  guildId: string,
+  userId: string,
+  opts: DiscordReactOpts = {},
+): Promise<APIGuildMember> {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  return (await rest.get(
+    Routes.guildMember(guildId, userId),
+  )) as APIGuildMember;
+}
+
+export async function fetchRoleInfoDiscord(
+  guildId: string,
+  opts: DiscordReactOpts = {},
+): Promise<APIRole[]> {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  return (await rest.get(Routes.guildRoles(guildId))) as APIRole[];
+}
+
+export async function addRoleDiscord(
+  payload: DiscordRoleChange,
+  opts: DiscordReactOpts = {},
+) {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  await rest.put(
+    Routes.guildMemberRole(payload.guildId, payload.userId, payload.roleId),
+  );
+  return { ok: true };
+}
+
+export async function removeRoleDiscord(
+  payload: DiscordRoleChange,
+  opts: DiscordReactOpts = {},
+) {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  await rest.delete(
+    Routes.guildMemberRole(payload.guildId, payload.userId, payload.roleId),
+  );
+  return { ok: true };
+}
+
+export async function fetchChannelInfoDiscord(
+  channelId: string,
+  opts: DiscordReactOpts = {},
+): Promise<APIChannel> {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  return (await rest.get(Routes.channel(channelId))) as APIChannel;
+}
+
+export async function listGuildChannelsDiscord(
+  guildId: string,
+  opts: DiscordReactOpts = {},
+): Promise<APIChannel[]> {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  return (await rest.get(Routes.guildChannels(guildId))) as APIChannel[];
+}
+
+export async function fetchVoiceStatusDiscord(
+  guildId: string,
+  userId: string,
+  opts: DiscordReactOpts = {},
+): Promise<APIVoiceState> {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  return (await rest.get(
+    Routes.guildVoiceState(guildId, userId),
+  )) as APIVoiceState;
+}
+
+export async function listScheduledEventsDiscord(
+  guildId: string,
+  opts: DiscordReactOpts = {},
+): Promise<APIGuildScheduledEvent[]> {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  return (await rest.get(
+    Routes.guildScheduledEvents(guildId),
+  )) as APIGuildScheduledEvent[];
+}
+
+export async function createScheduledEventDiscord(
+  guildId: string,
+  payload: RESTPostAPIGuildScheduledEventJSONBody,
+  opts: DiscordReactOpts = {},
+): Promise<APIGuildScheduledEvent> {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  return (await rest.post(Routes.guildScheduledEvents(guildId), {
+    body: payload,
+  })) as APIGuildScheduledEvent;
+}
+
+export async function timeoutMemberDiscord(
+  payload: DiscordTimeoutTarget,
+  opts: DiscordReactOpts = {},
+): Promise<APIGuildMember> {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  let until = payload.until;
+  if (!until && payload.durationMinutes) {
+    const ms = payload.durationMinutes * 60 * 1000;
+    until = new Date(Date.now() + ms).toISOString();
+  }
+  return (await rest.patch(
+    Routes.guildMember(payload.guildId, payload.userId),
+    {
+      body: { communication_disabled_until: until ?? null },
+      reason: payload.reason,
+    },
+  )) as APIGuildMember;
+}
+
+export async function kickMemberDiscord(
+  payload: DiscordModerationTarget,
+  opts: DiscordReactOpts = {},
+) {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  await rest.delete(Routes.guildMember(payload.guildId, payload.userId), {
+    reason: payload.reason,
+  });
+  return { ok: true };
+}
+
+export async function banMemberDiscord(
+  payload: DiscordModerationTarget & { deleteMessageDays?: number },
+  opts: DiscordReactOpts = {},
+) {
+  const token = resolveToken(opts.token);
+  const rest = opts.rest ?? new REST({ version: "10" }).setToken(token);
+  const deleteMessageDays =
+    typeof payload.deleteMessageDays === "number" &&
+    Number.isFinite(payload.deleteMessageDays)
+      ? Math.min(Math.max(Math.floor(payload.deleteMessageDays), 0), 7)
+      : undefined;
+  await rest.put(Routes.guildBan(payload.guildId, payload.userId), {
+    body:
+      deleteMessageDays !== undefined
+        ? { delete_message_days: deleteMessageDays }
+        : undefined,
+    reason: payload.reason,
+  });
   return { ok: true };
 }