@kodelyth/discord 2026.5.42 → 2026.6.2

package/src/resolve-channels.test.ts

@@ -1,341 +0,0 @@
-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

@@ -1,369 +0,0 @@
-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;
-}