@openclaw/discord 2026.3.13 → 2026.5.1-beta.1

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;
+}

package/src/resolve-users.test.ts

@@ -0,0 +1,222 @@
+import { withFetchPreconnect } from "openclaw/plugin-sdk/test-env";
+import { describe, expect, it } from "vitest";
+import { resolveDiscordUserAllowlist } from "./resolve-users.js";
+import { jsonResponse, urlToString } from "./test-http-helpers.js";
+
+function createGuildListProbeFetcher() {
+  let guildsCalled = false;
+  const fetcher = withFetchPreconnect(async (input: RequestInfo | URL) => {
+    const url = urlToString(input);
+    if (url.endsWith("/users/@me/guilds")) {
+      guildsCalled = true;
+      return jsonResponse([]);
+    }
+    return new Response("not found", { status: 404 });
+  });
+  return {
+    fetcher,
+    wasGuildsCalled: () => guildsCalled,
+  };
+}
+
+function createGuildsForbiddenFetcher() {
+  return withFetchPreconnect(async (input: RequestInfo | URL) => {
+    const url = urlToString(input);
+    if (url.endsWith("/users/@me/guilds")) {
+      throw new Error("Forbidden: Missing Access");
+    }
+    return new Response("not found", { status: 404 });
+  });
+}
+
+describe("resolveDiscordUserAllowlist", () => {
+  it("resolves plain user ids without calling listGuilds", async () => {
+    const { fetcher, wasGuildsCalled } = createGuildListProbeFetcher();
+
+    const results = await resolveDiscordUserAllowlist({
+      token: "test",
+      entries: ["123456789012345678"],
+      fetcher,
+    });
+
+    expect(results).toEqual([
+      {
+        input: "123456789012345678",
+        resolved: true,
+        id: "123456789012345678",
+      },
+    ]);
+    expect(wasGuildsCalled()).toBe(false);
+  });
+
+  it("resolves mention-format ids without calling listGuilds", async () => {
+    const { fetcher, wasGuildsCalled } = createGuildListProbeFetcher();
+
+    const results = await resolveDiscordUserAllowlist({
+      token: "test",
+      entries: ["<@!123456789012345678>"],
+      fetcher,
+    });
+
+    expect(results).toEqual([
+      {
+        input: "<@!123456789012345678>",
+        resolved: true,
+        id: "123456789012345678",
+      },
+    ]);
+    expect(wasGuildsCalled()).toBe(false);
+  });
+
+  it("resolves prefixed ids (user:, discord:) without calling listGuilds", async () => {
+    const { fetcher, wasGuildsCalled } = createGuildListProbeFetcher();
+
+    const results = await resolveDiscordUserAllowlist({
+      token: "test",
+      entries: ["user:111", "discord:222"],
+      fetcher,
+    });
+
+    expect(results).toHaveLength(2);
+    expect(results[0]).toMatchObject({ resolved: true, id: "111" });
+    expect(results[1]).toMatchObject({ resolved: true, id: "222" });
+    expect(wasGuildsCalled()).toBe(false);
+  });
+
+  it("resolves user ids even when listGuilds would fail", async () => {
+    const fetcher = createGuildsForbiddenFetcher();
+
+    // Before the fix, this would throw because listGuilds() was called eagerly
+    const results = await resolveDiscordUserAllowlist({
+      token: "test",
+      entries: ["994979735488692324"],
+      fetcher,
+    });
+
+    expect(results).toEqual([
+      {
+        input: "994979735488692324",
+        resolved: true,
+        id: "994979735488692324",
+      },
+    ]);
+  });
+
+  it("calls listGuilds lazily when resolving usernames", async () => {
+    let guildsCalled = false;
+    const fetcher = withFetchPreconnect(async (input: RequestInfo | URL) => {
+      const url = urlToString(input);
+      if (url.endsWith("/users/@me/guilds")) {
+        guildsCalled = true;
+        return jsonResponse([{ id: "g1", name: "Test Guild" }]);
+      }
+      if (url.includes("/guilds/g1/members/search")) {
+        return jsonResponse([
+          {
+            user: { id: "u1", username: "alice", bot: false },
+            nick: null,
+          },
+        ]);
+      }
+      return new Response("not found", { status: 404 });
+    });
+
+    const results = await resolveDiscordUserAllowlist({
+      token: "test",
+      entries: ["alice"],
+      fetcher,
+    });
+
+    expect(guildsCalled).toBe(true);
+    expect(results).toHaveLength(1);
+    expect(results[0]).toMatchObject({
+      input: "alice",
+      resolved: true,
+      id: "u1",
+      name: "alice",
+    });
+  });
+
+  it("fetches guilds only once for multiple username entries", async () => {
+    let guildsCallCount = 0;
+    const fetcher = withFetchPreconnect(async (input: RequestInfo | URL) => {
+      const url = urlToString(input);
+      if (url.endsWith("/users/@me/guilds")) {
+        guildsCallCount++;
+        return jsonResponse([{ id: "g1", name: "Test Guild" }]);
+      }
+      if (url.includes("/guilds/g1/members/search")) {
+        const params = new URL(url).searchParams;
+        const query = params.get("query") ?? "";
+        return jsonResponse([
+          {
+            user: { id: `u-${query}`, username: query, bot: false },
+            nick: null,
+          },
+        ]);
+      }
+      return new Response("not found", { status: 404 });
+    });
+
+    const results = await resolveDiscordUserAllowlist({
+      token: "test",
+      entries: ["alice", "bob"],
+      fetcher,
+    });
+
+    expect(guildsCallCount).toBe(1);
+    expect(results).toHaveLength(2);
+    expect(results[0]).toMatchObject({ resolved: true, id: "u-alice" });
+    expect(results[1]).toMatchObject({ resolved: true, id: "u-bob" });
+  });
+
+  it("handles mixed ids and usernames — ids resolve even if guilds fail", async () => {
+    const fetcher = createGuildsForbiddenFetcher();
+
+    // IDs should succeed, username should fail (listGuilds throws)
+    await expect(
+      resolveDiscordUserAllowlist({
+        token: "test",
+        entries: ["123456789012345678", "alice"],
+        fetcher,
+      }),
+    ).rejects.toThrow("Forbidden");
+
+    // But if we only pass IDs, it should work fine
+    const results = await resolveDiscordUserAllowlist({
+      token: "test",
+      entries: ["123456789012345678", "<@999>"],
+      fetcher,
+    });
+
+    expect(results).toHaveLength(2);
+    expect(results[0]).toMatchObject({ resolved: true, id: "123456789012345678" });
+    expect(results[1]).toMatchObject({ resolved: true, id: "999" });
+  });
+
+  it("returns unresolved for empty/blank entries", async () => {
+    const fetcher = withFetchPreconnect(async () => {
+      return new Response("not found", { status: 404 });
+    });
+
+    const results = await resolveDiscordUserAllowlist({
+      token: "test",
+      entries: ["", "  "],
+      fetcher,
+    });
+
+    expect(results).toHaveLength(2);
+    expect(results[0]).toMatchObject({ resolved: false });
+    expect(results[1]).toMatchObject({ resolved: false });
+  });
+
+  it("returns all unresolved when token is empty", async () => {
+    const results = await resolveDiscordUserAllowlist({
+      token: "",
+      entries: ["123456789012345678", "alice"],
+    });
+
+    expect(results).toHaveLength(2);
+    expect(results.every((r) => !r.resolved)).toBe(true);
+  });
+});