@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/src/approval-native.test.ts

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

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

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

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