@openclaw/discord 2026.3.13 → 2026.5.1-beta.1

package/src/proxy-request-client.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  createAbortableFetchMock,
+  createJsonResponse,
+} from "./internal/test-builders.test-support.js";
+import { createDiscordRequestClient, DISCORD_REST_TIMEOUT_MS } from "./proxy-request-client.js";
+
+describe("createDiscordRequestClient", () => {
+  it("preserves the REST client's abort signal for proxied fetch calls", async () => {
+    const fetchSpy = vi.fn(async (_input: string | URL | Request, init?: RequestInit) => {
+      expect(init?.signal).toBeDefined();
+      expect(init!.signal!.aborted).toBe(false);
+      return createJsonResponse([]);
+    });
+
+    const client = createDiscordRequestClient("Bot test-token", {
+      fetch: fetchSpy as never,
+      queueRequests: false,
+    });
+
+    await client.get("/channels/123/messages");
+    expect(fetchSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("lets the REST client abort hanging proxied requests after its timeout", async () => {
+    const { fetch: fetchSpy } = createAbortableFetchMock();
+
+    const client = createDiscordRequestClient("Bot test-token", {
+      fetch: fetchSpy as never,
+      queueRequests: false,
+      timeout: 20,
+    });
+
+    await expect(client.get("/channels/123/messages")).rejects.toThrow();
+  }, 1_000);
+
+  it("lets abortAllRequests cancel active proxied fetches", async () => {
+    const abortable = createAbortableFetchMock();
+
+    const client = createDiscordRequestClient("Bot test-token", {
+      fetch: abortable.fetch as never,
+      queueRequests: false,
+      timeout: 5_000,
+    });
+
+    const request = client.get("/channels/123/messages");
+    await vi.waitFor(() => expect(abortable.fetch).toHaveBeenCalledTimes(1));
+
+    client.abortAllRequests();
+
+    await expect(request).rejects.toThrow();
+    expect(abortable.receivedSignal?.aborted).toBe(true);
+  });
+
+  it("provides the REST client's timeout signal even without a caller signal", async () => {
+    let receivedSignal: AbortSignal | undefined;
+
+    const fetchSpy = vi.fn(async (_input: string | URL | Request, init?: RequestInit) => {
+      receivedSignal = init?.signal ?? undefined;
+      return createJsonResponse({});
+    });
+
+    const client = createDiscordRequestClient("Bot test-token", {
+      fetch: fetchSpy as never,
+      queueRequests: false,
+    });
+
+    await client.get("/channels/123/messages");
+
+    expect(receivedSignal).toBeDefined();
+    expect(receivedSignal!.aborted).toBe(false);
+  });
+
+  it("exports a reasonable timeout constant", () => {
+    expect(DISCORD_REST_TIMEOUT_MS).toBeGreaterThanOrEqual(5_000);
+    expect(DISCORD_REST_TIMEOUT_MS).toBeLessThanOrEqual(30_000);
+  });
+});

package/src/proxy-request-client.ts

@@ -0,0 +1,54 @@
+import { FormData as UndiciFormData } from "undici";
+import { RequestClient, type RequestClientOptions } from "./internal/discord.js";
+
+type ProxyRequestClientOptions = RequestClientOptions;
+
+export const DISCORD_REST_TIMEOUT_MS = 15_000;
+
+function toUndiciFormData(body: FormData): UndiciFormData {
+  const converted = new UndiciFormData();
+  for (const [key, value] of body.entries()) {
+    if (typeof value === "string") {
+      converted.append(key, value);
+      continue;
+    }
+    const filename = (value as Blob & { name?: unknown }).name;
+    if (typeof filename === "string" && filename.length > 0) {
+      converted.append(key, value, filename);
+      continue;
+    }
+    converted.append(key, value);
+  }
+  return converted;
+}
+
+function wrapDiscordFetch(fetchImpl: NonNullable<RequestClientOptions["fetch"]>) {
+  return (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
+    if (init?.body instanceof FormData) {
+      // The proxy fetch path needs undici's FormData class to preserve multipart
+      // boundaries. Preserve the REST client's AbortController signal so timeout
+      // and abortAllRequests keep working.
+      return fetchImpl(input, {
+        ...init,
+        body: toUndiciFormData(init.body) as unknown as BodyInit,
+      });
+    }
+    return fetchImpl(input, init);
+  };
+}
+
+export function createDiscordRequestClient(
+  token: string,
+  options?: ProxyRequestClientOptions,
+): RequestClient {
+  if (!options?.fetch) {
+    return new RequestClient(token, options);
+  }
+  return new RequestClient(token, {
+    runtimeProfile: "persistent",
+    maxQueueSize: 1000,
+    timeout: DISCORD_REST_TIMEOUT_MS,
+    ...options,
+    fetch: wrapDiscordFetch(options.fetch),
+  });
+}

package/src/recipient-resolution.ts

@@ -0,0 +1,39 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
+import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
+import { resolveDiscordAccount } from "./accounts.js";
+import { parseAndResolveDiscordTarget } from "./target-resolver.js";
+import type { DiscordTargetParseOptions } from "./targets.js";
+
+type DiscordRecipient =
+  | {
+      kind: "user";
+      id: string;
+    }
+  | {
+      kind: "channel";
+      id: string;
+    };
+
+export async function parseAndResolveRecipient(
+  raw: string,
+  cfg: OpenClawConfig,
+  accountId?: string,
+  parseOptions: DiscordTargetParseOptions = {},
+): Promise<DiscordRecipient> {
+  if (!cfg) {
+    throw new Error(
+      "Discord recipient resolution requires a resolved runtime config. Load and resolve config at the command or gateway boundary, then pass cfg through the runtime path.",
+    );
+  }
+  const resolvedCfg = requireRuntimeConfig(cfg, "Discord recipient resolution");
+  const accountInfo = resolveDiscordAccount({ cfg: resolvedCfg, accountId });
+  const resolved = await parseAndResolveDiscordTarget(
+    raw,
+    {
+      cfg: resolvedCfg,
+      accountId: accountInfo.accountId,
+    },
+    parseOptions,
+  );
+  return { kind: resolved.kind, id: resolved.id };
+}

package/src/resolve-allowlist-common.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildDiscordUnresolvedResults,
+  filterDiscordGuilds,
+  findDiscordGuildByName,
+  resolveDiscordAllowlistToken,
+} from "./resolve-allowlist-common.js";
+
+describe("resolve-allowlist-common", () => {
+  const guilds = [
+    { id: "1", name: "Main Guild", slug: "main-guild" },
+    { id: "2", name: "Ops Guild", slug: "ops-guild" },
+  ];
+
+  it("resolves and filters guilds by id or name", () => {
+    expect(findDiscordGuildByName(guilds, "Main Guild")?.id).toBe("1");
+    expect(filterDiscordGuilds(guilds, { guildId: "2" })).toEqual([guilds[1]]);
+    expect(filterDiscordGuilds(guilds, { guildName: "main-guild" })).toEqual([guilds[0]]);
+  });
+
+  it("builds unresolved result rows in input order", () => {
+    const unresolved = buildDiscordUnresolvedResults(["a", "b"], (input) => ({
+      input,
+      resolved: false,
+    }));
+    expect(unresolved).toEqual([
+      { input: "a", resolved: false },
+      { input: "b", resolved: false },
+    ]);
+  });
+
+  it("normalizes allowlist token values", () => {
+    expect(resolveDiscordAllowlistToken(" discord-token ")).toBe("discord-token");
+    expect(resolveDiscordAllowlistToken("")).toBeUndefined();
+  });
+});

package/src/resolve-allowlist-common.ts

@@ -0,0 +1,39 @@
+import type { DiscordGuildSummary } from "./guilds.js";
+import { normalizeDiscordSlug } from "./monitor/allow-list.js";
+import { normalizeDiscordToken } from "./token.js";
+
+export function resolveDiscordAllowlistToken(token: string): string | undefined {
+  return normalizeDiscordToken(token, "channels.discord.token");
+}
+
+export function buildDiscordUnresolvedResults<T extends { input: string; resolved: boolean }>(
+  entries: string[],
+  buildResult: (input: string) => T,
+): T[] {
+  return entries.map((input) => buildResult(input));
+}
+
+export function findDiscordGuildByName(
+  guilds: DiscordGuildSummary[],
+  input: string,
+): DiscordGuildSummary | undefined {
+  const slug = normalizeDiscordSlug(input);
+  if (!slug) {
+    return undefined;
+  }
+  return guilds.find((guild) => guild.slug === slug);
+}
+
+export function filterDiscordGuilds(
+  guilds: DiscordGuildSummary[],
+  params: { guildId?: string; guildName?: string },
+): DiscordGuildSummary[] {
+  if (params.guildId) {
+    return guilds.filter((guild) => guild.id === params.guildId);
+  }
+  if (params.guildName) {
+    const match = findDiscordGuildByName(guilds, params.guildName);
+    return match ? [match] : [];
+  }
+  return guilds;
+}

package/src/resolve-channels.test.ts

@@ -0,0 +1,340 @@
+import { withFetchPreconnect } from "openclaw/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]).toMatchObject({
+      input: "111/222",
+      resolved: true,
+      guildId: "111",
+      channelId: "222",
+      channelName: "general",
+      guildName: "Guild One",
+    });
+  });
+
+  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]).toMatchObject({
+      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();
+  });
+});