@openclaw/discord 2026.3.13 → 2026.5.2-beta.1

package/src/send.webhook.ts

@@ -0,0 +1,133 @@
+import { recordChannelActivity } from "openclaw/plugin-sdk/channel-activity-runtime";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+import { resolveDiscordClientAccountContext } from "./client.js";
+import {
+  DiscordError,
+  RateLimitError,
+  readDiscordCode,
+  readDiscordMessage,
+  readRetryAfter,
+} from "./internal/rest-errors.js";
+import { rewriteDiscordKnownMentions } from "./mentions.js";
+import type { DiscordSendResult } from "./send.types.js";
+
+type DiscordWebhookSendOpts = {
+  cfg: OpenClawConfig;
+  webhookId: string;
+  webhookToken: string;
+  accountId?: string;
+  threadId?: string | number;
+  replyTo?: string;
+  username?: string;
+  avatarUrl?: string;
+  wait?: boolean;
+};
+
+function resolveWebhookExecutionUrl(params: {
+  webhookId: string;
+  webhookToken: string;
+  threadId?: string | number;
+  wait?: boolean;
+}) {
+  const baseUrl = new URL(
+    `https://discord.com/api/v10/webhooks/${encodeURIComponent(params.webhookId)}/${encodeURIComponent(params.webhookToken)}`,
+  );
+  baseUrl.searchParams.set("wait", params.wait === false ? "false" : "true");
+  if (params.threadId !== undefined && params.threadId !== null && params.threadId !== "") {
+    baseUrl.searchParams.set("thread_id", String(params.threadId));
+  }
+  return baseUrl.toString();
+}
+
+function coerceWebhookErrorBody(raw: string): unknown {
+  if (!raw) {
+    return undefined;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return { message: raw.slice(0, 200) };
+  }
+}
+
+async function throwWebhookResponseError(response: Response): Promise<never> {
+  const raw = await response.text().catch(() => "");
+  const parsed = coerceWebhookErrorBody(raw);
+  if (response.status === 429) {
+    throw new RateLimitError(response, {
+      message: readDiscordMessage(parsed, "Rate limited"),
+      retry_after: readRetryAfter(parsed, response, 1),
+      code: readDiscordCode(parsed),
+      global:
+        parsed && typeof parsed === "object" && "global" in parsed
+          ? Boolean((parsed as { global?: unknown }).global)
+          : false,
+    });
+  }
+  throw new DiscordError(response, parsed);
+}
+
+export async function sendWebhookMessageDiscord(
+  text: string,
+  opts: DiscordWebhookSendOpts,
+): Promise<DiscordSendResult> {
+  const webhookId = normalizeOptionalString(opts.webhookId) ?? "";
+  const webhookToken = normalizeOptionalString(opts.webhookToken) ?? "";
+  if (!webhookId || !webhookToken) {
+    throw new Error("Discord webhook id/token are required");
+  }
+
+  const replyTo = normalizeOptionalString(opts.replyTo) ?? "";
+  const messageReference = replyTo ? { message_id: replyTo, fail_if_not_exists: false } : undefined;
+  const { account, proxyFetch } = resolveDiscordClientAccountContext({
+    cfg: opts.cfg,
+    accountId: opts.accountId,
+  });
+  const rewrittenText = rewriteDiscordKnownMentions(text, {
+    accountId: account.accountId,
+    mentionAliases: account.config.mentionAliases,
+  });
+
+  const response = await (proxyFetch ?? fetch)(
+    resolveWebhookExecutionUrl({
+      webhookId,
+      webhookToken,
+      threadId: opts.threadId,
+      wait: opts.wait,
+    }),
+    {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        content: rewrittenText,
+        username: normalizeOptionalString(opts.username),
+        avatar_url: normalizeOptionalString(opts.avatarUrl),
+        ...(messageReference ? { message_reference: messageReference } : {}),
+      }),
+    },
+  );
+  if (!response.ok) {
+    await throwWebhookResponseError(response);
+  }
+
+  const payload = (await response.json().catch(() => ({}))) as {
+    id?: string;
+    channel_id?: string;
+  };
+  try {
+    recordChannelActivity({
+      channel: "discord",
+      accountId: account.accountId,
+      direction: "outbound",
+    });
+  } catch {
+    // Best-effort telemetry only.
+  }
+  return {
+    messageId: payload.id || "unknown",
+    channelId: payload.channel_id ? payload.channel_id : opts.threadId ? String(opts.threadId) : "",
+  };
+}

package/src/session-contract.ts

@@ -0,0 +1,3 @@
+export function deriveLegacySessionChatType(sessionKey: string): "channel" | undefined {
+  return /^discord:(?:[^:]+:)?guild-[^:]+:channel-[^:]+$/.test(sessionKey) ? "channel" : undefined;
+}

package/src/session-key-normalization.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import { normalizeExplicitDiscordSessionKey } from "./session-key-normalization.js";
+
+describe("normalizeExplicitDiscordSessionKey", () => {
+  it("rewrites bare discord:dm keys for direct chats", () => {
+    expect(
+      normalizeExplicitDiscordSessionKey("discord:dm:123456", {
+        ChatType: "direct",
+        From: "discord:123456",
+        SenderId: "123456",
+      }),
+    ).toBe("discord:direct:123456");
+  });
+
+  it("rewrites legacy discord:dm keys for direct chats", () => {
+    expect(
+      normalizeExplicitDiscordSessionKey("agent:fina:discord:dm:123456", {
+        ChatType: "direct",
+        From: "discord:123456",
+        SenderId: "123456",
+      }),
+    ).toBe("agent:fina:discord:direct:123456");
+  });
+
+  it("rewrites phantom discord:channel keys when sender matches", () => {
+    expect(
+      normalizeExplicitDiscordSessionKey("discord:channel:123456", {
+        ChatType: "direct",
+        From: "discord:123456",
+        SenderId: "123456",
+      }),
+    ).toBe("discord:direct:123456");
+  });
+
+  it("leaves non-direct channel keys unchanged", () => {
+    expect(
+      normalizeExplicitDiscordSessionKey("agent:fina:discord:channel:123456", {
+        ChatType: "channel",
+        From: "discord:channel:123456",
+        SenderId: "789",
+      }),
+    ).toBe("agent:fina:discord:channel:123456");
+  });
+});

package/src/session-key-normalization.ts

@@ -0,0 +1,47 @@
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
+
+type DiscordSessionKeyContext = {
+  ChatType?: string;
+  From?: string;
+  SenderId?: string;
+};
+
+function normalizeDiscordChatType(raw?: string): "direct" | "group" | "channel" | undefined {
+  const normalized = normalizeLowercaseStringOrEmpty(raw);
+  if (!normalized) {
+    return undefined;
+  }
+  if (normalized === "dm") {
+    return "direct";
+  }
+  if (normalized === "group" || normalized === "channel" || normalized === "direct") {
+    return normalized;
+  }
+  return undefined;
+}
+
+export function normalizeExplicitDiscordSessionKey(
+  sessionKey: string,
+  ctx: DiscordSessionKeyContext,
+): string {
+  let normalized = normalizeLowercaseStringOrEmpty(sessionKey);
+  if (normalizeDiscordChatType(ctx.ChatType) !== "direct") {
+    return normalized;
+  }
+
+  normalized = normalized.replace(/^(discord:)dm:/, "$1direct:");
+  normalized = normalized.replace(/^(agent:[^:]+:discord:)dm:/, "$1direct:");
+  const match = normalized.match(/^((?:agent:[^:]+:)?)discord:channel:([^:]+)$/);
+  if (!match) {
+    return normalized;
+  }
+
+  const from = normalizeLowercaseStringOrEmpty(ctx.From);
+  const senderId = normalizeLowercaseStringOrEmpty(ctx.SenderId);
+  const fromDiscordId =
+    from.startsWith("discord:") && !from.includes(":channel:") && !from.includes(":group:")
+      ? from.slice("discord:".length)
+      : "";
+  const directId = senderId || fromDiscordId;
+  return directId && directId === match[2] ? `${match[1]}discord:direct:${match[2]}` : normalized;
+}

package/src/setup-account-state.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from "vitest";
+import {
+  inspectDiscordSetupAccount,
+  listDiscordSetupAccountIds,
+  resolveDefaultDiscordSetupAccountId,
+  resolveDiscordSetupAccountConfig,
+} from "./setup-account-state.js";
+
+describe("discord setup account state", () => {
+  it("lists normalized setup account ids plus the implicit default account", () => {
+    expect(
+      listDiscordSetupAccountIds({
+        channels: {
+          discord: {
+            accounts: {
+              Work: { token: "work-token" },
+              alerts: { token: "alerts-token" },
+            },
+          },
+        },
+      }),
+    ).toEqual(["alerts", "default", "work"]);
+  });
+
+  it("resolves setup account config when account key casing differs from normalized id", () => {
+    const resolved = resolveDiscordSetupAccountConfig({
+      cfg: {
+        channels: {
+          discord: {
+            allowFrom: ["top"],
+            accounts: {
+              Work: { name: "Work", allowFrom: ["acct"] },
+            },
+          },
+        },
+      },
+      accountId: "work",
+    });
+
+    expect(resolved.accountId).toBe("work");
+    expect(resolved.config.name).toBe("Work");
+    expect(resolved.config.allowFrom).toEqual(["acct"]);
+  });
+
+  it("uses configured defaultAccount for omitted setup account resolution", () => {
+    const cfg = {
+      channels: {
+        discord: {
+          defaultAccount: "work",
+          allowFrom: ["top"],
+          accounts: {
+            alerts: { allowFrom: ["alerts-only"] },
+            work: { name: "Work", allowFrom: ["work-only"] },
+          },
+        },
+      },
+    };
+
+    expect(resolveDefaultDiscordSetupAccountId(cfg)).toBe("work");
+
+    const resolved = resolveDiscordSetupAccountConfig({
+      cfg,
+    });
+
+    expect(resolved.accountId).toBe("work");
+    expect(resolved.config.name).toBe("Work");
+    expect(resolved.config.allowFrom).toEqual(["work-only"]);
+  });
+
+  it("treats explicit blank account tokens as missing without falling back", () => {
+    const inspected = inspectDiscordSetupAccount({
+      cfg: {
+        channels: {
+          discord: {
+            token: "top-level-token",
+            accounts: {
+              work: { token: "" },
+            },
+          },
+        },
+      },
+      accountId: "work",
+    });
+
+    expect(inspected.accountId).toBe("work");
+    expect(inspected.token).toBe("");
+    expect(inspected.tokenSource).toBe("none");
+    expect(inspected.tokenStatus).toBe("missing");
+    expect(inspected.configured).toBe(false);
+  });
+});

package/src/setup-account-state.ts

@@ -0,0 +1,144 @@
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { listCombinedAccountIds } from "openclaw/plugin-sdk/account-resolution";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
+import {
+  hasConfiguredSecretInput,
+  normalizeSecretInputString,
+} from "openclaw/plugin-sdk/secret-input";
+import { resolveDefaultDiscordAccountId } from "./accounts.js";
+import { mergeDiscordAccountConfig, resolveDiscordAccountConfig } from "./accounts.js";
+import type { DiscordAccountConfig } from "./runtime-api.js";
+import { resolveDiscordToken } from "./token.js";
+
+type InspectedDiscordSetupAccount = {
+  accountId: string;
+  enabled: boolean;
+  token: string;
+  tokenSource: "env" | "config" | "none";
+  tokenStatus: "available" | "configured_unavailable" | "missing";
+  configured: boolean;
+  config: DiscordAccountConfig;
+};
+
+function inspectConfiguredToken(value: unknown): {
+  token: string;
+  tokenSource: "config";
+  tokenStatus: "available" | "configured_unavailable";
+} | null {
+  const normalized = normalizeSecretInputString(value);
+  if (normalized) {
+    return {
+      token: normalized.replace(/^Bot\s+/i, ""),
+      tokenSource: "config",
+      tokenStatus: "available",
+    };
+  }
+  if (hasConfiguredSecretInput(value)) {
+    return {
+      token: "",
+      tokenSource: "config",
+      tokenStatus: "configured_unavailable",
+    };
+  }
+  return null;
+}
+
+export function listDiscordSetupAccountIds(cfg: OpenClawConfig): string[] {
+  const accounts = cfg.channels?.discord?.accounts;
+  return listCombinedAccountIds({
+    configuredAccountIds:
+      accounts && typeof accounts === "object" && !Array.isArray(accounts)
+        ? Object.keys(accounts).map((accountId) => normalizeAccountId(accountId))
+        : [],
+    implicitAccountId: DEFAULT_ACCOUNT_ID,
+  });
+}
+
+export function resolveDefaultDiscordSetupAccountId(cfg: OpenClawConfig): string {
+  return resolveDefaultDiscordAccountId(cfg);
+}
+
+export function resolveDiscordSetupAccountConfig(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+}): { accountId: string; config: DiscordAccountConfig } {
+  const accountId = normalizeAccountId(
+    params.accountId ?? resolveDefaultDiscordSetupAccountId(params.cfg),
+  );
+  return {
+    accountId,
+    config: mergeDiscordAccountConfig(params.cfg, accountId),
+  };
+}
+
+export function inspectDiscordSetupAccount(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+}): InspectedDiscordSetupAccount {
+  const { accountId, config } = resolveDiscordSetupAccountConfig(params);
+  const enabled = params.cfg.channels?.discord?.enabled !== false && config.enabled !== false;
+  const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
+  const hasAccountToken = Boolean(
+    accountConfig &&
+    Object.prototype.hasOwnProperty.call(accountConfig as Record<string, unknown>, "token"),
+  );
+  const accountToken = inspectConfiguredToken(accountConfig?.token);
+  if (accountToken) {
+    return {
+      accountId,
+      enabled,
+      token: accountToken.token,
+      tokenSource: accountToken.tokenSource,
+      tokenStatus: accountToken.tokenStatus,
+      configured: true,
+      config,
+    };
+  }
+  if (hasAccountToken) {
+    return {
+      accountId,
+      enabled,
+      token: "",
+      tokenSource: "none",
+      tokenStatus: "missing",
+      configured: false,
+      config,
+    };
+  }
+
+  const channelToken = inspectConfiguredToken(params.cfg.channels?.discord?.token);
+  if (channelToken) {
+    return {
+      accountId,
+      enabled,
+      token: channelToken.token,
+      tokenSource: channelToken.tokenSource,
+      tokenStatus: channelToken.tokenStatus,
+      configured: true,
+      config,
+    };
+  }
+
+  const tokenResolution = resolveDiscordToken(params.cfg, { accountId });
+  if (tokenResolution.token) {
+    return {
+      accountId,
+      enabled,
+      token: tokenResolution.token,
+      tokenSource: tokenResolution.source,
+      tokenStatus: "available",
+      configured: true,
+      config,
+    };
+  }
+
+  return {
+    accountId,
+    enabled,
+    token: "",
+    tokenSource: "none",
+    tokenStatus: "missing",
+    configured: false,
+    config,
+  };
+}

package/src/setup-adapter.ts

@@ -0,0 +1,12 @@
+import { createEnvPatchedAccountSetupAdapter } from "openclaw/plugin-sdk/setup-adapter-runtime";
+import type { ChannelSetupAdapter } from "openclaw/plugin-sdk/setup-runtime";
+
+const channel = "discord" as const;
+
+export const discordSetupAdapter: ChannelSetupAdapter = createEnvPatchedAccountSetupAdapter({
+  channelKey: channel,
+  defaultAccountOnlyEnvError: "DISCORD_BOT_TOKEN can only be used for the default account.",
+  missingCredentialError: "Discord requires token (or --use-env).",
+  hasCredentials: (input) => Boolean(input.token),
+  buildPatch: (input) => (input.token ? { token: input.token } : {}),
+});

package/src/setup-core.ts

@@ -0,0 +1,212 @@
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import type { DiscordGuildEntry, OpenClawConfig } from "openclaw/plugin-sdk/config-types";
+import type { ChannelSetupDmPolicy, ChannelSetupWizard } from "openclaw/plugin-sdk/setup-runtime";
+import { createStandardChannelSetupStatus } from "openclaw/plugin-sdk/setup-runtime";
+import { formatDocsLink } from "openclaw/plugin-sdk/setup-tools";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+import {
+  inspectDiscordSetupAccount,
+  resolveDiscordSetupAccountConfig,
+} from "./setup-account-state.js";
+import {
+  createAccountScopedAllowFromSection,
+  createAccountScopedGroupAccessSection,
+  createLegacyCompatChannelDmPolicy,
+  parseMentionOrPrefixedId,
+  patchChannelConfigForAccount,
+  setSetupChannelEnabled,
+} from "./setup-runtime-helpers.js";
+
+const channel = "discord" as const;
+
+const DISCORD_TOKEN_HELP_LINES = [
+  "1) Discord Developer Portal -> Applications -> New Application",
+  "2) Bot -> Add Bot -> Reset Token -> copy token",
+  "3) OAuth2 -> URL Generator -> scope 'bot' -> invite to your server",
+  "Tip: enable Message Content Intent if you need message text. (Bot -> Privileged Gateway Intents -> Message Content Intent)",
+  `Docs: ${formatDocsLink("/discord", "discord")}`,
+];
+
+type DiscordGuildChannelAllowlistEntry = {
+  guildKey: string;
+  channelKey?: string;
+};
+
+type DiscordSetupAllowlistResolution = {
+  resolved?: boolean;
+  guildId?: string;
+  channelId?: string;
+  guildKey?: string;
+  channelKey?: string;
+};
+
+function mapDiscordSetupAllowlistEntries(resolved: unknown): DiscordGuildChannelAllowlistEntry[] {
+  if (!Array.isArray(resolved)) {
+    return [];
+  }
+  return resolved.flatMap((entry): DiscordGuildChannelAllowlistEntry[] => {
+    if (!entry || typeof entry !== "object") {
+      return [];
+    }
+    const row = entry as DiscordSetupAllowlistResolution;
+    if (row.resolved === false) {
+      return [];
+    }
+    const guildKey = normalizeOptionalString(row.guildId ?? row.guildKey);
+    if (!guildKey) {
+      return [];
+    }
+    const channelKey = normalizeOptionalString(row.channelId ?? row.channelKey);
+    return channelKey ? [{ guildKey, channelKey }] : [{ guildKey }];
+  });
+}
+
+function setDiscordGuildChannelAllowlist(
+  cfg: OpenClawConfig,
+  accountId: string,
+  entries: DiscordGuildChannelAllowlistEntry[],
+): OpenClawConfig {
+  const baseGuilds =
+    accountId === DEFAULT_ACCOUNT_ID
+      ? (cfg.channels?.discord?.guilds ?? {})
+      : (cfg.channels?.discord?.accounts?.[accountId]?.guilds ?? {});
+  const guilds: Record<string, DiscordGuildEntry> = { ...baseGuilds };
+  for (const entry of entries) {
+    const guildKey = entry.guildKey || "*";
+    const existing = guilds[guildKey] ?? {};
+    if (entry.channelKey) {
+      const channels = { ...existing.channels };
+      channels[entry.channelKey] = { enabled: true };
+      guilds[guildKey] = { ...existing, channels };
+    } else {
+      guilds[guildKey] = existing;
+    }
+  }
+  return patchChannelConfigForAccount({
+    cfg,
+    channel,
+    accountId,
+    patch: { guilds },
+  });
+}
+
+export function parseDiscordAllowFromId(value: string): string | null {
+  return parseMentionOrPrefixedId({
+    value,
+    mentionPattern: /^<@!?(\d+)>$/,
+    prefixPattern: /^(user:|discord:)/i,
+    idPattern: /^\d+$/,
+  });
+}
+
+export function createDiscordSetupWizardBase(handlers: {
+  promptAllowFrom: NonNullable<ChannelSetupDmPolicy["promptAllowFrom"]>;
+  resolveAllowFromEntries: NonNullable<
+    NonNullable<ChannelSetupWizard["allowFrom"]>["resolveEntries"]
+  >;
+  resolveGroupAllowlist: NonNullable<
+    NonNullable<NonNullable<ChannelSetupWizard["groupAccess"]>["resolveAllowlist"]>
+  >;
+}) {
+  const discordDmPolicy: ChannelSetupDmPolicy = createLegacyCompatChannelDmPolicy({
+    label: "Discord",
+    channel,
+    promptAllowFrom: handlers.promptAllowFrom,
+  });
+
+  return {
+    channel,
+    status: createStandardChannelSetupStatus({
+      channelLabel: "Discord",
+      configuredLabel: "configured",
+      unconfiguredLabel: "needs token",
+      configuredHint: "configured",
+      unconfiguredHint: "needs token",
+      configuredScore: 2,
+      unconfiguredScore: 1,
+      resolveConfigured: ({ cfg, accountId }) =>
+        inspectDiscordSetupAccount({ cfg, accountId }).configured,
+    }),
+    credentials: [
+      {
+        inputKey: "token",
+        providerHint: channel,
+        credentialLabel: "Discord bot token",
+        preferredEnvVar: "DISCORD_BOT_TOKEN",
+        helpTitle: "Discord bot token",
+        helpLines: DISCORD_TOKEN_HELP_LINES,
+        envPrompt: "DISCORD_BOT_TOKEN detected. Use env var?",
+        keepPrompt: "Discord token already configured. Keep it?",
+        inputPrompt: "Enter Discord bot token",
+        allowEnv: ({ accountId }: { accountId: string }) => accountId === DEFAULT_ACCOUNT_ID,
+        inspect: ({ cfg, accountId }: { cfg: OpenClawConfig; accountId: string }) => {
+          const account = inspectDiscordSetupAccount({ cfg, accountId });
+          return {
+            accountConfigured: account.configured,
+            hasConfiguredValue: account.tokenStatus !== "missing",
+            resolvedValue: normalizeOptionalString(account.token),
+            envValue:
+              accountId === DEFAULT_ACCOUNT_ID
+                ? normalizeOptionalString(process.env.DISCORD_BOT_TOKEN)
+                : undefined,
+          };
+        },
+      },
+    ],
+    groupAccess: createAccountScopedGroupAccessSection({
+      channel,
+      label: "Discord channels",
+      placeholder: "My Server/#general, guildId/channelId, #support",
+      currentPolicy: ({ cfg, accountId }: { cfg: OpenClawConfig; accountId: string }) =>
+        resolveDiscordSetupAccountConfig({ cfg, accountId }).config.groupPolicy ?? "allowlist",
+      currentEntries: ({ cfg, accountId }: { cfg: OpenClawConfig; accountId: string }) =>
+        Object.entries(
+          resolveDiscordSetupAccountConfig({ cfg, accountId }).config.guilds ?? {},
+        ).flatMap(([guildKey, value]) => {
+          const channels = value?.channels ?? {};
+          const channelKeys = Object.keys(channels);
+          if (channelKeys.length === 0) {
+            const input = /^\d+$/.test(guildKey) ? `guild:${guildKey}` : guildKey;
+            return [input];
+          }
+          return channelKeys.map((channelKey) => `${guildKey}/${channelKey}`);
+        }),
+      updatePrompt: ({ cfg, accountId }: { cfg: OpenClawConfig; accountId: string }) =>
+        Boolean(resolveDiscordSetupAccountConfig({ cfg, accountId }).config.guilds),
+      resolveAllowlist: handlers.resolveGroupAllowlist,
+      fallbackResolved: (entries) => entries.map((input) => ({ input, resolved: false })),
+      applyAllowlist: ({
+        cfg,
+        accountId,
+        resolved,
+      }: {
+        cfg: OpenClawConfig;
+        accountId: string;
+        resolved: unknown;
+      }) =>
+        setDiscordGuildChannelAllowlist(cfg, accountId, mapDiscordSetupAllowlistEntries(resolved)),
+    }),
+    allowFrom: createAccountScopedAllowFromSection({
+      channel,
+      credentialInputKey: "token",
+      helpTitle: "Discord allowlist",
+      helpLines: [
+        "Allowlist Discord DMs by username (we resolve to user ids).",
+        "Examples:",
+        "- 123456789012345678",
+        "- @alice",
+        "- alice#1234",
+        "Multiple entries: comma-separated.",
+        `Docs: ${formatDocsLink("/discord", "discord")}`,
+      ],
+      message: "Discord allowFrom (usernames or ids)",
+      placeholder: "@alice, 123456789012345678",
+      invalidWithoutCredentialNote:
+        "Bot token missing; use numeric user ids (or mention form) only.",
+      parseId: parseDiscordAllowFromId,
+      resolveEntries: handlers.resolveAllowFromEntries,
+    }),
+    dmPolicy: discordDmPolicy,
+    disable: (cfg: OpenClawConfig) => setSetupChannelEnabled(cfg, channel, false),
+  } satisfies ChannelSetupWizard;
+}