@openclaw/discord 2026.3.13 → 2026.5.2-beta.1

package/src/approval-native.test.ts

@@ -0,0 +1,330 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { clearSessionStoreCacheForTest } from "openclaw/plugin-sdk/session-store-runtime";
+import { describe, expect, it } from "vitest";
+import {
+  createDiscordNativeApprovalAdapter,
+  getDiscordApprovalCapability,
+  shouldHandleDiscordApprovalRequest,
+} from "./approval-native.js";
+
+const STORE_PATH = path.join(os.tmpdir(), "openclaw-discord-approval-native-test.json");
+const NATIVE_APPROVAL_CFG = {
+  commands: {
+    ownerAllowFrom: ["discord:555555555"],
+  },
+} as const;
+const NATIVE_DELIVERY_CFG = {
+  ...NATIVE_APPROVAL_CFG,
+  channels: {
+    discord: {
+      execApprovals: {
+        enabled: true,
+      },
+    },
+  },
+} as const;
+
+function writeStore(store: Record<string, unknown>) {
+  fs.writeFileSync(STORE_PATH, `${JSON.stringify(store, null, 2)}\n`, "utf8");
+  clearSessionStoreCacheForTest();
+}
+
+describe("createDiscordNativeApprovalAdapter", () => {
+  it("keeps approval availability enabled when approvers exist but native delivery is off", () => {
+    const adapter = createDiscordNativeApprovalAdapter({
+      enabled: false,
+      approvers: ["555555555"],
+      target: "channel",
+    } as never);
+
+    expect(
+      adapter.auth?.getActionAvailabilityState?.({
+        cfg: NATIVE_APPROVAL_CFG as never,
+        accountId: "main",
+        action: "approve",
+      }),
+    ).toEqual({ kind: "enabled" });
+    expect(
+      adapter.native?.describeDeliveryCapabilities({
+        cfg: NATIVE_APPROVAL_CFG as never,
+        accountId: "main",
+        approvalKind: "exec",
+        request: {
+          id: "approval-1",
+          request: {
+            command: "pwd",
+            turnSourceChannel: "discord",
+            turnSourceTo: "channel:123456789",
+            turnSourceAccountId: "main",
+            sessionKey: "agent:main:discord:channel:123456789",
+          },
+          createdAtMs: 1,
+          expiresAtMs: 2,
+        },
+      }),
+    ).toEqual({
+      enabled: false,
+      preferredSurface: "origin",
+      supportsOriginSurface: true,
+      supportsApproverDmSurface: true,
+      notifyOriginWhenDmOnly: true,
+    });
+  });
+
+  it("honors ownerAllowFrom fallback when gating approval requests", () => {
+    expect(
+      shouldHandleDiscordApprovalRequest({
+        cfg: {
+          commands: {
+            ownerAllowFrom: ["discord:123"],
+          },
+        } as never,
+        accountId: "main",
+        configOverride: { enabled: true } as never,
+        request: {
+          id: "approval-1",
+          request: {
+            command: "pwd",
+            turnSourceChannel: "discord",
+            turnSourceTo: "channel:123456789",
+            turnSourceAccountId: "main",
+          },
+          createdAtMs: 1,
+          expiresAtMs: 2,
+        },
+      }),
+    ).toBe(true);
+  });
+
+  it("describes the correct Discord exec-approval setup path", () => {
+    const text = getDiscordApprovalCapability().describeExecApprovalSetup?.({
+      channel: "discord",
+      channelLabel: "Discord",
+    });
+
+    expect(text).toContain("`channels.discord.execApprovals.approvers`");
+    expect(text).toContain("`commands.ownerAllowFrom`");
+    expect(text).not.toContain("`channels.discord.dm.allowFrom`");
+  });
+
+  it("describes the named-account Discord exec-approval setup path", () => {
+    const text = getDiscordApprovalCapability().describeExecApprovalSetup?.({
+      channel: "discord",
+      channelLabel: "Discord",
+      accountId: "work",
+    });
+
+    expect(text).toContain("`channels.discord.accounts.work.execApprovals.approvers`");
+    expect(text).toContain("`commands.ownerAllowFrom`");
+    expect(text).not.toContain("`channels.discord.execApprovals.approvers`");
+  });
+
+  it("normalizes prefixed turn-source channel ids", async () => {
+    const adapter = createDiscordNativeApprovalAdapter();
+
+    const target = await adapter.native?.resolveOriginTarget?.({
+      cfg: NATIVE_DELIVERY_CFG as never,
+      accountId: "main",
+      approvalKind: "plugin",
+      request: {
+        id: "abc",
+        request: {
+          title: "Plugin approval",
+          description: "Let plugin proceed",
+          turnSourceChannel: "discord",
+          turnSourceTo: "channel:123456789",
+          turnSourceAccountId: "main",
+        },
+        createdAtMs: 1,
+        expiresAtMs: 2,
+      },
+    });
+
+    expect(target).toEqual({ to: "123456789" });
+  });
+
+  it("falls back to approver DMs for Discord DM sessions with raw turn-source ids", async () => {
+    const adapter = createDiscordNativeApprovalAdapter();
+
+    const target = await adapter.native?.resolveOriginTarget?.({
+      cfg: NATIVE_DELIVERY_CFG as never,
+      accountId: "main",
+      approvalKind: "plugin",
+      request: {
+        id: "abc",
+        request: {
+          title: "Plugin approval",
+          description: "Let plugin proceed",
+          sessionKey: "agent:main:discord:dm:123456789",
+          turnSourceChannel: "discord",
+          turnSourceTo: "123456789",
+          turnSourceAccountId: "main",
+        },
+        createdAtMs: 1,
+        expiresAtMs: 2,
+      },
+    });
+
+    expect(target).toBeNull();
+  });
+
+  it("ignores session-store turn targets for Discord DM sessions", async () => {
+    writeStore({
+      "agent:main:discord:dm:123456789": {
+        sessionId: "sess",
+        updatedAt: Date.now(),
+        origin: { provider: "discord", to: "123456789", accountId: "main" },
+        lastChannel: "discord",
+        lastTo: "123456789",
+        lastAccountId: "main",
+      },
+    });
+
+    const adapter = createDiscordNativeApprovalAdapter();
+    const target = await adapter.native?.resolveOriginTarget?.({
+      cfg: {
+        ...NATIVE_DELIVERY_CFG,
+        session: { store: STORE_PATH },
+      } as never,
+      accountId: "main",
+      approvalKind: "plugin",
+      request: {
+        id: "abc",
+        request: {
+          title: "Plugin approval",
+          description: "Let plugin proceed",
+          sessionKey: "agent:main:discord:dm:123456789",
+          turnSourceChannel: "discord",
+          turnSourceTo: "123456789",
+          turnSourceAccountId: "main",
+        },
+        createdAtMs: 1,
+        expiresAtMs: 2,
+      },
+    });
+
+    expect(target).toBeNull();
+  });
+
+  it("accepts raw turn-source ids when a Discord channel session backs them", async () => {
+    const adapter = createDiscordNativeApprovalAdapter();
+
+    const target = await adapter.native?.resolveOriginTarget?.({
+      cfg: NATIVE_DELIVERY_CFG as never,
+      accountId: "main",
+      approvalKind: "plugin",
+      request: {
+        id: "abc",
+        request: {
+          title: "Plugin approval",
+          description: "Let plugin proceed",
+          sessionKey: "agent:main:discord:channel:123456789",
+          turnSourceChannel: "discord",
+          turnSourceTo: "123456789",
+          turnSourceAccountId: "main",
+        },
+        createdAtMs: 1,
+        expiresAtMs: 2,
+      },
+    });
+
+    expect(target).toEqual({ to: "123456789", threadId: undefined });
+  });
+
+  it("falls back to extracting the channel id from the session key", async () => {
+    const adapter = createDiscordNativeApprovalAdapter();
+
+    const target = await adapter.native?.resolveOriginTarget?.({
+      cfg: NATIVE_DELIVERY_CFG as never,
+      accountId: "main",
+      approvalKind: "plugin",
+      request: {
+        id: "abc",
+        request: {
+          title: "Plugin approval",
+          description: "Let plugin proceed",
+          sessionKey: "agent:main:discord:channel:987654321",
+        },
+        createdAtMs: 1,
+        expiresAtMs: 2,
+      },
+    });
+
+    expect(target).toEqual({ to: "987654321", threadId: undefined });
+  });
+
+  it("preserves explicit turn-source thread ids on origin targets", async () => {
+    const adapter = createDiscordNativeApprovalAdapter();
+
+    const target = await adapter.native?.resolveOriginTarget?.({
+      cfg: NATIVE_DELIVERY_CFG as never,
+      accountId: "main",
+      approvalKind: "plugin",
+      request: {
+        id: "abc",
+        request: {
+          title: "Plugin approval",
+          description: "Let plugin proceed",
+          sessionKey: "agent:main:discord:channel:123456789:thread:777888999",
+          turnSourceChannel: "discord",
+          turnSourceTo: "channel:123456789",
+          turnSourceThreadId: "777888999",
+          turnSourceAccountId: "main",
+        },
+        createdAtMs: 1,
+        expiresAtMs: 2,
+      },
+    });
+
+    expect(target).toEqual({ to: "123456789", threadId: "777888999" });
+  });
+
+  it("falls back to extracting thread ids from the session key", async () => {
+    const adapter = createDiscordNativeApprovalAdapter();
+
+    const target = await adapter.native?.resolveOriginTarget?.({
+      cfg: NATIVE_DELIVERY_CFG as never,
+      accountId: "main",
+      approvalKind: "plugin",
+      request: {
+        id: "abc",
+        request: {
+          title: "Plugin approval",
+          description: "Let plugin proceed",
+          sessionKey: "agent:main:discord:channel:987654321:thread:444555666",
+        },
+        createdAtMs: 1,
+        expiresAtMs: 2,
+      },
+    });
+
+    expect(target).toEqual({ to: "987654321", threadId: "444555666" });
+  });
+
+  it("rejects origin delivery for requests bound to another Discord account", async () => {
+    const adapter = createDiscordNativeApprovalAdapter();
+
+    const target = await adapter.native?.resolveOriginTarget?.({
+      cfg: NATIVE_APPROVAL_CFG as never,
+      accountId: "main",
+      approvalKind: "plugin",
+      request: {
+        id: "abc",
+        request: {
+          title: "Plugin approval",
+          description: "Let plugin proceed",
+          turnSourceChannel: "discord",
+          turnSourceTo: "channel:123456789",
+          turnSourceAccountId: "other",
+          sessionKey: "agent:main:missing",
+        },
+        createdAtMs: 1,
+        expiresAtMs: 2,
+      },
+    });
+
+    expect(target).toBeNull();
+  });
+});

package/src/approval-native.ts

@@ -0,0 +1,219 @@
+import { createLazyChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
+import type { ChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-runtime";
+import { resolveApprovalRequestSessionConversation } from "openclaw/plugin-sdk/approval-native-runtime";
+import type { ChannelApprovalCapability } from "openclaw/plugin-sdk/channel-contract";
+import type { DiscordExecApprovalConfig } from "openclaw/plugin-sdk/config-types";
+import {
+  normalizeLowercaseStringOrEmpty,
+  normalizeOptionalString,
+} from "openclaw/plugin-sdk/text-runtime";
+export { shouldHandleDiscordApprovalRequest } from "./approval-shared.js";
+import { listDiscordAccountIds, resolveDiscordAccount } from "./accounts.js";
+import {
+  createChannelApproverDmTargetResolver,
+  createChannelNativeOriginTargetResolver,
+  createApproverRestrictedNativeApprovalCapability,
+  splitChannelApprovalCapability,
+} from "./approval-runtime.js";
+import { shouldHandleDiscordApprovalRequest } from "./approval-shared.js";
+import {
+  getDiscordExecApprovalApprovers,
+  isDiscordExecApprovalApprover,
+  isDiscordExecApprovalClientEnabled,
+} from "./exec-approvals.js";
+
+// Legacy export kept for monitor test/support surfaces; native routing now uses
+// the shared session-conversation fallback helper instead.
+export function extractDiscordChannelId(sessionKey?: string | null): string | null {
+  if (!sessionKey) {
+    return null;
+  }
+  const match = sessionKey.match(/discord:(?:channel|group):(\d+)/);
+  return match ? match[1] : null;
+}
+
+function extractDiscordSessionKind(sessionKey?: string | null): "channel" | "group" | "dm" | null {
+  if (!sessionKey) {
+    return null;
+  }
+  const match = sessionKey.match(/discord:(channel|group|dm):/);
+  if (!match) {
+    return null;
+  }
+  return match[1] as "channel" | "group" | "dm";
+}
+
+function normalizeDiscordOriginChannelId(value?: string | null): string | null {
+  if (!value) {
+    return null;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const prefixed = trimmed.match(/^(?:channel|group):(\d+)$/i);
+  if (prefixed) {
+    return prefixed[1];
+  }
+  return /^\d+$/.test(trimmed) ? trimmed : null;
+}
+
+function normalizeDiscordThreadId(value?: string | number | null): string | undefined {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? String(value) : undefined;
+  }
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const normalized = value.trim();
+  return /^\d+$/.test(normalized) ? normalized : undefined;
+}
+
+function createDiscordOriginTargetResolver(configOverride?: DiscordExecApprovalConfig | null) {
+  return createChannelNativeOriginTargetResolver({
+    channel: "discord",
+    shouldHandleRequest: ({ cfg, accountId, request }) =>
+      shouldHandleDiscordApprovalRequest({
+        cfg,
+        accountId,
+        request,
+        configOverride,
+      }),
+    resolveTurnSourceTarget: (request) => {
+      const sessionConversation = resolveApprovalRequestSessionConversation({
+        request,
+        channel: "discord",
+        bundledFallback: false,
+      });
+      const sessionKind = extractDiscordSessionKind(
+        normalizeOptionalString(request.request.sessionKey) ?? null,
+      );
+      const turnSourceChannel = normalizeLowercaseStringOrEmpty(request.request.turnSourceChannel);
+      const rawTurnSourceTo = normalizeOptionalString(request.request.turnSourceTo) ?? "";
+      const turnSourceTo = normalizeDiscordOriginChannelId(rawTurnSourceTo);
+      const threadId =
+        normalizeDiscordThreadId(request.request.turnSourceThreadId) ??
+        normalizeDiscordThreadId(sessionConversation?.threadId) ??
+        undefined;
+      const hasExplicitOriginTarget = /^(?:channel|group):/i.test(rawTurnSourceTo);
+      if (turnSourceChannel !== "discord" || !turnSourceTo || sessionKind === "dm") {
+        return null;
+      }
+      return hasExplicitOriginTarget || sessionKind === "channel" || sessionKind === "group"
+        ? { to: turnSourceTo, threadId }
+        : null;
+    },
+    resolveSessionTarget: (sessionTarget, request) => {
+      const sessionConversation = resolveApprovalRequestSessionConversation({
+        request,
+        channel: "discord",
+        bundledFallback: false,
+      });
+      const sessionKind = extractDiscordSessionKind(request.request.sessionKey?.trim() || null);
+      if (sessionKind === "dm") {
+        return null;
+      }
+      const targetTo = normalizeDiscordOriginChannelId(sessionTarget.to);
+      return targetTo
+        ? {
+            to: targetTo,
+            threadId:
+              normalizeDiscordThreadId(sessionTarget.threadId) ??
+              normalizeDiscordThreadId(sessionConversation?.threadId) ??
+              undefined,
+          }
+        : null;
+    },
+    resolveFallbackTarget: (request) => {
+      const sessionConversation = resolveApprovalRequestSessionConversation({
+        request,
+        channel: "discord",
+        bundledFallback: false,
+      });
+      const sessionKind = extractDiscordSessionKind(request.request.sessionKey?.trim() || null);
+      if (sessionKind === "dm") {
+        return null;
+      }
+      const fallbackChannelId = normalizeDiscordOriginChannelId(sessionConversation?.id);
+      return fallbackChannelId
+        ? {
+            to: fallbackChannelId,
+            threadId: normalizeDiscordThreadId(sessionConversation?.threadId) ?? undefined,
+          }
+        : null;
+    },
+  });
+}
+
+function createDiscordApproverDmTargetResolver(configOverride?: DiscordExecApprovalConfig | null) {
+  return createChannelApproverDmTargetResolver({
+    shouldHandleRequest: ({ cfg, accountId, request }) =>
+      shouldHandleDiscordApprovalRequest({
+        cfg,
+        accountId,
+        request,
+        configOverride,
+      }),
+    resolveApprovers: ({ cfg, accountId }) =>
+      getDiscordExecApprovalApprovers({ cfg, accountId, configOverride }),
+    mapApprover: (approver) => ({ to: approver }),
+  });
+}
+
+function createDiscordApprovalCapability(configOverride?: DiscordExecApprovalConfig | null) {
+  return createApproverRestrictedNativeApprovalCapability({
+    channel: "discord",
+    channelLabel: "Discord",
+    describeExecApprovalSetup: ({
+      accountId,
+    }: Parameters<NonNullable<ChannelApprovalCapability["describeExecApprovalSetup"]>>[0]) => {
+      const prefix =
+        accountId && accountId !== "default"
+          ? `channels.discord.accounts.${accountId}`
+          : "channels.discord";
+      return `Approve it from the Web UI or terminal UI for now. Discord supports native exec approvals for this account. Configure \`${prefix}.execApprovals.approvers\` or \`commands.ownerAllowFrom\`; set \`${prefix}.execApprovals.enabled\` to \`auto\` or \`true\`.`;
+    },
+    listAccountIds: listDiscordAccountIds,
+    hasApprovers: ({ cfg, accountId }) =>
+      getDiscordExecApprovalApprovers({ cfg, accountId, configOverride }).length > 0,
+    isExecAuthorizedSender: ({ cfg, accountId, senderId }) =>
+      isDiscordExecApprovalApprover({ cfg, accountId, senderId, configOverride }),
+    isNativeDeliveryEnabled: ({ cfg, accountId }) =>
+      isDiscordExecApprovalClientEnabled({ cfg, accountId, configOverride }),
+    resolveNativeDeliveryMode: ({ cfg, accountId }) =>
+      configOverride?.target ??
+      resolveDiscordAccount({ cfg, accountId }).config.execApprovals?.target ??
+      "dm",
+    resolveOriginTarget: createDiscordOriginTargetResolver(configOverride),
+    resolveApproverDmTargets: createDiscordApproverDmTargetResolver(configOverride),
+    notifyOriginWhenDmOnly: true,
+    nativeRuntime: createLazyChannelApprovalNativeRuntimeAdapter({
+      eventKinds: ["exec", "plugin"],
+      isConfigured: ({ cfg, accountId }) =>
+        isDiscordExecApprovalClientEnabled({ cfg, accountId, configOverride }),
+      shouldHandle: ({ cfg, accountId, request }) =>
+        shouldHandleDiscordApprovalRequest({
+          cfg,
+          accountId,
+          request,
+          configOverride,
+        }),
+      load: async () =>
+        (await import("./approval-handler.runtime.js"))
+          .discordApprovalNativeRuntime as unknown as ChannelApprovalNativeRuntimeAdapter,
+    }),
+  });
+}
+
+export function createDiscordNativeApprovalAdapter(
+  configOverride?: DiscordExecApprovalConfig | null,
+) {
+  return splitChannelApprovalCapability(createDiscordApprovalCapability(configOverride));
+}
+
+let cachedDiscordApprovalCapability: ReturnType<typeof createDiscordApprovalCapability> | undefined;
+
+export function getDiscordApprovalCapability() {
+  cachedDiscordApprovalCapability ??= createDiscordApprovalCapability();
+  return cachedDiscordApprovalCapability;
+}

package/src/approval-runtime.ts

@@ -0,0 +1,14 @@
+export {
+  isChannelExecApprovalClientEnabledFromConfig,
+  matchesApprovalRequestFilters,
+  getExecApprovalReplyMetadata,
+} from "openclaw/plugin-sdk/approval-client-runtime";
+export { resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
+export {
+  createApproverRestrictedNativeApprovalCapability,
+  splitChannelApprovalCapability,
+} from "openclaw/plugin-sdk/approval-delivery-runtime";
+export {
+  createChannelApproverDmTargetResolver,
+  createChannelNativeOriginTargetResolver,
+} from "openclaw/plugin-sdk/approval-native-runtime";

package/src/approval-shared.ts

@@ -0,0 +1,53 @@
+import { doesApprovalRequestMatchChannelAccount } from "openclaw/plugin-sdk/approval-native-runtime";
+import type {
+  ExecApprovalRequest,
+  PluginApprovalRequest,
+} from "openclaw/plugin-sdk/approval-runtime";
+import type { DiscordExecApprovalConfig, OpenClawConfig } from "openclaw/plugin-sdk/config-types";
+import { resolveDiscordAccount } from "./accounts.js";
+import {
+  isChannelExecApprovalClientEnabledFromConfig,
+  matchesApprovalRequestFilters,
+} from "./approval-runtime.js";
+import { getDiscordExecApprovalApprovers } from "./exec-approvals.js";
+
+type ApprovalRequest = ExecApprovalRequest | PluginApprovalRequest;
+
+export function shouldHandleDiscordApprovalRequest(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+  request: ApprovalRequest;
+  configOverride?: DiscordExecApprovalConfig | null;
+}): boolean {
+  const config =
+    params.configOverride ??
+    resolveDiscordAccount({ cfg: params.cfg, accountId: params.accountId }).config.execApprovals;
+  const approvers = getDiscordExecApprovalApprovers({
+    cfg: params.cfg,
+    accountId: params.accountId,
+    configOverride: params.configOverride,
+  });
+  if (
+    !doesApprovalRequestMatchChannelAccount({
+      cfg: params.cfg,
+      request: params.request,
+      channel: "discord",
+      accountId: params.accountId,
+    })
+  ) {
+    return false;
+  }
+  if (
+    !isChannelExecApprovalClientEnabledFromConfig({
+      enabled: config?.enabled,
+      approverCount: approvers.length,
+    })
+  ) {
+    return false;
+  }
+  return matchesApprovalRequestFilters({
+    request: params.request.request,
+    agentFilter: config?.agentFilter,
+    sessionFilter: config?.sessionFilter,
+  });
+}