@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

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

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

@@ -1,21 +0,0 @@
-import { RequestClient, type RequestClientOptions } from "./internal/discord.js";
-
-type ProxyRequestClientOptions = RequestClientOptions;
-
-export const DISCORD_REST_TIMEOUT_MS = 15_000;
-
-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: options.fetch,
-  });
-}

package/src/recipient-resolution.ts

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

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

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

@@ -1,340 +0,0 @@
-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();
-  });
-});