@gakr-gakr/discord 0.1.0

package/src/doctor.ts

@@ -0,0 +1,340 @@
+import { type ChannelDoctorAdapter } from "autobot/plugin-sdk/channel-contract";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { collectProviderDangerousNameMatchingScopes } from "autobot/plugin-sdk/runtime-doctor";
+import { normalizeOptionalString } from "autobot/plugin-sdk/string-coerce-runtime";
+import { inspectDiscordAccount } from "./account-inspect.js";
+import { resolveDefaultDiscordAccountId } from "./accounts.js";
+import { normalizeCompatibilityConfig as normalizeDiscordCompatibilityConfig } from "./doctor-contract.js";
+import { DISCORD_LEGACY_CONFIG_RULES } from "./doctor-shared.js";
+import { isDiscordMutableAllowEntry } from "./security-doctor.js";
+
+type DiscordNumericIdHit = { path: string; entry: number; safe: boolean };
+
+type DiscordIdListRef = {
+  pathLabel: string;
+  holder: Record<string, unknown>;
+  key: string;
+};
+
+function asObjectRecord(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+function sanitizeForLog(value: string): string {
+  return value.replace(/\p{Cc}+/gu, " ").trim();
+}
+
+function collectDiscordAccountScopes(
+  cfg: AutoBotConfig,
+): Array<{ prefix: string; account: Record<string, unknown> }> {
+  const scopes: Array<{ prefix: string; account: Record<string, unknown> }> = [];
+  const discord = asObjectRecord(cfg.channels?.discord);
+  if (!discord) {
+    return scopes;
+  }
+
+  scopes.push({ prefix: "channels.discord", account: discord });
+  const accounts = asObjectRecord(discord.accounts);
+  if (!accounts) {
+    return scopes;
+  }
+  for (const key of Object.keys(accounts)) {
+    const account = asObjectRecord(accounts[key]);
+    if (account) {
+      scopes.push({ prefix: `channels.discord.accounts.${key}`, account });
+    }
+  }
+  return scopes;
+}
+
+function collectDiscordIdLists(
+  prefix: string,
+  account: Record<string, unknown>,
+): DiscordIdListRef[] {
+  const refs: DiscordIdListRef[] = [
+    { pathLabel: `${prefix}.allowFrom`, holder: account, key: "allowFrom" },
+  ];
+  const dm = asObjectRecord(account.dm);
+  if (dm) {
+    refs.push({ pathLabel: `${prefix}.dm.allowFrom`, holder: dm, key: "allowFrom" });
+    refs.push({ pathLabel: `${prefix}.dm.groupChannels`, holder: dm, key: "groupChannels" });
+  }
+  const execApprovals = asObjectRecord(account.execApprovals);
+  if (execApprovals) {
+    refs.push({
+      pathLabel: `${prefix}.execApprovals.approvers`,
+      holder: execApprovals,
+      key: "approvers",
+    });
+  }
+  const guilds = asObjectRecord(account.guilds);
+  if (!guilds) {
+    return refs;
+  }
+  for (const guildId of Object.keys(guilds)) {
+    const guild = asObjectRecord(guilds[guildId]);
+    if (!guild) {
+      continue;
+    }
+    refs.push({ pathLabel: `${prefix}.guilds.${guildId}.users`, holder: guild, key: "users" });
+    refs.push({ pathLabel: `${prefix}.guilds.${guildId}.roles`, holder: guild, key: "roles" });
+    const channels = asObjectRecord(guild.channels);
+    if (!channels) {
+      continue;
+    }
+    for (const channelId of Object.keys(channels)) {
+      const channel = asObjectRecord(channels[channelId]);
+      if (!channel) {
+        continue;
+      }
+      refs.push({
+        pathLabel: `${prefix}.guilds.${guildId}.channels.${channelId}.users`,
+        holder: channel,
+        key: "users",
+      });
+      refs.push({
+        pathLabel: `${prefix}.guilds.${guildId}.channels.${channelId}.roles`,
+        holder: channel,
+        key: "roles",
+      });
+    }
+  }
+  return refs;
+}
+
+export function scanDiscordNumericIdEntries(cfg: AutoBotConfig): DiscordNumericIdHit[] {
+  const hits: DiscordNumericIdHit[] = [];
+  const scanList = (pathLabel: string, list: unknown) => {
+    if (!Array.isArray(list)) {
+      return;
+    }
+    for (const [index, entry] of list.entries()) {
+      if (typeof entry !== "number") {
+        continue;
+      }
+      hits.push({
+        path: `${pathLabel}[${index}]`,
+        entry,
+        safe: Number.isSafeInteger(entry) && entry >= 0,
+      });
+    }
+  };
+
+  for (const scope of collectDiscordAccountScopes(cfg)) {
+    for (const ref of collectDiscordIdLists(scope.prefix, scope.account)) {
+      scanList(ref.pathLabel, ref.holder[ref.key]);
+    }
+  }
+  return hits;
+}
+
+export function collectDiscordNumericIdWarnings(params: {
+  hits: DiscordNumericIdHit[];
+  doctorFixCommand: string;
+}): string[] {
+  if (params.hits.length === 0) {
+    return [];
+  }
+  const hitsByListPath = new Map<string, DiscordNumericIdHit[]>();
+  for (const hit of params.hits) {
+    const listPath = hit.path.replace(/\[\d+\]$/, "");
+    const existing = hitsByListPath.get(listPath);
+    if (existing) {
+      existing.push(hit);
+    } else {
+      hitsByListPath.set(listPath, [hit]);
+    }
+  }
+
+  const repairableHits: DiscordNumericIdHit[] = [];
+  const blockedHits: DiscordNumericIdHit[] = [];
+  for (const hits of hitsByListPath.values()) {
+    if (hits.some((hit) => !hit.safe)) {
+      blockedHits.push(...hits);
+    } else {
+      repairableHits.push(...hits);
+    }
+  }
+
+  const lines: string[] = [];
+  if (repairableHits.length > 0) {
+    const sample = repairableHits[0];
+    lines.push(
+      `- Discord allowlists contain ${repairableHits.length} numeric ${repairableHits.length === 1 ? "entry" : "entries"} (e.g. ${sanitizeForLog(sample.path)}=${sanitizeForLog(String(sample.entry))}).`,
+      `- Discord IDs must be strings; run "${params.doctorFixCommand}" to convert numeric IDs to quoted strings.`,
+    );
+  }
+  if (blockedHits.length > 0) {
+    const sample = blockedHits[0];
+    lines.push(
+      `- Discord allowlists contain ${blockedHits.length} numeric ${blockedHits.length === 1 ? "entry" : "entries"} in lists that cannot be auto-repaired (e.g. ${sanitizeForLog(sample.path)}).`,
+      `- These lists include invalid or precision-losing numeric IDs; manually quote the original values in your config file, then rerun "${params.doctorFixCommand}".`,
+    );
+  }
+  return lines;
+}
+
+export function maybeRepairDiscordNumericIds(
+  cfg: AutoBotConfig,
+  doctorFixCommand: string,
+): { config: AutoBotConfig; changes: string[]; warnings?: string[] } {
+  const hits = scanDiscordNumericIdEntries(cfg);
+  if (hits.length === 0) {
+    return { config: cfg, changes: [] };
+  }
+
+  const next = structuredClone(cfg);
+  const changes: string[] = [];
+
+  const repairList = (pathLabel: string, holder: Record<string, unknown>, key: string) => {
+    const raw = holder[key];
+    if (!Array.isArray(raw)) {
+      return;
+    }
+    const hasUnsafe = raw.some(
+      (entry) => typeof entry === "number" && (!Number.isSafeInteger(entry) || entry < 0),
+    );
+    if (hasUnsafe) {
+      return;
+    }
+    let converted = 0;
+    holder[key] = raw.map((entry) => {
+      if (typeof entry === "number") {
+        converted += 1;
+        return String(entry);
+      }
+      return entry;
+    });
+    if (converted > 0) {
+      changes.push(
+        `- ${sanitizeForLog(pathLabel)}: converted ${converted} numeric ${converted === 1 ? "ID" : "IDs"} to strings`,
+      );
+    }
+  };
+
+  for (const scope of collectDiscordAccountScopes(next)) {
+    for (const ref of collectDiscordIdLists(scope.prefix, scope.account)) {
+      repairList(ref.pathLabel, ref.holder, ref.key);
+    }
+  }
+
+  if (changes.length === 0) {
+    return {
+      config: cfg,
+      changes: [],
+      warnings: collectDiscordNumericIdWarnings({ hits, doctorFixCommand }),
+    };
+  }
+  return {
+    config: next,
+    changes,
+    warnings: collectDiscordNumericIdWarnings({
+      hits: hits.filter((hit) => !hit.safe),
+      doctorFixCommand,
+    }),
+  };
+}
+
+export function collectDiscordMissingEnvTokenWarnings(params: {
+  cfg: AutoBotConfig;
+  env?: NodeJS.ProcessEnv;
+}): string[] {
+  if (resolveDefaultDiscordAccountId(params.cfg) !== "default") {
+    return [];
+  }
+  const account = inspectDiscordAccount({
+    cfg: params.cfg,
+    accountId: "default",
+    envToken: params.env?.DISCORD_BOT_TOKEN ?? "",
+  });
+  if (!account.enabled || account.tokenStatus !== "missing" || account.tokenSource !== "none") {
+    return [];
+  }
+  return [
+    "- channels.discord: default account has no available bot token, and DISCORD_BOT_TOKEN is absent in this doctor environment. After migration, verify DISCORD_BOT_TOKEN is present in the state-dir .env or configure channels.discord.token / channels.discord.accounts.default.token as a SecretRef.",
+  ];
+}
+
+function collectDiscordMutableAllowlistWarnings(cfg: AutoBotConfig): string[] {
+  const hits: Array<{ path: string; entry: string }> = [];
+  const addHits = (pathLabel: string, list: unknown) => {
+    if (!Array.isArray(list)) {
+      return;
+    }
+    for (const entry of list) {
+      const text = normalizeOptionalString(String(entry)) ?? "";
+      if (!text || text === "*" || !isDiscordMutableAllowEntry(text)) {
+        continue;
+      }
+      hits.push({ path: pathLabel, entry: text });
+    }
+  };
+
+  for (const scope of collectProviderDangerousNameMatchingScopes(cfg, "discord")) {
+    if (scope.dangerousNameMatchingEnabled) {
+      continue;
+    }
+    addHits(`${scope.prefix}.allowFrom`, scope.account.allowFrom);
+    const dm = asObjectRecord(scope.account.dm);
+    if (dm) {
+      addHits(`${scope.prefix}.dm.allowFrom`, dm.allowFrom);
+    }
+    const guilds = asObjectRecord(scope.account.guilds);
+    if (!guilds) {
+      continue;
+    }
+    for (const [guildId, guildRaw] of Object.entries(guilds)) {
+      const guild = asObjectRecord(guildRaw);
+      if (!guild) {
+        continue;
+      }
+      addHits(`${scope.prefix}.guilds.${guildId}.users`, guild.users);
+      const channels = asObjectRecord(guild.channels);
+      if (!channels) {
+        continue;
+      }
+      for (const [channelId, channelRaw] of Object.entries(channels)) {
+        const channel = asObjectRecord(channelRaw);
+        if (channel) {
+          addHits(`${scope.prefix}.guilds.${guildId}.channels.${channelId}.users`, channel.users);
+        }
+      }
+    }
+  }
+
+  if (hits.length === 0) {
+    return [];
+  }
+  const exampleLines = hits
+    .slice(0, 8)
+    .map((hit) => `- ${sanitizeForLog(hit.path)}: ${sanitizeForLog(hit.entry)}`);
+  const remaining =
+    hits.length > 8 ? `- +${hits.length - 8} more mutable allowlist entries.` : null;
+  return [
+    `- Found ${hits.length} mutable allowlist ${hits.length === 1 ? "entry" : "entries"} across discord while name matching is disabled by default.`,
+    ...exampleLines,
+    ...(remaining ? [remaining] : []),
+    `- Option A (break-glass): enable channels.discord.dangerousNameMatching=true for the affected scope.`,
+    `- Option B (recommended): resolve names to stable Discord IDs and rewrite the allowlist entries.`,
+  ];
+}
+
+export const discordDoctor: ChannelDoctorAdapter = {
+  dmAllowFromMode: "topOnly",
+  groupModel: "route",
+  groupAllowFromFallbackToAllowFrom: false,
+  warnOnEmptyGroupSenderAllowlist: false,
+  legacyConfigRules: DISCORD_LEGACY_CONFIG_RULES,
+  normalizeCompatibilityConfig: normalizeDiscordCompatibilityConfig,
+  collectPreviewWarnings: ({ cfg, doctorFixCommand, env }) => [
+    ...collectDiscordMissingEnvTokenWarnings({ cfg, env }),
+    ...collectDiscordNumericIdWarnings({
+      hits: scanDiscordNumericIdEntries(cfg),
+      doctorFixCommand,
+    }),
+  ],
+  collectMutableAllowlistWarnings: ({ cfg }) => collectDiscordMutableAllowlistWarnings(cfg),
+  repairConfig: ({ cfg, doctorFixCommand }) => maybeRepairDiscordNumericIds(cfg, doctorFixCommand),
+};

package/src/draft-chunking.ts

@@ -0,0 +1,43 @@
+import { resolveChannelStreamingPreviewChunk } from "autobot/plugin-sdk/channel-streaming";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { resolveTextChunkLimit } from "autobot/plugin-sdk/reply-chunking";
+import { resolveAccountEntry } from "autobot/plugin-sdk/routing";
+import { normalizeAccountId } from "autobot/plugin-sdk/routing";
+import { DISCORD_TEXT_CHUNK_LIMIT } from "./outbound-adapter.js";
+
+const DEFAULT_DISCORD_DRAFT_STREAM_MIN = 200;
+const DEFAULT_DISCORD_DRAFT_STREAM_MAX = 800;
+
+export function resolveDiscordDraftStreamingChunking(
+  cfg: AutoBotConfig,
+  accountId?: string | null,
+): {
+  minChars: number;
+  maxChars: number;
+  breakPreference: "paragraph" | "newline" | "sentence";
+} {
+  const textLimit = resolveTextChunkLimit(cfg, "discord", accountId, {
+    fallbackLimit: DISCORD_TEXT_CHUNK_LIMIT,
+  });
+  const normalizedAccountId = normalizeAccountId(accountId);
+  const accountCfg = resolveAccountEntry(cfg?.channels?.discord?.accounts, normalizedAccountId);
+  const draftCfg =
+    resolveChannelStreamingPreviewChunk(accountCfg) ??
+    resolveChannelStreamingPreviewChunk(cfg?.channels?.discord);
+
+  const maxRequested = Math.max(
+    1,
+    Math.floor(draftCfg?.maxChars ?? DEFAULT_DISCORD_DRAFT_STREAM_MAX),
+  );
+  const maxChars = Math.max(1, Math.min(maxRequested, textLimit));
+  const minRequested = Math.max(
+    1,
+    Math.floor(draftCfg?.minChars ?? DEFAULT_DISCORD_DRAFT_STREAM_MIN),
+  );
+  const minChars = Math.min(minRequested, maxChars);
+  const breakPreference =
+    draftCfg?.breakPreference === "newline" || draftCfg?.breakPreference === "sentence"
+      ? draftCfg.breakPreference
+      : "paragraph";
+  return { minChars, maxChars, breakPreference };
+}

package/src/draft-stream.ts

@@ -0,0 +1,162 @@
+import { createFinalizableDraftLifecycle } from "autobot/plugin-sdk/channel-lifecycle";
+import { formatErrorMessage } from "autobot/plugin-sdk/error-runtime";
+import {
+  createChannelMessage,
+  deleteChannelMessage,
+  editChannelMessage,
+  type RequestClient,
+} from "./internal/discord.js";
+import { resolveDiscordMessageFlags } from "./send.shared.js";
+
+/** Discord messages cap at 2000 characters. */
+const DISCORD_STREAM_MAX_CHARS = 2000;
+const DEFAULT_THROTTLE_MS = 1200;
+const DISCORD_PREVIEW_ALLOWED_MENTIONS = { parse: [] };
+
+type DiscordDraftStream = {
+  update: (text: string) => void;
+  flush: () => Promise<void>;
+  messageId: () => string | undefined;
+  clear: () => Promise<void>;
+  discardPending: () => Promise<void>;
+  seal: () => Promise<void>;
+  stop: () => Promise<void>;
+  /** Reset internal state so the next update creates a new message instead of editing. */
+  forceNewMessage: () => void;
+};
+
+export function createDiscordDraftStream(params: {
+  rest: RequestClient;
+  channelId: string;
+  maxChars?: number;
+  replyToMessageId?: string | (() => string | undefined);
+  throttleMs?: number;
+  /** Minimum chars before sending first message (debounce for push notifications) */
+  minInitialChars?: number;
+  suppressEmbeds?: boolean;
+  log?: (message: string) => void;
+  warn?: (message: string) => void;
+}): DiscordDraftStream {
+  const maxChars = Math.min(params.maxChars ?? DISCORD_STREAM_MAX_CHARS, DISCORD_STREAM_MAX_CHARS);
+  const throttleMs = Math.max(250, params.throttleMs ?? DEFAULT_THROTTLE_MS);
+  const minInitialChars = params.minInitialChars;
+  const channelId = params.channelId;
+  const rest = params.rest;
+  const flags = resolveDiscordMessageFlags({ suppressEmbeds: params.suppressEmbeds });
+  const resolveReplyToMessageId = () =>
+    typeof params.replyToMessageId === "function"
+      ? params.replyToMessageId()
+      : params.replyToMessageId;
+
+  const streamState = { stopped: false, final: false };
+  let streamMessageId: string | undefined;
+  let lastSentText = "";
+
+  const sendOrEditStreamMessage = async (text: string): Promise<boolean> => {
+    // Allow final flush even if stopped (e.g., after clear()).
+    if (streamState.stopped && !streamState.final) {
+      return false;
+    }
+    const trimmed = text.trimEnd();
+    if (!trimmed) {
+      return false;
+    }
+    if (trimmed.length > maxChars) {
+      // Discord messages cap at 2000 chars.
+      // Stop streaming once we exceed the cap to avoid repeated API failures.
+      streamState.stopped = true;
+      params.warn?.(`discord stream preview stopped (text length ${trimmed.length} > ${maxChars})`);
+      return false;
+    }
+    if (trimmed === lastSentText) {
+      return true;
+    }
+
+    // Debounce first preview send for better push notification quality.
+    if (streamMessageId === undefined && minInitialChars != null && !streamState.final) {
+      if (trimmed.length < minInitialChars) {
+        return false;
+      }
+    }
+
+    lastSentText = trimmed;
+    try {
+      if (streamMessageId !== undefined) {
+        // Edit existing message
+        await editChannelMessage(rest, channelId, streamMessageId, {
+          body: {
+            content: trimmed,
+            allowed_mentions: DISCORD_PREVIEW_ALLOWED_MENTIONS,
+            ...(flags ? { flags } : {}),
+          },
+        });
+        return true;
+      }
+      // Send new message
+      const replyToMessageId = resolveReplyToMessageId()?.trim();
+      const messageReference = replyToMessageId
+        ? { message_id: replyToMessageId, fail_if_not_exists: false }
+        : undefined;
+      const sent = await createChannelMessage<{ id?: string }>(rest, channelId, {
+        body: {
+          content: trimmed,
+          allowed_mentions: DISCORD_PREVIEW_ALLOWED_MENTIONS,
+          ...(flags ? { flags } : {}),
+          ...(messageReference ? { message_reference: messageReference } : {}),
+        },
+      });
+      const sentMessageId = sent?.id;
+      if (typeof sentMessageId !== "string" || !sentMessageId) {
+        streamState.stopped = true;
+        params.warn?.("discord stream preview stopped (missing message id from send)");
+        return false;
+      }
+      streamMessageId = sentMessageId;
+      return true;
+    } catch (err) {
+      streamState.stopped = true;
+      params.warn?.(`discord stream preview failed: ${formatErrorMessage(err)}`);
+      return false;
+    }
+  };
+
+  const readMessageId = () => streamMessageId;
+  const clearMessageId = () => {
+    streamMessageId = undefined;
+  };
+  const isValidStreamMessageId = (value: unknown): value is string => typeof value === "string";
+  const deleteStreamMessage = async (messageId: string) => {
+    await deleteChannelMessage(rest, channelId, messageId);
+  };
+
+  const { loop, update, stop, clear, discardPending, seal } = createFinalizableDraftLifecycle({
+    throttleMs,
+    state: streamState,
+    sendOrEditStreamMessage,
+    readMessageId,
+    clearMessageId,
+    isValidMessageId: isValidStreamMessageId,
+    deleteMessage: deleteStreamMessage,
+    warn: params.warn,
+    warnPrefix: "discord stream preview cleanup failed",
+  });
+
+  const forceNewMessage = () => {
+    streamMessageId = undefined;
+    lastSentText = "";
+    loop.resetPending();
+  };
+
+  params.log?.(`discord stream preview ready (maxChars=${maxChars}, throttleMs=${throttleMs})`);
+
+  return {
+    update,
+    flush: loop.flush,
+    messageId: () => streamMessageId,
+    clear,
+    discardPending,
+    seal,
+    stop,
+    forceNewMessage,
+  };
+}

package/src/error-body.ts

@@ -0,0 +1,38 @@
+const DISCORD_RESPONSE_BODY_SUMMARY_MAX_CHARS = 240;
+
+export function summarizeDiscordResponseBody(
+  body: string,
+  opts: { emptyText?: string } = {},
+): string | undefined {
+  const summary = body
+    .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, " ")
+    .replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, " ")
+    .replace(/<[^>]+>/g, " ")
+    .replace(/&nbsp;/gi, " ")
+    .replace(/&amp;/gi, "&")
+    .replace(/&lt;/gi, "<")
+    .replace(/&gt;/gi, ">")
+    .replace(/\s+/g, " ")
+    .trim();
+  if (!summary) {
+    return opts.emptyText;
+  }
+  return summary.slice(0, DISCORD_RESPONSE_BODY_SUMMARY_MAX_CHARS);
+}
+
+export function isDiscordHtmlResponseBody(body: string, contentType?: string | null): boolean {
+  return (
+    /\bhtml\b/i.test(contentType ?? "") ||
+    /^\s*<!doctype\s+html\b/i.test(body) ||
+    /^\s*<html\b/i.test(body)
+  );
+}
+
+export function isDiscordRateLimitResponseBody(body: string): boolean {
+  const normalized = body.toLowerCase();
+  return (
+    normalized.includes("error 1015") ||
+    normalized.includes("cloudflare") ||
+    normalized.includes("rate limit")
+  );
+}

package/src/exec-approvals.ts

@@ -0,0 +1,110 @@
+import type { ChannelOutboundPayloadHint } from "autobot/plugin-sdk/channel-contract";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import type { DiscordExecApprovalConfig } from "autobot/plugin-sdk/config-contracts";
+import type { ReplyPayload } from "autobot/plugin-sdk/reply-dispatch-runtime";
+import { resolveDiscordAccount } from "./accounts.js";
+import {
+  getExecApprovalReplyMetadata,
+  isChannelExecApprovalClientEnabledFromConfig,
+  matchesApprovalRequestFilters,
+  resolveApprovalApprovers,
+} from "./approval-runtime.js";
+import { parseDiscordTarget } from "./target-parsing.js";
+
+function normalizeDiscordApproverId(value: string): string | undefined {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  if (/^\d+$/.test(trimmed)) {
+    return trimmed;
+  }
+  try {
+    const target = parseDiscordTarget(trimmed);
+    return target?.kind === "user" ? target.id : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function resolveDiscordOwnerApprovers(cfg: AutoBotConfig): string[] {
+  const ownerAllowFrom = cfg.commands?.ownerAllowFrom;
+  if (!Array.isArray(ownerAllowFrom) || ownerAllowFrom.length === 0) {
+    return [];
+  }
+  return resolveApprovalApprovers({
+    explicit: ownerAllowFrom,
+    normalizeApprover: (value) => normalizeDiscordApproverId(String(value)),
+  });
+}
+
+export function getDiscordExecApprovalApprovers(params: {
+  cfg: AutoBotConfig;
+  accountId?: string | null;
+  configOverride?: DiscordExecApprovalConfig | null;
+}): string[] {
+  return resolveApprovalApprovers({
+    explicit:
+      params.configOverride?.approvers ??
+      resolveDiscordAccount(params).config.execApprovals?.approvers ??
+      resolveDiscordOwnerApprovers(params.cfg),
+    normalizeApprover: (value) => normalizeDiscordApproverId(String(value)),
+  });
+}
+
+export function isDiscordExecApprovalClientEnabled(params: {
+  cfg: AutoBotConfig;
+  accountId?: string | null;
+  configOverride?: DiscordExecApprovalConfig | null;
+}): boolean {
+  const config = params.configOverride ?? resolveDiscordAccount(params).config.execApprovals;
+  return isChannelExecApprovalClientEnabledFromConfig({
+    enabled: config?.enabled,
+    approverCount: getDiscordExecApprovalApprovers({
+      cfg: params.cfg,
+      accountId: params.accountId,
+      configOverride: params.configOverride,
+    }).length,
+  });
+}
+
+export function isDiscordExecApprovalApprover(params: {
+  cfg: AutoBotConfig;
+  accountId?: string | null;
+  senderId?: string | null;
+  configOverride?: DiscordExecApprovalConfig | null;
+}): boolean {
+  const senderId = params.senderId?.trim();
+  if (!senderId) {
+    return false;
+  }
+  return getDiscordExecApprovalApprovers({
+    cfg: params.cfg,
+    accountId: params.accountId,
+    configOverride: params.configOverride,
+  }).includes(senderId);
+}
+
+export function shouldSuppressLocalDiscordExecApprovalPrompt(params: {
+  cfg: AutoBotConfig;
+  accountId?: string | null;
+  payload: ReplyPayload;
+  hint?: ChannelOutboundPayloadHint;
+}): boolean {
+  const metadata = getExecApprovalReplyMetadata(params.payload);
+  const config = resolveDiscordAccount(params).config.execApprovals;
+  return (
+    params.hint?.kind === "approval-pending" &&
+    params.hint.nativeRouteActive === true &&
+    isDiscordExecApprovalClientEnabled(params) &&
+    metadata !== null &&
+    matchesApprovalRequestFilters({
+      request: {
+        agentId: metadata.agentId,
+        sessionKey: metadata.sessionKey,
+      },
+      agentFilter: config?.agentFilter,
+      sessionFilter: config?.sessionFilter,
+    })
+  );
+}