@openclaw/discord 2026.3.13 → 2026.5.2-beta.1

package/src/setup-runtime-helpers.ts

@@ -0,0 +1,10 @@
+export {
+  createAccountScopedAllowFromSection,
+  createAccountScopedGroupAccessSection,
+  createLegacyCompatChannelDmPolicy,
+  parseMentionOrPrefixedId,
+  patchChannelConfigForAccount,
+  promptLegacyChannelAllowFromForAccount,
+  resolveEntriesWithOptionalToken,
+  setSetupChannelEnabled,
+} from "openclaw/plugin-sdk/setup-runtime";

package/src/setup-surface.test.ts

@@ -0,0 +1,137 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
+import { describe, expect, it } from "vitest";
+import { createDiscordSetupWizardBase } from "./setup-core.js";
+
+const discordSetupWizard = createDiscordSetupWizardBase({
+  promptAllowFrom: async ({ cfg }) => cfg,
+  resolveAllowFromEntries: async ({ entries }) =>
+    entries.map((entry) => ({
+      input: entry,
+      resolved: false,
+      id: null,
+    })),
+  resolveGroupAllowlist: async ({ entries }) =>
+    entries.map((entry) => ({
+      input: entry,
+      resolved: false,
+    })),
+});
+
+describe("discordSetupWizard.dmPolicy", () => {
+  it("reads the named-account DM policy instead of the channel root", () => {
+    expect(
+      discordSetupWizard.dmPolicy?.getCurrent(
+        {
+          channels: {
+            discord: {
+              dmPolicy: "disabled",
+              accounts: {
+                alerts: {
+                  dmPolicy: "allowlist",
+                  token: "discord-token",
+                },
+              },
+            },
+          },
+        } as OpenClawConfig,
+        "alerts",
+      ),
+    ).toBe("allowlist");
+  });
+
+  it("reports account-scoped config keys for named accounts", () => {
+    expect(discordSetupWizard.dmPolicy?.resolveConfigKeys?.({}, "alerts")).toEqual({
+      policyKey: "channels.discord.accounts.alerts.dmPolicy",
+      allowFromKey: "channels.discord.accounts.alerts.allowFrom",
+    });
+  });
+
+  it('writes open policy state to the named account and preserves inherited allowFrom with "*"', () => {
+    const next = discordSetupWizard.dmPolicy?.setPolicy(
+      {
+        channels: {
+          discord: {
+            allowFrom: ["123"],
+            accounts: {
+              alerts: {
+                token: "discord-token",
+              },
+            },
+          },
+        },
+      } as OpenClawConfig,
+      "open",
+      "alerts",
+    );
+
+    expect(next?.channels?.discord?.dmPolicy).toBeUndefined();
+    expect(next?.channels?.discord?.accounts?.alerts?.dmPolicy).toBe("open");
+    expect(next?.channels?.discord?.accounts?.alerts?.allowFrom).toEqual(["123", "*"]);
+  });
+});
+
+describe("discordSetupWizard.status", () => {
+  it("uses configured defaultAccount for omitted setup configured state", async () => {
+    const configured = await discordSetupWizard.status.resolveConfigured({
+      cfg: {
+        channels: {
+          discord: {
+            defaultAccount: "work",
+            token: "discord-root-token",
+            accounts: {
+              alerts: {
+                token: "discord-alerts-token",
+              },
+              work: {
+                token: "",
+              },
+            },
+          },
+        },
+      } as OpenClawConfig,
+    });
+
+    expect(configured).toBe(false);
+  });
+});
+
+describe("discordSetupWizard.groupAccess", () => {
+  it("writes resolved Discord channel rows to their selected guild and channel", () => {
+    const next = discordSetupWizard.groupAccess?.applyAllowlist?.({
+      cfg: {
+        channels: {
+          discord: {
+            guilds: {
+              existing: {
+                channels: {
+                  keep: { enabled: true },
+                },
+              },
+            },
+          },
+        },
+      } as OpenClawConfig,
+      accountId: "default",
+      resolved: [
+        {
+          input: "OpenClaw/#triage",
+          resolved: true,
+          guildId: "guild-1",
+          channelId: "channel-1",
+        },
+        {
+          input: "missing",
+          resolved: false,
+        },
+      ],
+    });
+
+    expect(next?.channels?.discord?.guilds?.["guild-1"]?.channels?.["channel-1"]).toEqual({
+      enabled: true,
+    });
+    expect(next?.channels?.discord?.guilds?.["*"]).toBeUndefined();
+    expect(next?.channels?.discord?.guilds?.existing?.channels?.keep).toEqual({
+      enabled: true,
+    });
+  });
+});

package/src/setup-surface.ts

@@ -0,0 +1,129 @@
+import {
+  type ChannelSetupWizard,
+  type OpenClawConfig,
+  type WizardPrompter,
+} from "openclaw/plugin-sdk/setup-runtime";
+import { formatDocsLink } from "openclaw/plugin-sdk/setup-tools";
+import { resolveDiscordAccountAllowFrom } from "./accounts.js";
+import { resolveDiscordChannelAllowlist } from "./resolve-channels.js";
+import { resolveDiscordUserAllowlist } from "./resolve-users.js";
+import {
+  resolveDefaultDiscordSetupAccountId,
+  resolveDiscordSetupAccountConfig,
+} from "./setup-account-state.js";
+import { createDiscordSetupWizardBase, parseDiscordAllowFromId } from "./setup-core.js";
+import {
+  promptLegacyChannelAllowFromForAccount,
+  resolveEntriesWithOptionalToken,
+} from "./setup-runtime-helpers.js";
+import { resolveDiscordToken } from "./token.js";
+
+const channel = "discord" as const;
+
+async function resolveDiscordAllowFromEntries(params: { token?: string; entries: string[] }) {
+  return await resolveEntriesWithOptionalToken({
+    token: params.token,
+    entries: params.entries,
+    buildWithoutToken: (input) => ({
+      input,
+      resolved: false,
+      id: null,
+    }),
+    resolveEntries: async ({ token, entries }) =>
+      (
+        await resolveDiscordUserAllowlist({
+          token,
+          entries,
+        })
+      ).map((entry) => ({
+        input: entry.input,
+        resolved: entry.resolved,
+        id: entry.id ?? null,
+      })),
+  });
+}
+
+async function promptDiscordAllowFrom(params: {
+  cfg: OpenClawConfig;
+  prompter: WizardPrompter;
+  accountId?: string;
+}): Promise<OpenClawConfig> {
+  return await promptLegacyChannelAllowFromForAccount({
+    cfg: params.cfg,
+    channel,
+    prompter: params.prompter,
+    accountId: params.accountId,
+    defaultAccountId: resolveDefaultDiscordSetupAccountId(params.cfg),
+    resolveAccount: (cfg, accountId) => resolveDiscordSetupAccountConfig({ cfg, accountId }),
+    noteTitle: "Discord allowlist",
+    noteLines: [
+      "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",
+    parseId: parseDiscordAllowFromId,
+    invalidWithoutTokenNote: "Bot token missing; use numeric user ids (or mention form) only.",
+    resolveExisting: (account, cfg) =>
+      resolveDiscordAccountAllowFrom({ cfg, accountId: account.accountId }) ?? [],
+    resolveToken: (account) =>
+      resolveDiscordToken(params.cfg, { accountId: account.accountId }).token,
+    resolveEntries: async ({ token, entries }) =>
+      (
+        await resolveDiscordUserAllowlist({
+          token,
+          entries,
+        })
+      ).map((entry) => ({
+        input: entry.input,
+        resolved: entry.resolved,
+        id: entry.id ?? null,
+      })),
+  });
+}
+
+async function resolveDiscordGroupAllowlist(params: {
+  cfg: OpenClawConfig;
+  accountId: string;
+  credentialValues: { token?: string };
+  entries: string[];
+}) {
+  return await resolveEntriesWithOptionalToken({
+    token:
+      resolveDiscordToken(params.cfg, { accountId: params.accountId }).token ||
+      (typeof params.credentialValues.token === "string" ? params.credentialValues.token : ""),
+    entries: params.entries,
+    buildWithoutToken: (input) => ({
+      input,
+      resolved: false,
+    }),
+    resolveEntries: async ({ token, entries }) =>
+      await resolveDiscordChannelAllowlist({
+        token,
+        entries,
+      }),
+  });
+}
+
+export const discordSetupWizard: ChannelSetupWizard = createDiscordSetupWizardBase({
+  promptAllowFrom: promptDiscordAllowFrom,
+  resolveAllowFromEntries: async ({ cfg, accountId, credentialValues, entries }) =>
+    await resolveDiscordAllowFromEntries({
+      token:
+        resolveDiscordToken(cfg, { accountId }).token ||
+        (typeof credentialValues.token === "string" ? credentialValues.token : ""),
+      entries,
+    }),
+  resolveGroupAllowlist: async ({ cfg, accountId, credentialValues, entries }) =>
+    await resolveDiscordGroupAllowlist({
+      cfg,
+      accountId,
+      credentialValues,
+      entries,
+    }),
+});

package/src/shared-interactive.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildDiscordInteractiveComponents,
+  buildDiscordPresentationComponents,
+} from "./shared-interactive.js";
+
+describe("buildDiscordInteractiveComponents", () => {
+  it("maps shared buttons and selects into Discord component blocks", () => {
+    expect(
+      buildDiscordInteractiveComponents({
+        blocks: [
+          {
+            type: "buttons",
+            buttons: [
+              { label: "Approve", value: "approve", style: "success" },
+              { label: "Reject", value: "reject", style: "danger" },
+            ],
+          },
+          {
+            type: "select",
+            placeholder: "Pick one",
+            options: [{ label: "Alpha", value: "alpha" }],
+          },
+        ],
+      }),
+    ).toEqual({
+      blocks: [
+        {
+          type: "actions",
+          buttons: [
+            { label: "Approve", style: "success", callbackData: "approve" },
+            { label: "Reject", style: "danger", callbackData: "reject" },
+          ],
+        },
+        {
+          type: "actions",
+          select: {
+            type: "string",
+            placeholder: "Pick one",
+            options: [{ label: "Alpha", value: "alpha" }],
+          },
+        },
+      ],
+    });
+  });
+
+  it("preserves authored shared text blocks around controls", () => {
+    expect(
+      buildDiscordInteractiveComponents({
+        blocks: [
+          { type: "text", text: "First" },
+          {
+            type: "buttons",
+            buttons: [{ label: "Approve", value: "approve", style: "success" }],
+          },
+          { type: "text", text: "Last" },
+        ],
+      }),
+    ).toEqual({
+      blocks: [
+        { type: "text", text: "First" },
+        {
+          type: "actions",
+          buttons: [{ label: "Approve", style: "success", callbackData: "approve" }],
+        },
+        { type: "text", text: "Last" },
+      ],
+    });
+  });
+
+  it("preserves URL-only buttons as Discord link buttons", () => {
+    expect(
+      buildDiscordInteractiveComponents({
+        blocks: [
+          {
+            type: "buttons",
+            buttons: [{ label: "Docs", url: "https://example.com/docs" }],
+          },
+        ],
+      }),
+    ).toEqual({
+      blocks: [
+        {
+          type: "actions",
+          buttons: [{ label: "Docs", style: "link", url: "https://example.com/docs" }],
+        },
+      ],
+    });
+  });
+
+  it("splits long shared button rows to stay within Discord action limits", () => {
+    expect(
+      buildDiscordInteractiveComponents({
+        blocks: [
+          {
+            type: "buttons",
+            buttons: [
+              { label: "One", value: "1" },
+              { label: "Two", value: "2" },
+              { label: "Three", value: "3" },
+              { label: "Four", value: "4" },
+              { label: "Five", value: "5" },
+              { label: "Six", value: "6" },
+            ],
+          },
+        ],
+      }),
+    ).toEqual({
+      blocks: [
+        {
+          type: "actions",
+          buttons: [
+            { label: "One", style: "secondary", callbackData: "1" },
+            { label: "Two", style: "secondary", callbackData: "2" },
+            { label: "Three", style: "secondary", callbackData: "3" },
+            { label: "Four", style: "secondary", callbackData: "4" },
+            { label: "Five", style: "secondary", callbackData: "5" },
+          ],
+        },
+        {
+          type: "actions",
+          buttons: [{ label: "Six", style: "secondary", callbackData: "6" }],
+        },
+      ],
+    });
+  });
+
+  it("does not duplicate presentation text when appending controls", () => {
+    expect(
+      buildDiscordPresentationComponents({
+        title: "Status",
+        blocks: [
+          { type: "text", text: "Build completed" },
+          { type: "context", text: "main branch" },
+          {
+            type: "buttons",
+            buttons: [{ label: "Open", value: "open" }],
+          },
+        ],
+      }),
+    ).toEqual({
+      blocks: [
+        { type: "text", text: "Status" },
+        { type: "text", text: "Build completed" },
+        { type: "text", text: "-# main branch" },
+        {
+          type: "actions",
+          buttons: [{ label: "Open", style: "secondary", callbackData: "open" }],
+        },
+      ],
+    });
+  });
+});

package/src/shared-interactive.ts

@@ -0,0 +1,124 @@
+import {
+  presentationToInteractiveReply,
+  reduceInteractiveReply,
+} from "openclaw/plugin-sdk/interactive-runtime";
+import type {
+  InteractiveButtonStyle,
+  InteractiveReply,
+  MessagePresentation,
+} from "openclaw/plugin-sdk/interactive-runtime";
+import type {
+  DiscordComponentButtonSpec,
+  DiscordComponentButtonStyle,
+  DiscordComponentMessageSpec,
+} from "./components.types.js";
+
+function resolveDiscordInteractiveButtonStyle(
+  style?: InteractiveButtonStyle,
+): DiscordComponentButtonStyle | undefined {
+  return style ?? "secondary";
+}
+
+const DISCORD_INTERACTIVE_BUTTON_ROW_SIZE = 5;
+
+export function buildDiscordInteractiveComponents(
+  interactive?: InteractiveReply,
+): DiscordComponentMessageSpec | undefined {
+  const blocks = reduceInteractiveReply(
+    interactive,
+    [] as NonNullable<DiscordComponentMessageSpec["blocks"]>,
+    (state, block) => {
+      if (block.type === "text") {
+        const text = block.text.trim();
+        if (text) {
+          state.push({ type: "text", text });
+        }
+        return state;
+      }
+      if (block.type === "buttons") {
+        if (block.buttons.length === 0) {
+          return state;
+        }
+        for (
+          let index = 0;
+          index < block.buttons.length;
+          index += DISCORD_INTERACTIVE_BUTTON_ROW_SIZE
+        ) {
+          state.push({
+            type: "actions",
+            buttons: block.buttons
+              .slice(index, index + DISCORD_INTERACTIVE_BUTTON_ROW_SIZE)
+              .map((button) => {
+                const spec: DiscordComponentButtonSpec = {
+                  label: button.label,
+                  style: button.url ? "link" : resolveDiscordInteractiveButtonStyle(button.style),
+                };
+                if (button.value) {
+                  spec.callbackData = button.value;
+                }
+                if (button.url) {
+                  spec.url = button.url;
+                }
+                return spec;
+              }),
+          });
+        }
+        return state;
+      }
+      if (block.type === "select" && block.options.length > 0) {
+        state.push({
+          type: "actions",
+          select: {
+            type: "string",
+            placeholder: block.placeholder,
+            options: block.options.map((option) => ({
+              label: option.label,
+              value: option.value,
+            })),
+          },
+        });
+      }
+      return state;
+    },
+  );
+  return blocks.length > 0 ? { blocks } : undefined;
+}
+
+export function buildDiscordPresentationComponents(
+  presentation?: MessagePresentation,
+): DiscordComponentMessageSpec | undefined {
+  if (!presentation) {
+    return undefined;
+  }
+  const spec: DiscordComponentMessageSpec = { blocks: [] };
+  if (presentation.title) {
+    spec.blocks?.push({ type: "text", text: presentation.title });
+  }
+  for (const block of presentation.blocks) {
+    if (block.type === "text" || block.type === "context") {
+      const text = block.text.trim();
+      if (text) {
+        spec.blocks?.push({
+          type: "text",
+          text: block.type === "context" ? `-# ${text}` : text,
+        });
+      }
+      continue;
+    }
+    if (block.type === "divider") {
+      spec.blocks?.push({ type: "separator" });
+      continue;
+    }
+  }
+  const interactiveSpec = buildDiscordInteractiveComponents(
+    presentationToInteractiveReply({
+      blocks: presentation.blocks.filter(
+        (block) => block.type === "buttons" || block.type === "select",
+      ),
+    }),
+  );
+  if (interactiveSpec?.blocks?.length) {
+    spec.blocks?.push(...interactiveSpec.blocks);
+  }
+  return spec.blocks?.length ? spec : undefined;
+}