@kodelyth/discord 2026.5.39 → 2026.5.42

package/src/resolve-channels.test.ts

@@ -0,0 +1,341 @@
+import { withFetchPreconnect } from "klaw/plugin-sdk/test-env";
+import { describe, expect, it } from "vitest";
+import { resolveDiscordChannelAllowlist } from "./resolve-channels.js";
+import { jsonResponse, urlToString } from "./test-http-helpers.js";
+
+describe("resolveDiscordChannelAllowlist", () => {
+  type DiscordChannel = { id: string; name: string; guild_id: string; type: number };
+
+  async function resolveWithChannelLookup(params: {
+    guilds: Array<{ id: string; name: string }>;
+    channel: DiscordChannel;
+    entry: string;
+  }) {
+    const fetcher = withFetchPreconnect(async (input: RequestInfo | URL) => {
+      const url = urlToString(input);
+      if (url.endsWith("/users/@me/guilds")) {
+        return jsonResponse(params.guilds);
+      }
+      if (url.endsWith(`/channels/${params.channel.id}`)) {
+        return jsonResponse(params.channel);
+      }
+      return new Response("not found", { status: 404 });
+    });
+    return resolveDiscordChannelAllowlist({
+      token: "test",
+      entries: [params.entry],
+      fetcher,
+    });
+  }
+
+  async function resolveGuild111Entry2024(params: {
+    channelLookup: () => Response;
+    guildChannels?: DiscordChannel[];
+  }) {
+    const fetcher = withFetchPreconnect(async (input: RequestInfo | URL) => {
+      const url = urlToString(input);
+      if (url.endsWith("/users/@me/guilds")) {
+        return jsonResponse([{ id: "111", name: "Test Server" }]);
+      }
+      if (url.endsWith("/channels/2024")) {
+        return params.channelLookup();
+      }
+      if (url.endsWith("/guilds/111/channels")) {
+        return jsonResponse(
+          params.guildChannels ?? [
+            { id: "c1", name: "2024", guild_id: "111", type: 0 },
+            { id: "c2", name: "general", guild_id: "111", type: 0 },
+          ],
+        );
+      }
+      return new Response("not found", { status: 404 });
+    });
+
+    return resolveDiscordChannelAllowlist({
+      token: "test",
+      entries: ["111/2024"],
+      fetcher,
+    });
+  }
+
+  function expectUnresolved1112024(
+    res: Awaited<ReturnType<typeof resolveDiscordChannelAllowlist>>,
+  ) {
+    expect(res[0]?.resolved).toBe(false);
+    expect(res[0]?.channelId).toBe("2024");
+    expect(res[0]?.guildId).toBe("111");
+  }
+
+  it("resolves guild/channel by name", async () => {
+    const fetcher = withFetchPreconnect(async (input: RequestInfo | URL) => {
+      const url = urlToString(input);
+      if (url.endsWith("/users/@me/guilds")) {
+        return jsonResponse([{ id: "g1", name: "My Guild" }]);
+      }
+      if (url.endsWith("/guilds/g1/channels")) {
+        return jsonResponse([
+          { id: "c1", name: "general", guild_id: "g1", type: 0 },
+          { id: "c2", name: "random", guild_id: "g1", type: 0 },
+        ]);
+      }
+      return new Response("not found", { status: 404 });
+    });
+
+    const res = await resolveDiscordChannelAllowlist({
+      token: "test",
+      entries: ["My Guild/general"],
+      fetcher,
+    });
+
+    expect(res[0]?.resolved).toBe(true);
+    expect(res[0]?.guildId).toBe("g1");
+    expect(res[0]?.channelId).toBe("c1");
+  });
+
+  it("resolves channel id to guild", async () => {
+    const fetcher = withFetchPreconnect(async (input: RequestInfo | URL) => {
+      const url = urlToString(input);
+      if (url.endsWith("/users/@me/guilds")) {
+        return jsonResponse([{ id: "g1", name: "Guild One" }]);
+      }
+      if (url.endsWith("/channels/123")) {
+        return jsonResponse({ id: "123", name: "general", guild_id: "g1", type: 0 });
+      }
+      return new Response("not found", { status: 404 });
+    });
+
+    const res = await resolveDiscordChannelAllowlist({
+      token: "test",
+      entries: ["123"],
+      fetcher,
+    });
+
+    expect(res[0]?.resolved).toBe(true);
+    expect(res[0]?.guildId).toBe("g1");
+    expect(res[0]?.channelId).toBe("123");
+  });
+
+  it("resolves guildId/channelId entries via channel lookup", async () => {
+    const res = await resolveWithChannelLookup({
+      guilds: [{ id: "111", name: "Guild One" }],
+      channel: { id: "222", name: "general", guild_id: "111", type: 0 },
+      entry: "111/222",
+    });
+
+    expect(res[0]).toEqual({
+      input: "111/222",
+      resolved: true,
+      guildId: "111",
+      guildName: "Guild One",
+      channelId: "222",
+      channelName: "general",
+      archived: undefined,
+    });
+  });
+
+  it("reports unresolved when channel id belongs to a different guild", async () => {
+    const res = await resolveWithChannelLookup({
+      guilds: [
+        { id: "111", name: "Guild One" },
+        { id: "333", name: "Guild Two" },
+      ],
+      channel: { id: "222", name: "general", guild_id: "333", type: 0 },
+      entry: "111/222",
+    });
+
+    expect(res[0]).toEqual({
+      input: "111/222",
+      resolved: false,
+      guildId: "111",
+      guildName: "Guild One",
+      channelId: "222",
+      channelName: "general",
+      note: "channel belongs to guild Guild Two",
+    });
+  });
+
+  it("resolves numeric channel id when guild is specified by name", async () => {
+    const fetcher = withFetchPreconnect(async (input: RequestInfo | URL) => {
+      const url = urlToString(input);
+      if (url.endsWith("/users/@me/guilds")) {
+        return jsonResponse([{ id: "111", name: "My Guild" }]);
+      }
+      if (url.endsWith("/guilds/111/channels")) {
+        return jsonResponse([{ id: "444555666", name: "general", guild_id: "111", type: 0 }]);
+      }
+      return new Response("not found", { status: 404 });
+    });
+
+    const res = await resolveDiscordChannelAllowlist({
+      token: "test",
+      entries: ["My Guild/444555666"],
+      fetcher,
+    });
+
+    expect(res[0]?.resolved).toBe(true);
+    expect(res[0]?.channelId).toBe("444555666");
+  });
+
+  it("marks invalid numeric channelId as unresolved without aborting batch", async () => {
+    const fetcher = withFetchPreconnect(async (input: RequestInfo | URL) => {
+      const url = urlToString(input);
+      if (url.endsWith("/users/@me/guilds")) {
+        return jsonResponse([{ id: "111", name: "Test Server" }]);
+      }
+      if (url.endsWith("/guilds/111/channels")) {
+        return jsonResponse([{ id: "444555666", name: "general", guild_id: "111", type: 0 }]);
+      }
+      if (url.endsWith("/channels/999000111")) {
+        return new Response("not found", { status: 404 });
+      }
+      if (url.endsWith("/channels/444555666")) {
+        return jsonResponse({
+          id: "444555666",
+          name: "general",
+          guild_id: "111",
+          type: 0,
+        });
+      }
+      return new Response("not found", { status: 404 });
+    });
+
+    const res = await resolveDiscordChannelAllowlist({
+      token: "test",
+      entries: ["111/999000111", "111/444555666"],
+      fetcher,
+    });
+
+    expect(res).toHaveLength(2);
+    expect(res[0]?.resolved).toBe(false);
+    expect(res[0]?.channelId).toBe("999000111");
+    expect(res[0]?.guildId).toBe("111");
+    expect(res[1]?.resolved).toBe(true);
+    expect(res[1]?.channelId).toBe("444555666");
+  });
+
+  it("treats 403 channel lookup as unresolved without aborting batch", async () => {
+    const fetcher = withFetchPreconnect(async (input: RequestInfo | URL) => {
+      const url = urlToString(input);
+      if (url.endsWith("/users/@me/guilds")) {
+        return jsonResponse([{ id: "111", name: "Test Server" }]);
+      }
+      if (url.endsWith("/guilds/111/channels")) {
+        return jsonResponse([{ id: "444555666", name: "general", guild_id: "111", type: 0 }]);
+      }
+      if (url.endsWith("/channels/777888999")) {
+        return new Response("Missing Access", { status: 403 });
+      }
+      if (url.endsWith("/channels/444555666")) {
+        return jsonResponse({
+          id: "444555666",
+          name: "general",
+          guild_id: "111",
+          type: 0,
+        });
+      }
+      return new Response("not found", { status: 404 });
+    });
+
+    const res = await resolveDiscordChannelAllowlist({
+      token: "test",
+      entries: ["111/777888999", "111/444555666"],
+      fetcher,
+    });
+
+    expect(res).toHaveLength(2);
+    expect(res[0]?.resolved).toBe(false);
+    expect(res[0]?.channelId).toBe("777888999");
+    expect(res[0]?.guildId).toBe("111");
+    expect(res[1]?.resolved).toBe(true);
+    expect(res[1]?.channelId).toBe("444555666");
+  });
+
+  it("falls back to name matching when numeric channel name is not a valid ID", async () => {
+    const res = await resolveGuild111Entry2024({
+      channelLookup: () => new Response("not found", { status: 404 }),
+    });
+
+    expect(res[0]?.resolved).toBe(true);
+    expect(res[0]?.guildId).toBe("111");
+    expect(res[0]?.channelId).toBe("c1");
+    expect(res[0]?.channelName).toBe("2024");
+  });
+
+  it("does not fall back to name matching when channel lookup returns 403", async () => {
+    const res = await resolveGuild111Entry2024({
+      channelLookup: () => new Response("Missing Access", { status: 403 }),
+    });
+
+    expectUnresolved1112024(res);
+  });
+
+  it("does not fall back to name matching when channel payload is malformed", async () => {
+    const res = await resolveGuild111Entry2024({
+      channelLookup: () => jsonResponse({ id: "2024", name: "unknown", type: 0 }),
+      guildChannels: [{ id: "c1", name: "2024", guild_id: "111", type: 0 }],
+    });
+
+    expectUnresolved1112024(res);
+  });
+
+  it("resolves guild: prefixed id as guild (not channel)", async () => {
+    const fetcher = withFetchPreconnect(async (input: RequestInfo | URL) => {
+      const url = urlToString(input);
+      if (url.endsWith("/users/@me/guilds")) {
+        return jsonResponse([{ id: "111222333444555666", name: "Guild One" }]);
+      }
+      // Should never be called — if it is, the ID was misrouted as a channel
+      if (url.includes("/channels/")) {
+        throw new Error("guild id was incorrectly routed to /channels/");
+      }
+      return new Response("not found", { status: 404 });
+    });
+
+    const res = await resolveDiscordChannelAllowlist({
+      token: "test",
+      entries: ["guild:111222333444555666"],
+      fetcher,
+    });
+
+    expect(res[0]?.resolved).toBe(true);
+    expect(res[0]?.guildId).toBe("111222333444555666");
+    expect(res[0]?.channelId).toBeUndefined();
+  });
+
+  it("bare numeric guild id is misrouted as channel id (regression)", async () => {
+    // Demonstrates why provider.ts must prefix guild-only entries with "guild:"
+    // In reality, Discord returns 404 when a guild ID is sent to /channels/<guildId>,
+    // which causes fetchDiscord to throw and the entire resolver to crash.
+    const fetcher = withFetchPreconnect(async (input: RequestInfo | URL) => {
+      const url = urlToString(input);
+      if (url.endsWith("/users/@me/guilds")) {
+        return jsonResponse([{ id: "999", name: "My Server" }]);
+      }
+      // Guild ID hitting /channels/ returns 404 — just like real Discord
+      if (url.includes("/channels/")) {
+        return new Response(JSON.stringify({ message: "Unknown Channel" }), { status: 404 });
+      }
+      return new Response("not found", { status: 404 });
+    });
+
+    // Without the guild: prefix, a bare numeric string hits /channels/999 → 404 → unresolved
+    const res = await resolveDiscordChannelAllowlist({
+      token: "test",
+      entries: ["999"],
+      fetcher,
+    });
+    expect(res[0]?.resolved).toBe(false);
+    expect(res[0]?.channelId).toBe("999");
+    expect(res[0]?.guildId).toBeUndefined();
+
+    // With the guild: prefix, it correctly resolves as a guild (never hits /channels/)
+    const res2 = await resolveDiscordChannelAllowlist({
+      token: "test",
+      entries: ["guild:999"],
+      fetcher,
+    });
+    expect(res2[0]?.resolved).toBe(true);
+    expect(res2[0]?.guildId).toBe("999");
+    expect(res2[0]?.channelId).toBeUndefined();
+  });
+});

package/src/resolve-channels.ts

@@ -0,0 +1,369 @@
+import { DiscordApiError, fetchDiscord } from "./api.js";
+import { listGuilds } from "./guilds.js";
+import { normalizeDiscordSlug } from "./monitor/allow-list.js";
+import {
+  buildDiscordUnresolvedResults,
+  filterDiscordGuilds,
+  resolveDiscordAllowlistToken,
+} from "./resolve-allowlist-common.js";
+
+type DiscordChannelSummary = {
+  id: string;
+  name: string;
+  guildId: string;
+  type?: number;
+  archived?: boolean;
+};
+
+type DiscordChannelPayload = {
+  id?: string;
+  name?: string;
+  type?: number;
+  guild_id?: string;
+  thread_metadata?: { archived?: boolean };
+};
+
+export type DiscordChannelResolution = {
+  input: string;
+  resolved: boolean;
+  guildId?: string;
+  guildName?: string;
+  channelId?: string;
+  channelName?: string;
+  archived?: boolean;
+  note?: string;
+};
+
+function parseDiscordChannelInput(raw: string): {
+  guild?: string;
+  channel?: string;
+  channelId?: string;
+  guildId?: string;
+  guildOnly?: boolean;
+} {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return {};
+  }
+  const mention = trimmed.match(/^<#(\d+)>$/);
+  if (mention) {
+    return { channelId: mention[1] };
+  }
+  const channelPrefix = trimmed.match(/^(?:channel:|discord:)?(\d+)$/i);
+  if (channelPrefix) {
+    return { channelId: channelPrefix[1] };
+  }
+  const guildPrefix = trimmed.match(/^(?:guild:|server:)?(\d+)$/i);
+  if (guildPrefix && !trimmed.includes("/") && !trimmed.includes("#")) {
+    return { guildId: guildPrefix[1], guildOnly: true };
+  }
+  const split = trimmed.includes("/") ? trimmed.split("/") : trimmed.split("#");
+  if (split.length >= 2) {
+    const guild = split[0]?.trim();
+    const channel = split.slice(1).join("#").trim();
+    if (!channel) {
+      return guild ? { guild: guild.trim(), guildOnly: true } : {};
+    }
+    if (guild && /^\d+$/.test(guild)) {
+      if (/^\d+$/.test(channel)) {
+        return { guildId: guild, channelId: channel };
+      }
+      return { guildId: guild, channel };
+    }
+    return { guild, channel };
+  }
+  return { guild: trimmed, guildOnly: true };
+}
+
+async function listGuildChannels(
+  token: string,
+  fetcher: typeof fetch,
+  guildId: string,
+): Promise<DiscordChannelSummary[]> {
+  const raw = await fetchDiscord<DiscordChannelPayload[]>(
+    `/guilds/${guildId}/channels`,
+    token,
+    fetcher,
+  );
+  return raw
+    .map((channel) => {
+      const archived = channel.thread_metadata?.archived;
+      return {
+        id: typeof channel.id === "string" ? channel.id : "",
+        name: typeof channel.name === "string" ? channel.name : "",
+        guildId,
+        type: channel.type,
+        archived,
+      };
+    })
+    .filter((channel) => Boolean(channel.id) && Boolean(channel.name));
+}
+
+type FetchChannelResult =
+  | { status: "found"; channel: DiscordChannelSummary }
+  | { status: "not-found" }
+  | { status: "forbidden" }
+  | { status: "invalid" };
+
+async function fetchChannel(
+  token: string,
+  fetcher: typeof fetch,
+  channelId: string,
+): Promise<FetchChannelResult> {
+  let raw: DiscordChannelPayload;
+  try {
+    raw = await fetchDiscord<DiscordChannelPayload>(`/channels/${channelId}`, token, fetcher);
+  } catch (err) {
+    if (err instanceof DiscordApiError && err.status === 403) {
+      return { status: "forbidden" };
+    }
+    if (err instanceof DiscordApiError && err.status === 404) {
+      return { status: "not-found" };
+    }
+    throw err;
+  }
+  if (!raw || typeof raw.guild_id !== "string" || typeof raw.id !== "string") {
+    return { status: "invalid" };
+  }
+  return {
+    status: "found",
+    channel: {
+      id: raw.id,
+      name: typeof raw.name === "string" ? raw.name : "",
+      guildId: raw.guild_id,
+      type: raw.type,
+    },
+  };
+}
+
+function preferActiveMatch(candidates: DiscordChannelSummary[]): DiscordChannelSummary | undefined {
+  if (candidates.length === 0) {
+    return undefined;
+  }
+  const scored = candidates.map((channel) => {
+    const isThread = channel.type === 11 || channel.type === 12;
+    const archived = Boolean(channel.archived);
+    const score = (archived ? 0 : 2) + (isThread ? 0 : 1);
+    return { channel, score };
+  });
+  scored.sort((a, b) => b.score - a.score);
+  return scored[0]?.channel ?? candidates[0];
+}
+
+export async function resolveDiscordChannelAllowlist(params: {
+  token: string;
+  entries: string[];
+  fetcher?: typeof fetch;
+}): Promise<DiscordChannelResolution[]> {
+  const token = resolveDiscordAllowlistToken(params.token);
+  if (!token) {
+    return buildDiscordUnresolvedResults(params.entries, (input) => ({
+      input,
+      resolved: false,
+    }));
+  }
+  const fetcher = params.fetcher ?? fetch;
+  const guilds = await listGuilds(token, fetcher);
+  const channelsByGuild = new Map<string, Promise<DiscordChannelSummary[]>>();
+  const getChannels = (guildId: string) => {
+    const existing = channelsByGuild.get(guildId);
+    if (existing) {
+      return existing;
+    }
+    const promise = listGuildChannels(token, fetcher, guildId);
+    channelsByGuild.set(guildId, promise);
+    return promise;
+  };
+
+  const results: DiscordChannelResolution[] = [];
+
+  for (const input of params.entries) {
+    const parsed = parseDiscordChannelInput(input);
+    if (parsed.guildOnly) {
+      const guild = filterDiscordGuilds(guilds, {
+        guildId: parsed.guildId,
+        guildName: parsed.guild,
+      })[0];
+      if (guild) {
+        results.push({
+          input,
+          resolved: true,
+          guildId: guild.id,
+          guildName: guild.name,
+        });
+      } else {
+        results.push({
+          input,
+          resolved: false,
+          guildId: parsed.guildId,
+          guildName: parsed.guild,
+        });
+      }
+      continue;
+    }
+
+    if (parsed.channelId) {
+      const channelId = parsed.channelId;
+      const result = await fetchChannel(token, fetcher, channelId);
+      if (result.status === "found") {
+        const channel = result.channel;
+        if (parsed.guildId && parsed.guildId !== channel.guildId) {
+          const expectedGuild = guilds.find((entry) => entry.id === parsed.guildId);
+          const actualGuild = guilds.find((entry) => entry.id === channel.guildId);
+          results.push({
+            input,
+            resolved: false,
+            guildId: parsed.guildId,
+            guildName: expectedGuild?.name,
+            channelId,
+            channelName: channel.name,
+            note: actualGuild?.name
+              ? `channel belongs to guild ${actualGuild.name}`
+              : "channel belongs to a different guild",
+          });
+          continue;
+        }
+        const guild = guilds.find((entry) => entry.id === channel.guildId);
+        results.push({
+          input,
+          resolved: true,
+          guildId: channel.guildId,
+          guildName: guild?.name,
+          channelId: channel.id,
+          channelName: channel.name,
+          archived: channel.archived,
+        });
+        continue;
+      }
+
+      if (result.status === "not-found" && parsed.guildId) {
+        const guild = guilds.find((entry) => entry.id === parsed.guildId);
+        if (guild) {
+          const channels = await getChannels(guild.id);
+          const matches = channels.filter(
+            (channel) => normalizeDiscordSlug(channel.name) === normalizeDiscordSlug(channelId),
+          );
+          const match = preferActiveMatch(matches);
+          if (match) {
+            results.push({
+              input,
+              resolved: true,
+              guildId: guild.id,
+              guildName: guild.name,
+              channelId: match.id,
+              channelName: match.name,
+              archived: match.archived,
+            });
+            continue;
+          }
+        }
+      }
+
+      results.push({
+        input,
+        resolved: false,
+        guildId: parsed.guildId,
+        channelId,
+      });
+      continue;
+    }
+
+    if (parsed.guildId || parsed.guild) {
+      const guild = filterDiscordGuilds(guilds, {
+        guildId: parsed.guildId,
+        guildName: parsed.guild,
+      })[0];
+      const channelQuery = parsed.channel?.trim();
+      if (!guild || !channelQuery) {
+        results.push({
+          input,
+          resolved: false,
+          guildId: parsed.guildId,
+          guildName: parsed.guild,
+          channelName: channelQuery ?? parsed.channel,
+        });
+        continue;
+      }
+      const channels = await getChannels(guild.id);
+      const normalizedChannelQuery = normalizeDiscordSlug(channelQuery);
+      const isNumericId = /^\d+$/.test(channelQuery);
+      let matches = channels.filter((channel) =>
+        isNumericId
+          ? channel.id === channelQuery
+          : normalizeDiscordSlug(channel.name) === normalizedChannelQuery,
+      );
+      if (isNumericId && matches.length === 0) {
+        matches = channels.filter(
+          (channel) => normalizeDiscordSlug(channel.name) === normalizedChannelQuery,
+        );
+      }
+      const match = preferActiveMatch(matches);
+      if (match) {
+        results.push({
+          input,
+          resolved: true,
+          guildId: guild.id,
+          guildName: guild.name,
+          channelId: match.id,
+          channelName: match.name,
+          archived: match.archived,
+        });
+      } else {
+        results.push({
+          input,
+          resolved: false,
+          guildId: guild.id,
+          guildName: guild.name,
+          channelName: parsed.channel,
+          note: `channel not found in guild ${guild.name}`,
+        });
+      }
+      continue;
+    }
+
+    const channelName = input.trim().replace(/^#/, "");
+    if (!channelName) {
+      results.push({
+        input,
+        resolved: false,
+        channelName: channelName,
+      });
+      continue;
+    }
+    const candidates: DiscordChannelSummary[] = [];
+    for (const guild of guilds) {
+      const channels = await getChannels(guild.id);
+      for (const channel of channels) {
+        if (normalizeDiscordSlug(channel.name) === normalizeDiscordSlug(channelName)) {
+          candidates.push(channel);
+        }
+      }
+    }
+    const match = preferActiveMatch(candidates);
+    if (match) {
+      const guild = guilds.find((entry) => entry.id === match.guildId);
+      results.push({
+        input,
+        resolved: true,
+        guildId: match.guildId,
+        guildName: guild?.name,
+        channelId: match.id,
+        channelName: match.name,
+        archived: match.archived,
+        note:
+          candidates.length > 1 && guild?.name
+            ? `matched multiple; chose ${guild.name}`
+            : undefined,
+      });
+      continue;
+    }
+
+    results.push({
+      input,
+      resolved: false,
+      channelName: channelName,
+    });
+  }
+
+  return results;
+}