@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/src/monitor/provider.deploy.ts

@@ -1,221 +0,0 @@
-import { warn, type RuntimeEnv } from "openclaw/plugin-sdk/runtime-env";
-import { formatErrorMessage } from "openclaw/plugin-sdk/ssrf-runtime";
-import { Client, overwriteApplicationCommands, type RequestClient } from "../internal/discord.js";
-import {
-  attachDiscordDeployRestContext,
-  attachDiscordDeployRequestBody,
-  formatDiscordDeployErrorDetails,
-  formatDiscordDeployErrorMessage,
-  formatDiscordDeployRateLimitDetails,
-  formatDiscordDeployRateLimitWarning,
-  isDiscordDeployDailyCreateLimit,
-} from "./provider.deploy-errors.js";
-import { logDiscordStartupPhase } from "./provider.startup-log.js";
-
-type RestMethodName = "get" | "post" | "put" | "patch" | "delete";
-type RestMethod = RequestClient[RestMethodName];
-type RestMethodMap = Record<RestMethodName, RestMethod>;
-
-function readDeployRequestBody(data?: unknown): unknown {
-  return data && typeof data === "object" && "body" in data
-    ? (data as { body?: unknown }).body
-    : undefined;
-}
-
-function wrapDeployRestMethod(params: {
-  method: RestMethodName;
-  original: RestMethodMap;
-  runtime: RuntimeEnv;
-  accountId: string;
-  startupStartedAt: number;
-  timeoutMs?: number;
-  shouldLogVerbose: () => boolean;
-}) {
-  return async (path: string, data?: never, query?: never) => {
-    const startedAt = Date.now();
-    const body = readDeployRequestBody(data);
-    const commandCount = Array.isArray(body) ? body.length : undefined;
-    const bodyBytes =
-      body === undefined
-        ? undefined
-        : Buffer.byteLength(typeof body === "string" ? body : JSON.stringify(body), "utf8");
-    if (params.shouldLogVerbose()) {
-      params.runtime.log?.(
-        `discord startup [${params.accountId}] native-slash-command-deploy-rest:${params.method}:start ${Math.max(0, Date.now() - params.startupStartedAt)}ms path=${path}${typeof commandCount === "number" ? ` commands=${commandCount}` : ""}${typeof bodyBytes === "number" ? ` bytes=${bodyBytes}` : ""}`,
-      );
-    }
-    try {
-      const result = await params.original[params.method](path, data, query);
-      if (params.shouldLogVerbose()) {
-        params.runtime.log?.(
-          `discord startup [${params.accountId}] native-slash-command-deploy-rest:${params.method}:done ${Math.max(0, Date.now() - params.startupStartedAt)}ms path=${path} requestMs=${Date.now() - startedAt}`,
-        );
-      }
-      return result;
-    } catch (err) {
-      const requestMs = Date.now() - startedAt;
-      attachDiscordDeployRequestBody(err, body);
-      attachDiscordDeployRestContext(err, {
-        method: params.method,
-        path,
-        requestMs,
-        timeoutMs: params.timeoutMs,
-      });
-      const rateLimitDetails = formatDiscordDeployRateLimitDetails(err);
-      if (rateLimitDetails) {
-        if (params.shouldLogVerbose()) {
-          params.runtime.log?.(
-            warn(
-              `discord startup [${params.accountId}] native-slash-command-deploy-rest:${params.method}:rate-limited ${Math.max(0, Date.now() - params.startupStartedAt)}ms path=${path} requestMs=${requestMs}${rateLimitDetails}`,
-            ),
-          );
-        }
-      } else {
-        const details = formatDiscordDeployErrorDetails(err);
-        params.runtime.error?.(
-          `discord startup [${params.accountId}] native-slash-command-deploy-rest:${params.method}:error ${Math.max(0, Date.now() - params.startupStartedAt)}ms path=${path} requestMs=${requestMs} error=${formatDiscordDeployErrorMessage(err)}${details}`,
-        );
-      }
-      throw err;
-    }
-  };
-}
-
-function installDeployRestLogging(params: {
-  rest: RequestClient;
-  runtime: RuntimeEnv;
-  accountId: string;
-  startupStartedAt: number;
-  shouldLogVerbose: () => boolean;
-}): () => void {
-  const original: RestMethodMap = {
-    get: params.rest.get.bind(params.rest),
-    post: params.rest.post.bind(params.rest),
-    put: params.rest.put.bind(params.rest),
-    patch: params.rest.patch.bind(params.rest),
-    delete: params.rest.delete.bind(params.rest),
-  };
-  for (const method of Object.keys(original) as RestMethodName[]) {
-    const timeout = (params.rest as { options?: { timeout?: unknown } }).options?.timeout;
-    params.rest[method] = wrapDeployRestMethod({
-      method,
-      original,
-      runtime: params.runtime,
-      accountId: params.accountId,
-      startupStartedAt: params.startupStartedAt,
-      timeoutMs: typeof timeout === "number" ? timeout : undefined,
-      shouldLogVerbose: params.shouldLogVerbose,
-    }) as RequestClient[typeof method];
-  }
-  return () => {
-    params.rest.get = original.get;
-    params.rest.post = original.post;
-    params.rest.put = original.put;
-    params.rest.patch = original.patch;
-    params.rest.delete = original.delete;
-  };
-}
-
-async function deployDiscordCommands(params: {
-  client: Client;
-  runtime: RuntimeEnv;
-  enabled: boolean;
-  accountId?: string;
-  startupStartedAt?: number;
-  shouldLogVerbose: () => boolean;
-}) {
-  if (!params.enabled) {
-    return;
-  }
-  const startupStartedAt = params.startupStartedAt ?? Date.now();
-  const accountId = params.accountId ?? "default";
-  const restoreDeployRestLogging = installDeployRestLogging({
-    rest: params.client.rest,
-    runtime: params.runtime,
-    accountId,
-    startupStartedAt,
-    shouldLogVerbose: params.shouldLogVerbose,
-  });
-  try {
-    try {
-      await params.client.deployCommands({ mode: "reconcile" });
-      return;
-    } catch (err) {
-      if (isDiscordDeployDailyCreateLimit(err)) {
-        params.runtime.log?.(
-          warn(
-            `discord: native slash command deploy skipped for ${accountId}; daily application command create limit reached. Existing slash commands stay active until Discord resets the quota. Message send/receive is unaffected.`,
-          ),
-        );
-        return;
-      }
-      const rateLimitWarning = formatDiscordDeployRateLimitWarning(err, accountId);
-      if (rateLimitWarning) {
-        params.runtime.log?.(warn(rateLimitWarning));
-        return;
-      }
-      throw err;
-    }
-  } catch (err) {
-    params.runtime.log?.(
-      warn(
-        `discord: native slash command deploy warning (not message send): ${formatDiscordDeployErrorMessage(err)}${formatDiscordDeployErrorDetails(err)}`,
-      ),
-    );
-  } finally {
-    restoreDeployRestLogging();
-  }
-}
-
-export function runDiscordCommandDeployInBackground(params: {
-  client: Client;
-  runtime: RuntimeEnv;
-  enabled: boolean;
-  accountId: string;
-  startupStartedAt: number;
-  shouldLogVerbose: () => boolean;
-  isVerbose: () => boolean;
-}) {
-  if (!params.enabled) {
-    return;
-  }
-  logDiscordStartupPhase({
-    runtime: params.runtime,
-    accountId: params.accountId,
-    phase: "deploy-commands:scheduled",
-    startAt: params.startupStartedAt,
-    details: "mode=reconcile background=true",
-    isVerbose: params.isVerbose,
-  });
-  void deployDiscordCommands(params)
-    .then(() => {
-      logDiscordStartupPhase({
-        runtime: params.runtime,
-        accountId: params.accountId,
-        phase: "deploy-commands:done",
-        startAt: params.startupStartedAt,
-        details: "background=true",
-        isVerbose: params.isVerbose,
-      });
-    })
-    .catch((err: unknown) => {
-      params.runtime.log?.(
-        warn(
-          `discord: native slash command deploy background warning (not message send): ${formatErrorMessage(err)}`,
-        ),
-      );
-    });
-}
-
-export async function clearDiscordNativeCommands(params: {
-  client: Client;
-  applicationId: string;
-  runtime: RuntimeEnv;
-}) {
-  try {
-    await overwriteApplicationCommands(params.client.rest, params.applicationId, []);
-    params.runtime.log?.("discord: cleared native commands (commands.native=false)");
-  } catch (err) {
-    params.runtime.error?.(`discord: failed to clear native commands: ${String(err)}`);
-  }
-}

package/src/monitor/provider.interactions.ts

@@ -1,160 +0,0 @@
-import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
-import type { ChannelRuntimeSurface } from "openclaw/plugin-sdk/channel-contract";
-import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
-import type { NativeCommandSpec } from "openclaw/plugin-sdk/command-auth";
-import type { DiscordAccountConfig, OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import type { RuntimeEnv } from "openclaw/plugin-sdk/runtime-env";
-import { isDiscordExecApprovalClientEnabled } from "../exec-approvals.js";
-import {
-  type BaseCommand,
-  type BaseMessageInteractiveComponent,
-  type Modal,
-} from "../internal/discord.js";
-import { createDiscordVoiceCommand } from "../voice/command.js";
-import {
-  createAgentComponentControls,
-  createDiscordComponentControls,
-  createDiscordComponentModal,
-} from "./agent-components.js";
-import {
-  createDiscordExecApprovalButtonContext,
-  createExecApprovalButton,
-} from "./exec-approvals.js";
-import {
-  createDiscordCommandArgFallbackButton,
-  createDiscordModelPickerFallbackButton,
-  createDiscordModelPickerFallbackSelect,
-  createDiscordNativeCommand,
-} from "./native-command.js";
-import type { ThreadBindingManager } from "./thread-bindings.types.js";
-
-type DiscordVoiceManager = import("../voice/manager.js").DiscordVoiceManager;
-
-export function createDiscordProviderInteractionSurface(params: {
-  cfg: OpenClawConfig;
-  discordConfig: DiscordAccountConfig;
-  accountId: string;
-  token: string;
-  commandSpecs: NativeCommandSpec[];
-  nativeEnabled: boolean;
-  voiceEnabled: boolean;
-  groupPolicy: "open" | "disabled" | "allowlist";
-  useAccessGroups: boolean;
-  sessionPrefix: string;
-  ephemeralDefault: boolean;
-  threadBindings: ThreadBindingManager;
-  voiceManagerRef: { current: DiscordVoiceManager | null };
-  guildEntries: DiscordAccountConfig["guilds"];
-  allowFrom: DiscordAccountConfig["allowFrom"];
-  dmPolicy: NonNullable<DiscordAccountConfig["dmPolicy"]>;
-  runtime: RuntimeEnv;
-  channelRuntime?: ChannelRuntimeSurface;
-  abortSignal?: AbortSignal;
-  createNativeCommand?: typeof createDiscordNativeCommand;
-}): {
-  commands: BaseCommand[];
-  components: BaseMessageInteractiveComponent[];
-  modals: Modal[];
-} {
-  const createNativeCommand = params.createNativeCommand ?? createDiscordNativeCommand;
-  const commands: BaseCommand[] = params.commandSpecs.map((spec) =>
-    createNativeCommand({
-      command: spec,
-      cfg: params.cfg,
-      discordConfig: params.discordConfig,
-      accountId: params.accountId,
-      sessionPrefix: params.sessionPrefix,
-      ephemeralDefault: params.ephemeralDefault,
-      threadBindings: params.threadBindings,
-    }),
-  );
-  if (params.nativeEnabled && params.voiceEnabled) {
-    commands.push(
-      createDiscordVoiceCommand({
-        cfg: params.cfg,
-        discordConfig: params.discordConfig,
-        accountId: params.accountId,
-        groupPolicy: params.groupPolicy,
-        useAccessGroups: params.useAccessGroups,
-        getManager: () => params.voiceManagerRef.current,
-        ephemeralDefault: params.ephemeralDefault,
-      }),
-    );
-  }
-
-  const execApprovalsConfig = params.discordConfig.execApprovals ?? {};
-  const execApprovalsEnabled = isDiscordExecApprovalClientEnabled({
-    cfg: params.cfg,
-    accountId: params.accountId,
-    configOverride: execApprovalsConfig,
-  });
-  if (execApprovalsEnabled) {
-    registerChannelRuntimeContext({
-      channelRuntime: params.channelRuntime,
-      channelId: "discord",
-      accountId: params.accountId,
-      capability: CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY,
-      context: {
-        token: params.token,
-        config: execApprovalsConfig,
-      },
-      abortSignal: params.abortSignal,
-    });
-  }
-
-  const components: BaseMessageInteractiveComponent[] = [
-    createDiscordCommandArgFallbackButton({
-      cfg: params.cfg,
-      discordConfig: params.discordConfig,
-      accountId: params.accountId,
-      sessionPrefix: params.sessionPrefix,
-      threadBindings: params.threadBindings,
-    }),
-    createDiscordModelPickerFallbackButton({
-      cfg: params.cfg,
-      discordConfig: params.discordConfig,
-      accountId: params.accountId,
-      sessionPrefix: params.sessionPrefix,
-      threadBindings: params.threadBindings,
-    }),
-    createDiscordModelPickerFallbackSelect({
-      cfg: params.cfg,
-      discordConfig: params.discordConfig,
-      accountId: params.accountId,
-      sessionPrefix: params.sessionPrefix,
-      threadBindings: params.threadBindings,
-    }),
-  ];
-  const modals: Modal[] = [];
-
-  if (execApprovalsEnabled) {
-    components.push(
-      createExecApprovalButton(
-        createDiscordExecApprovalButtonContext({
-          cfg: params.cfg,
-          accountId: params.accountId,
-          config: execApprovalsConfig,
-        }),
-      ),
-    );
-  }
-
-  const agentComponentsConfig = params.discordConfig.agentComponents ?? {};
-  if (agentComponentsConfig.enabled ?? true) {
-    const componentContext = {
-      cfg: params.cfg,
-      discordConfig: params.discordConfig,
-      accountId: params.accountId,
-      guildEntries: params.guildEntries,
-      allowFrom: params.allowFrom,
-      dmPolicy: params.dmPolicy,
-      runtime: params.runtime,
-      token: params.token,
-    };
-    components.push(...createAgentComponentControls.map((create) => create(componentContext)));
-    components.push(...createDiscordComponentControls.map((create) => create(componentContext)));
-    modals.push(createDiscordComponentModal(componentContext));
-  }
-
-  return { commands, components, modals };
-}