@kodelyth/discord 2026.5.42 → 2026.6.2

package/src/monitor/native-command-agent-reply.ts

@@ -1,125 +0,0 @@
-import { resolveHumanDelayConfig } from "klaw/plugin-sdk/agent-runtime";
-import { createChannelMessageReplyPipeline } from "klaw/plugin-sdk/channel-message";
-import { resolveChannelStreamingBlockEnabled } from "klaw/plugin-sdk/channel-streaming";
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import { getAgentScopedMediaLocalRoots } from "klaw/plugin-sdk/media-runtime";
-import { resolveChunkMode, resolveTextChunkLimit } from "klaw/plugin-sdk/reply-chunking";
-import type { createSubsystemLogger } from "klaw/plugin-sdk/runtime-env";
-import { logVerbose } from "klaw/plugin-sdk/runtime-env";
-import { resolveDiscordMaxLinesPerMessage } from "../accounts.js";
-import type {
-  ButtonInteraction,
-  CommandInteraction,
-  StringSelectMenuInteraction,
-} from "../internal/discord.js";
-import type { DiscordChannelConfigResolved } from "./allow-list.js";
-import type { buildDiscordNativeCommandContext } from "./native-command-context.js";
-import {
-  DISCORD_EMPTY_VISIBLE_REPLY_WARNING,
-  deliverDiscordInteractionReply,
-  isDiscordUnknownInteraction,
-  safeDiscordInteractionCall,
-} from "./native-command-reply.js";
-import { nativeCommandRuntime } from "./native-command.runtime.js";
-import type { DiscordConfig } from "./native-command.types.js";
-
-type NativeCommandEffectiveRoute = {
-  accountId: string;
-  agentId: string;
-};
-
-export async function dispatchDiscordNativeAgentReply(params: {
-  cfg: KlawConfig;
-  discordConfig: DiscordConfig;
-  accountId: string;
-  interaction: CommandInteraction | ButtonInteraction | StringSelectMenuInteraction;
-  ctxPayload: ReturnType<typeof buildDiscordNativeCommandContext>;
-  effectiveRoute: NativeCommandEffectiveRoute;
-  channelConfig: DiscordChannelConfigResolved | null;
-  mediaLocalRoots: ReturnType<typeof getAgentScopedMediaLocalRoots>;
-  preferFollowUp: boolean;
-  responseEphemeral?: boolean;
-  suppressReplies?: boolean;
-  log: ReturnType<typeof createSubsystemLogger>;
-}): Promise<void> {
-  const { onModelSelected, ...replyPipeline } = createChannelMessageReplyPipeline({
-    cfg: params.cfg,
-    agentId: params.effectiveRoute.agentId,
-    channel: "discord",
-    accountId: params.effectiveRoute.accountId,
-  });
-  const blockStreamingEnabled = resolveChannelStreamingBlockEnabled(params.discordConfig);
-
-  let didReply = false;
-  const dispatchResult = await nativeCommandRuntime.dispatchReplyWithDispatcher({
-    ctx: params.ctxPayload,
-    cfg: params.cfg,
-    dispatcherOptions: {
-      ...replyPipeline,
-      humanDelay: resolveHumanDelayConfig(params.cfg, params.effectiveRoute.agentId),
-      deliver: async (payload) => {
-        if (params.suppressReplies) {
-          return;
-        }
-        try {
-          await deliverDiscordInteractionReply({
-            interaction: params.interaction,
-            payload,
-            mediaLocalRoots: params.mediaLocalRoots,
-            textLimit: resolveTextChunkLimit(params.cfg, "discord", params.accountId, {
-              fallbackLimit: 2000,
-            }),
-            maxLinesPerMessage: resolveDiscordMaxLinesPerMessage({
-              cfg: params.cfg,
-              discordConfig: params.discordConfig,
-              accountId: params.accountId,
-            }),
-            preferFollowUp: params.preferFollowUp || didReply,
-            responseEphemeral: params.responseEphemeral,
-            chunkMode: resolveChunkMode(params.cfg, "discord", params.accountId),
-          });
-        } catch (error) {
-          if (isDiscordUnknownInteraction(error)) {
-            logVerbose("discord: interaction reply skipped (interaction expired)");
-            return;
-          }
-          throw error;
-        }
-        didReply = true;
-      },
-      onError: (err, info) => {
-        const message = err instanceof Error ? (err.stack ?? err.message) : String(err);
-        params.log.error(`discord slash ${info.kind} reply failed: ${message}`);
-      },
-    },
-    replyOptions: {
-      skillFilter: params.channelConfig?.skills,
-      disableBlockStreaming:
-        typeof blockStreamingEnabled === "boolean" ? !blockStreamingEnabled : undefined,
-      onModelSelected,
-    },
-  });
-
-  if (
-    params.suppressReplies ||
-    didReply ||
-    dispatchResult.queuedFinal ||
-    dispatchResult.counts.final !== 0 ||
-    dispatchResult.counts.block !== 0 ||
-    dispatchResult.counts.tool !== 0
-  ) {
-    return;
-  }
-
-  await safeDiscordInteractionCall("interaction empty fallback", async () => {
-    const payload = {
-      content: DISCORD_EMPTY_VISIBLE_REPLY_WARNING,
-      ephemeral: true,
-    };
-    if (params.preferFollowUp) {
-      await params.interaction.followUp(payload);
-      return;
-    }
-    await params.interaction.reply(payload);
-  });
-}

package/src/monitor/native-command-arg-ui.ts

@@ -1,233 +0,0 @@
-import { ButtonStyle } from "discord-api-types/v10";
-import {
-  buildCommandTextFromArgs,
-  findCommandByNativeName,
-  formatCommandArgMenuTitle,
-  listChatCommands,
-  serializeCommandArgs,
-  type ChatCommandDefinition,
-  type CommandArgDefinition,
-  type CommandArgValues,
-  type CommandArgs,
-} from "klaw/plugin-sdk/command-auth-native";
-import { chunkItems } from "klaw/plugin-sdk/text-chunking";
-import {
-  Button,
-  Row,
-  type ButtonInteraction,
-  type CommandInteraction,
-  type ComponentData,
-} from "../internal/discord.js";
-import { resolveDiscordSlashCommandConfig } from "./commands.js";
-import type { DispatchDiscordCommandInteraction } from "./native-command-dispatch.js";
-import type {
-  DiscordCommandArgContext,
-  SafeDiscordInteractionCall,
-} from "./native-command-ui.types.js";
-
-const DISCORD_COMMAND_ARG_CUSTOM_ID_KEY = "cmdarg";
-
-function createCommandArgsWithValue(params: { argName: string; value: string }): CommandArgs {
-  const values: CommandArgValues = { [params.argName]: params.value };
-  return { values };
-}
-
-function encodeDiscordCommandArgValue(value: string): string {
-  return encodeURIComponent(value);
-}
-
-function decodeDiscordCommandArgValue(value: string): string {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-
-export function buildDiscordCommandArgCustomId(params: {
-  command: string;
-  arg: string;
-  value: string;
-  userId: string;
-}): string {
-  return [
-    `${DISCORD_COMMAND_ARG_CUSTOM_ID_KEY}:command=${encodeDiscordCommandArgValue(params.command)}`,
-    `arg=${encodeDiscordCommandArgValue(params.arg)}`,
-    `value=${encodeDiscordCommandArgValue(params.value)}`,
-    `user=${encodeDiscordCommandArgValue(params.userId)}`,
-  ].join(";");
-}
-
-function parseDiscordCommandArgData(
-  data: ComponentData,
-): { command: string; arg: string; value: string; userId: string } | null {
-  if (!data || typeof data !== "object") {
-    return null;
-  }
-  const coerce = (value: unknown) =>
-    typeof value === "string" || typeof value === "number" ? String(value) : "";
-  const rawCommand = coerce(data.command);
-  const rawArg = coerce(data.arg);
-  const rawValue = coerce(data.value);
-  const rawUser = coerce(data.user);
-  if (!rawCommand || !rawArg || !rawValue || !rawUser) {
-    return null;
-  }
-  return {
-    command: decodeDiscordCommandArgValue(rawCommand),
-    arg: decodeDiscordCommandArgValue(rawArg),
-    value: decodeDiscordCommandArgValue(rawValue),
-    userId: decodeDiscordCommandArgValue(rawUser),
-  };
-}
-
-export async function handleDiscordCommandArgInteraction(params: {
-  interaction: ButtonInteraction;
-  data: ComponentData;
-  ctx: DiscordCommandArgContext;
-  safeInteractionCall: SafeDiscordInteractionCall;
-  dispatchCommandInteraction: DispatchDiscordCommandInteraction;
-}) {
-  const { interaction, data, ctx } = params;
-  const clearWithMessage = async (content: string) =>
-    await params.safeInteractionCall("command arg update", () =>
-      interaction.update({ content, components: [] }),
-    );
-  const parsed = parseDiscordCommandArgData(data);
-  if (!parsed) {
-    await clearWithMessage("Sorry, that selection is no longer available.");
-    return;
-  }
-  if (interaction.user?.id && interaction.user.id !== parsed.userId) {
-    await params.safeInteractionCall("command arg ack", () => interaction.acknowledge());
-    return;
-  }
-  const commandDefinition =
-    findCommandByNativeName(parsed.command, "discord") ??
-    listChatCommands().find((entry) => entry.key === parsed.command);
-  if (!commandDefinition) {
-    await clearWithMessage("Sorry, that command is no longer available.");
-    return;
-  }
-  const argUpdateResult = await clearWithMessage(`✅ Selected ${parsed.value}.`);
-  if (argUpdateResult === null) {
-    return;
-  }
-  const commandArgs = createCommandArgsWithValue({
-    argName: parsed.arg,
-    value: parsed.value,
-  });
-  const commandArgsWithRaw: CommandArgs = {
-    ...commandArgs,
-    raw: serializeCommandArgs(commandDefinition, commandArgs),
-  };
-  const prompt = buildCommandTextFromArgs(commandDefinition, commandArgsWithRaw);
-  await params.dispatchCommandInteraction({
-    interaction,
-    prompt,
-    command: commandDefinition,
-    commandArgs: commandArgsWithRaw,
-    cfg: ctx.cfg,
-    discordConfig: ctx.discordConfig,
-    accountId: ctx.accountId,
-    sessionPrefix: ctx.sessionPrefix,
-    preferFollowUp: true,
-    threadBindings: ctx.threadBindings,
-    responseEphemeral: resolveDiscordSlashCommandConfig(ctx.discordConfig?.slashCommand).ephemeral,
-  });
-}
-
-type DiscordCommandArgButtonParams = {
-  ctx: DiscordCommandArgContext;
-  safeInteractionCall: SafeDiscordInteractionCall;
-  dispatchCommandInteraction: DispatchDiscordCommandInteraction;
-};
-
-async function runDiscordCommandArgButton(
-  params: DiscordCommandArgButtonParams & {
-    interaction: ButtonInteraction;
-    data: ComponentData;
-  },
-) {
-  await handleDiscordCommandArgInteraction(params);
-}
-
-class DiscordCommandArgButton extends Button {
-  label: string;
-  customId: string;
-  override style = ButtonStyle.Secondary;
-
-  constructor(
-    params: {
-      label: string;
-      customId: string;
-    } & DiscordCommandArgButtonParams,
-  ) {
-    super();
-    this.label = params.label;
-    this.customId = params.customId;
-    this.params = params;
-  }
-
-  private params: DiscordCommandArgButtonParams;
-
-  override async run(interaction: ButtonInteraction, data: ComponentData) {
-    await runDiscordCommandArgButton({ ...this.params, interaction, data });
-  }
-}
-
-export function buildDiscordCommandArgMenu(params: {
-  command: ChatCommandDefinition;
-  menu: {
-    arg: CommandArgDefinition;
-    choices: Array<{ value: string; label: string }>;
-    title?: string;
-  };
-  interaction: CommandInteraction;
-  ctx: DiscordCommandArgContext;
-  safeInteractionCall: SafeDiscordInteractionCall;
-  dispatchCommandInteraction: DispatchDiscordCommandInteraction;
-}): { content: string; components: Row<Button>[] } {
-  const { command, menu, interaction } = params;
-  const commandLabel = command.nativeName ?? command.key;
-  const userId = interaction.user?.id ?? "";
-  const rows = chunkItems(menu.choices, 4).map((choices) => {
-    const buttons = choices.map(
-      (choice) =>
-        new DiscordCommandArgButton({
-          label: choice.label,
-          customId: buildDiscordCommandArgCustomId({
-            command: commandLabel,
-            arg: menu.arg.name,
-            value: choice.value,
-            userId,
-          }),
-          ctx: params.ctx,
-          safeInteractionCall: params.safeInteractionCall,
-          dispatchCommandInteraction: params.dispatchCommandInteraction,
-        }),
-    );
-    return new Row(buttons);
-  });
-  const content = formatCommandArgMenuTitle({ command, menu });
-  return { content, components: rows };
-}
-
-class DiscordCommandArgFallbackButton extends Button {
-  label = "cmdarg";
-  customId = "cmdarg:seed=1";
-
-  constructor(private readonly params: DiscordCommandArgButtonParams) {
-    super();
-  }
-
-  override async run(interaction: ButtonInteraction, data: ComponentData) {
-    await runDiscordCommandArgButton({ ...this.params, interaction, data });
-  }
-}
-
-export function createDiscordCommandArgFallbackButton(
-  params: DiscordCommandArgButtonParams,
-): Button {
-  return new DiscordCommandArgFallbackButton(params);
-}

package/src/monitor/native-command-auth.ts

@@ -1,309 +0,0 @@
-import { resolveCommandAuthorizedFromAuthorizers } from "klaw/plugin-sdk/command-auth-native";
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import { isDangerousNameMatchingEnabled } from "klaw/plugin-sdk/dangerous-name-runtime";
-import { resolveOpenProviderRuntimeGroupPolicy } from "klaw/plugin-sdk/runtime-group-policy";
-import { normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
-import { resolveDiscordAccountAllowFrom, resolveDiscordAccountDmPolicy } from "../accounts.js";
-import type { AutocompleteInteraction } from "../internal/discord.js";
-import {
-  normalizeDiscordAllowList,
-  resolveDiscordAllowListMatch,
-  resolveDiscordChannelConfigWithFallback,
-  resolveDiscordChannelPolicyCommandAuthorizer,
-  resolveDiscordGuildEntry,
-  resolveDiscordMemberAccessState,
-  resolveDiscordOwnerAccess,
-  resolveGroupDmAllow,
-} from "./allow-list.js";
-import { resolveDiscordDmCommandAccess } from "./dm-command-auth.js";
-import type { DiscordConfig } from "./native-command.types.js";
-import { resolveDiscordNativeInteractionChannelContext } from "./native-interaction-channel-context.js";
-import { resolveDiscordSenderIdentity } from "./sender-identity.js";
-
-export function resolveDiscordNativeCommandAllowlistAccess(params: {
-  cfg: KlawConfig;
-  accountId?: string | null;
-  sender: { id: string; name?: string; tag?: string };
-  chatType: "direct" | "group" | "thread" | "channel";
-  conversationId?: string;
-  guildId?: string | null;
-}) {
-  const commandsAllowFrom = params.cfg.commands?.allowFrom;
-  if (!commandsAllowFrom || typeof commandsAllowFrom !== "object") {
-    return { configured: false, allowed: false } as const;
-  }
-  const rawAllowList = Array.isArray(commandsAllowFrom.discord)
-    ? commandsAllowFrom.discord
-    : commandsAllowFrom["*"];
-  if (!Array.isArray(rawAllowList)) {
-    return { configured: false, allowed: false } as const;
-  }
-  const guildId = normalizeOptionalString(params.guildId);
-  if (guildId) {
-    for (const entry of rawAllowList) {
-      const text = normalizeOptionalString(String(entry)) ?? "";
-      if (text.startsWith("guild:") && text.slice("guild:".length) === guildId) {
-        return { configured: true, allowed: true } as const;
-      }
-    }
-  }
-  const allowList = normalizeDiscordAllowList(rawAllowList.map(String), [
-    "discord:",
-    "user:",
-    "pk:",
-  ]);
-  if (!allowList) {
-    return { configured: true, allowed: false } as const;
-  }
-  const match = resolveDiscordAllowListMatch({
-    allowList,
-    candidate: params.sender,
-    allowNameMatching: false,
-  });
-  return { configured: true, allowed: match.allowed } as const;
-}
-
-export async function resolveDiscordGuildNativeCommandAuthorized(params: {
-  cfg: KlawConfig;
-  accountId: string;
-  discordConfig: DiscordConfig;
-  useAccessGroups: boolean;
-  commandsAllowFromAccess: ReturnType<typeof resolveDiscordNativeCommandAllowlistAccess>;
-  guildInfo?: ReturnType<typeof resolveDiscordGuildEntry> | null;
-  channelConfig?: ReturnType<typeof resolveDiscordChannelConfigWithFallback> | null;
-  memberRoleIds: string[];
-  sender: { id: string; name?: string; tag?: string };
-  allowNameMatching: boolean;
-  ownerAllowListConfigured: boolean;
-  ownerAllowed: boolean;
-}) {
-  const { groupPolicy } = resolveOpenProviderRuntimeGroupPolicy({
-    providerConfigPresent: params.cfg.channels?.discord !== undefined,
-    groupPolicy: params.discordConfig?.groupPolicy,
-    defaultGroupPolicy: params.cfg.channels?.defaults?.groupPolicy,
-  });
-  const policyAuthorizer = resolveDiscordChannelPolicyCommandAuthorizer({
-    groupPolicy,
-    guildInfo: params.guildInfo,
-    channelConfig: params.channelConfig,
-  });
-  if (!policyAuthorizer.allowed) {
-    return false;
-  }
-  const { hasAccessRestrictions, memberAllowed } = resolveDiscordMemberAccessState({
-    channelConfig: params.channelConfig,
-    guildInfo: params.guildInfo,
-    memberRoleIds: params.memberRoleIds,
-    sender: params.sender,
-    allowNameMatching: params.allowNameMatching,
-  });
-  const commandAllowlistAuthorizer = {
-    configured: params.commandsAllowFromAccess.configured,
-    allowed: params.commandsAllowFromAccess.allowed,
-  };
-  const ownerAuthorizer = {
-    configured: params.ownerAllowListConfigured,
-    allowed: params.ownerAllowed,
-  };
-  const memberAuthorizer = {
-    configured: hasAccessRestrictions,
-    allowed: memberAllowed,
-  };
-  const hasStricterAccessRestrictions = ownerAuthorizer.configured || memberAuthorizer.configured;
-  const policyFallbackAuthorizer = {
-    configured: policyAuthorizer.configured && !hasStricterAccessRestrictions,
-    allowed: policyAuthorizer.allowed,
-  };
-  const fallbackAuthorizers = [policyFallbackAuthorizer, ownerAuthorizer, memberAuthorizer];
-  const authorizers = params.commandsAllowFromAccess.configured
-    ? [commandAllowlistAuthorizer]
-    : fallbackAuthorizers;
-  return resolveCommandAuthorizedFromAuthorizers({
-    useAccessGroups: params.useAccessGroups,
-    authorizers,
-    modeWhenAccessGroupsOff: "configured",
-  });
-}
-
-export function resolveDiscordNativeGroupDmAccess(params: {
-  isGroupDm: boolean;
-  groupEnabled?: boolean;
-  groupChannels?: string[];
-  channelId: string;
-  channelName?: string;
-  channelSlug: string;
-}): { allowed: true } | { allowed: false; reason: "disabled" | "not-allowlisted" } {
-  if (!params.isGroupDm) {
-    return { allowed: true };
-  }
-  if (params.groupEnabled === false) {
-    return { allowed: false, reason: "disabled" };
-  }
-  if (
-    !resolveGroupDmAllow({
-      channels: params.groupChannels,
-      channelId: params.channelId,
-      channelName: params.channelName,
-      channelSlug: params.channelSlug,
-    })
-  ) {
-    return { allowed: false, reason: "not-allowlisted" };
-  }
-  return { allowed: true };
-}
-
-export async function resolveDiscordNativeAutocompleteAuthorized(params: {
-  interaction: AutocompleteInteraction;
-  cfg: KlawConfig;
-  discordConfig: DiscordConfig;
-  accountId: string;
-}): Promise<boolean> {
-  const { interaction, cfg, discordConfig, accountId } = params;
-  const user = interaction.user;
-  if (!user) {
-    return false;
-  }
-  const sender = resolveDiscordSenderIdentity({ author: user, pluralkitInfo: null });
-  const {
-    isDirectMessage,
-    isGroupDm,
-    isThreadChannel,
-    channelName,
-    channelSlug,
-    rawChannelId,
-    threadParentId,
-    threadParentName,
-    threadParentSlug,
-  } = await resolveDiscordNativeInteractionChannelContext({
-    channel: interaction.channel,
-    client: interaction.client,
-    hasGuild: Boolean(interaction.guild),
-    channelIdFallback: "",
-  });
-  const memberRoleIds = Array.isArray(interaction.rawData.member?.roles)
-    ? interaction.rawData.member.roles.map((roleId: string) => roleId)
-    : [];
-  const allowNameMatching = isDangerousNameMatchingEnabled(discordConfig);
-  const useAccessGroups = cfg.commands?.useAccessGroups !== false;
-  const configuredDmAllowFrom =
-    resolveDiscordAccountAllowFrom({
-      cfg,
-      accountId,
-    }) ?? [];
-  const { ownerAllowList, ownerAllowed: ownerOk } = resolveDiscordOwnerAccess({
-    allowFrom: configuredDmAllowFrom,
-    sender: {
-      id: sender.id,
-      name: sender.name,
-      tag: sender.tag,
-    },
-    allowNameMatching,
-  });
-  const commandsAllowFromAccess = resolveDiscordNativeCommandAllowlistAccess({
-    cfg,
-    accountId,
-    sender: {
-      id: sender.id,
-      name: sender.name,
-      tag: sender.tag,
-    },
-    chatType: isDirectMessage
-      ? "direct"
-      : isThreadChannel
-        ? "thread"
-        : interaction.guild
-          ? "channel"
-          : "group",
-    conversationId: rawChannelId || undefined,
-    guildId: interaction.guild?.id,
-  });
-  const guildInfo = resolveDiscordGuildEntry({
-    guild: interaction.guild ?? undefined,
-    guildId: interaction.guild?.id ?? undefined,
-    guildEntries: discordConfig?.guilds,
-  });
-  const channelConfig = interaction.guild
-    ? resolveDiscordChannelConfigWithFallback({
-        guildInfo,
-        channelId: rawChannelId,
-        channelName,
-        channelSlug,
-        parentId: threadParentId,
-        parentName: threadParentName,
-        parentSlug: threadParentSlug,
-        scope: isThreadChannel ? "thread" : "channel",
-      })
-    : null;
-  if (channelConfig?.enabled === false) {
-    return false;
-  }
-  if (interaction.guild && channelConfig?.allowed === false) {
-    return false;
-  }
-  if (useAccessGroups && interaction.guild) {
-    const { groupPolicy } = resolveOpenProviderRuntimeGroupPolicy({
-      providerConfigPresent: cfg.channels?.discord !== undefined,
-      groupPolicy: discordConfig?.groupPolicy,
-      defaultGroupPolicy: cfg.channels?.defaults?.groupPolicy,
-    });
-    const policyAuthorizer = resolveDiscordChannelPolicyCommandAuthorizer({
-      groupPolicy,
-      guildInfo,
-      channelConfig,
-    });
-    if (!policyAuthorizer.allowed) {
-      return false;
-    }
-  }
-  const dmEnabled = discordConfig?.dm?.enabled ?? true;
-  const dmPolicy = resolveDiscordAccountDmPolicy({ cfg, accountId }) ?? "pairing";
-  if (isDirectMessage) {
-    if (!dmEnabled || dmPolicy === "disabled") {
-      return false;
-    }
-    const dmAccess = await resolveDiscordDmCommandAccess({
-      accountId,
-      dmPolicy,
-      configuredAllowFrom: configuredDmAllowFrom,
-      sender: {
-        id: sender.id,
-        name: sender.name,
-        tag: sender.tag,
-      },
-      allowNameMatching,
-      cfg,
-      rest: interaction.client.rest,
-    });
-    if (dmAccess.senderAccess.decision !== "allow") {
-      return false;
-    }
-  }
-  const groupDmAccess = resolveDiscordNativeGroupDmAccess({
-    isGroupDm,
-    groupEnabled: discordConfig?.dm?.groupEnabled,
-    groupChannels: discordConfig?.dm?.groupChannels,
-    channelId: rawChannelId,
-    channelName,
-    channelSlug,
-  });
-  if (!groupDmAccess.allowed) {
-    return false;
-  }
-  if (!isDirectMessage) {
-    return resolveDiscordGuildNativeCommandAuthorized({
-      cfg,
-      accountId,
-      discordConfig,
-      useAccessGroups,
-      commandsAllowFromAccess,
-      guildInfo,
-      channelConfig,
-      memberRoleIds,
-      sender,
-      allowNameMatching,
-      ownerAllowListConfigured: ownerAllowList != null,
-      ownerAllowed: ownerOk,
-    });
-  }
-  return true;
-}

package/src/monitor/native-command-bypass.ts

@@ -1,13 +0,0 @@
-import { normalizeLowercaseStringOrEmpty } from "klaw/plugin-sdk/string-coerce-runtime";
-
-export function shouldBypassConfiguredAcpEnsure(commandName: string): boolean {
-  const normalized = normalizeLowercaseStringOrEmpty(commandName);
-  // Recovery slash commands still need configured ACP readiness so stale dead
-  // bindings are recreated before /new or /reset dispatches through them.
-  return normalized === "acp";
-}
-
-export function shouldBypassConfiguredAcpGuildGuards(commandName: string): boolean {
-  const normalized = normalizeLowercaseStringOrEmpty(commandName);
-  return normalized === "new" || normalized === "reset";
-}