@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/src/setup-runtime-helpers.ts

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

package/src/setup-surface.test.ts

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

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

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

@@ -1,124 +0,0 @@
-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;
-}