@poolzin/pool-bot 2026.2.21 → 2026.2.23

package/dist/slack/monitor/slash.js

@@ -1,33 +1,88 @@
-import { resolveChunkMode } from "../../auto-reply/chunk.js";
-import { resolveEffectiveMessagesConfig } from "../../agents/identity.js";
-import { buildCommandTextFromArgs, findCommandByNativeName, listNativeCommandSpecsForConfig, parseCommandArgs, resolveCommandArgMenu, } from "../../auto-reply/commands-registry.js";
-import { listSkillCommandsForAgents } from "../../auto-reply/skill-commands.js";
-import { dispatchReplyWithDispatcher } from "../../auto-reply/reply/provider-dispatcher.js";
-import { finalizeInboundContext } from "../../auto-reply/reply/inbound-context.js";
+import { formatAllowlistMatchMeta } from "../../channels/allowlist-match.js";
+import { resolveCommandAuthorizedFromAuthorizers } from "../../channels/command-gating.js";
 import { resolveNativeCommandsEnabled, resolveNativeSkillsEnabled } from "../../config/commands.js";
-import { resolveMarkdownTableMode } from "../../config/markdown-tables.js";
 import { danger, logVerbose } from "../../globals.js";
 import { buildPairingReply } from "../../pairing/pairing-messages.js";
 import { readChannelAllowFromStore, upsertChannelPairingRequest, } from "../../pairing/pairing-store.js";
-import { resolveAgentRoute } from "../../routing/resolve-route.js";
-import { resolveConversationLabel } from "../../channels/conversation-label.js";
-import { resolveCommandAuthorizedFromAuthorizers } from "../../channels/command-gating.js";
-import { formatAllowlistMatchMeta } from "../../channels/allowlist-match.js";
+import { chunkItems } from "../../utils/chunk-items.js";
 import { normalizeAllowList, normalizeAllowListLower, resolveSlackAllowListMatch, resolveSlackUserAllowed, } from "./allow-list.js";
 import { resolveSlackChannelConfig } from "./channel-config.js";
 import { buildSlackSlashCommandMatcher, resolveSlackSlashCommandConfig } from "./commands.js";
+import { normalizeSlackChannelType } from "./context.js";
 import { isSlackChannelAllowedByPolicy } from "./policy.js";
-import { deliverSlackSlashReplies } from "./replies.js";
+import { resolveSlackRoomContextHints } from "./room-context.js";
 const SLACK_COMMAND_ARG_ACTION_ID = "poolbot_cmdarg";
 const SLACK_COMMAND_ARG_VALUE_PREFIX = "cmdarg";
-function chunkItems(items, size) {
-    if (size <= 0)
-        return [items];
-    const rows = [];
-    for (let i = 0; i < items.length; i += size) {
-        rows.push(items.slice(i, i + size));
+const SLACK_COMMAND_ARG_BUTTON_ROW_SIZE = 5;
+const SLACK_COMMAND_ARG_OVERFLOW_MIN = 3;
+const SLACK_COMMAND_ARG_OVERFLOW_MAX = 5;
+const SLACK_COMMAND_ARG_SELECT_OPTIONS_MAX = 100;
+const SLACK_COMMAND_ARG_SELECT_OPTION_VALUE_MAX = 75;
+const SLACK_COMMAND_ARG_EXTERNAL_PREFIX = "poolbot_cmdarg_ext:";
+const SLACK_COMMAND_ARG_EXTERNAL_TTL_MS = 10 * 60 * 1000;
+const SLACK_HEADER_TEXT_MAX = 150;
+const slackExternalArgMenuStore = new Map();
+function truncatePlainText(value, max) {
+    const trimmed = value.trim();
+    if (trimmed.length <= max) {
+        return trimmed;
+    }
+    if (max <= 1) {
+        return trimmed.slice(0, max);
+    }
+    return `${trimmed.slice(0, max - 1)}…`;
+}
+function escapeSlackMrkdwn(value) {
+    return value
+        .replaceAll("\\", "\\\\")
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replace(/([*_`~])/g, "\\$1");
+}
+function buildSlackArgMenuConfirm(params) {
+    const command = escapeSlackMrkdwn(params.command);
+    const arg = escapeSlackMrkdwn(params.arg);
+    return {
+        title: { type: "plain_text", text: "Confirm selection" },
+        text: {
+            type: "mrkdwn",
+            text: `Run */${command}* with *${arg}* set to this value?`,
+        },
+        confirm: { type: "plain_text", text: "Run command" },
+        deny: { type: "plain_text", text: "Cancel" },
+    };
+}
+function pruneSlackExternalArgMenuStore(now = Date.now()) {
+    for (const [token, entry] of slackExternalArgMenuStore.entries()) {
+        if (entry.expiresAt <= now) {
+            slackExternalArgMenuStore.delete(token);
+        }
+    }
+}
+function storeSlackExternalArgMenu(params) {
+    pruneSlackExternalArgMenuStore();
+    const token = `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
+    slackExternalArgMenuStore.set(token, {
+        choices: params.choices,
+        userId: params.userId,
+        expiresAt: Date.now() + SLACK_COMMAND_ARG_EXTERNAL_TTL_MS,
+    });
+    return token;
+}
+function readSlackExternalArgMenuToken(raw) {
+    if (typeof raw !== "string" || !raw.startsWith(SLACK_COMMAND_ARG_EXTERNAL_PREFIX)) {
+        return undefined;
+    }
+    const token = raw.slice(SLACK_COMMAND_ARG_EXTERNAL_PREFIX.length).trim();
+    return token.length > 0 ? token : undefined;
+}
+let commandsRegistry;
+async function getCommandsRegistry() {
+    if (!commandsRegistry) {
+        commandsRegistry = await import("../../auto-reply/commands-registry.js");
     }
-    return rows;
+    return commandsRegistry;
 }
 function encodeSlackCommandArgValue(parts) {
     return [
@@ -39,14 +94,17 @@ function encodeSlackCommandArgValue(parts) {
     ].join("|");
 }
 function parseSlackCommandArgValue(raw) {
-    if (!raw)
+    if (!raw) {
         return null;
+    }
     const parts = raw.split("|");
-    if (parts.length !== 5 || parts[0] !== SLACK_COMMAND_ARG_VALUE_PREFIX)
+    if (parts.length !== 5 || parts[0] !== SLACK_COMMAND_ARG_VALUE_PREFIX) {
         return null;
+    }
     const [, command, arg, value, userId] = parts;
-    if (!command || !arg || !value || !userId)
+    if (!command || !arg || !value || !userId) {
         return null;
+    }
     const decode = (text) => {
         try {
             return decodeURIComponent(text);
@@ -59,8 +117,9 @@ function parseSlackCommandArgValue(raw) {
     const decodedArg = decode(arg);
     const decodedValue = decode(value);
     const decodedUserId = decode(userId);
-    if (!decodedCommand || !decodedArg || !decodedValue || !decodedUserId)
+    if (!decodedCommand || !decodedArg || !decodedValue || !decodedUserId) {
         return null;
+    }
     return {
         command: decodedCommand,
         arg: decodedArg,
@@ -69,33 +128,112 @@ function parseSlackCommandArgValue(raw) {
     };
 }
 function buildSlackCommandArgMenuBlocks(params) {
-    const rows = chunkItems(params.choices, 5).map((choices) => ({
-        type: "actions",
-        elements: choices.map((choice) => ({
-            type: "button",
-            action_id: SLACK_COMMAND_ARG_ACTION_ID,
-            text: { type: "plain_text", text: choice.label },
-            value: encodeSlackCommandArgValue({
-                command: params.command,
-                arg: params.arg,
-                value: choice.value,
-                userId: params.userId,
-            }),
-        })),
+    const encodedChoices = params.choices.map((choice) => ({
+        label: choice.label,
+        value: encodeSlackCommandArgValue({
+            command: params.command,
+            arg: params.arg,
+            value: choice.value,
+            userId: params.userId,
+        }),
     }));
+    const canUseStaticSelect = encodedChoices.every((choice) => choice.value.length <= SLACK_COMMAND_ARG_SELECT_OPTION_VALUE_MAX);
+    const canUseOverflow = canUseStaticSelect &&
+        encodedChoices.length >= SLACK_COMMAND_ARG_OVERFLOW_MIN &&
+        encodedChoices.length <= SLACK_COMMAND_ARG_OVERFLOW_MAX;
+    const canUseExternalSelect = params.supportsExternalSelect &&
+        canUseStaticSelect &&
+        encodedChoices.length > SLACK_COMMAND_ARG_SELECT_OPTIONS_MAX;
+    const rows = canUseOverflow
+        ? [
+            {
+                type: "actions",
+                elements: [
+                    {
+                        type: "overflow",
+                        action_id: SLACK_COMMAND_ARG_ACTION_ID,
+                        confirm: buildSlackArgMenuConfirm({ command: params.command, arg: params.arg }),
+                        options: encodedChoices.map((choice) => ({
+                            text: { type: "plain_text", text: choice.label.slice(0, 75) },
+                            value: choice.value,
+                        })),
+                    },
+                ],
+            },
+        ]
+        : canUseExternalSelect
+            ? [
+                {
+                    type: "actions",
+                    block_id: `${SLACK_COMMAND_ARG_EXTERNAL_PREFIX}${params.createExternalMenuToken(encodedChoices)}`,
+                    elements: [
+                        {
+                            type: "external_select",
+                            action_id: SLACK_COMMAND_ARG_ACTION_ID,
+                            confirm: buildSlackArgMenuConfirm({ command: params.command, arg: params.arg }),
+                            min_query_length: 0,
+                            placeholder: {
+                                type: "plain_text",
+                                text: `Search ${params.arg}`,
+                            },
+                        },
+                    ],
+                },
+            ]
+            : encodedChoices.length <= SLACK_COMMAND_ARG_BUTTON_ROW_SIZE || !canUseStaticSelect
+                ? chunkItems(encodedChoices, SLACK_COMMAND_ARG_BUTTON_ROW_SIZE).map((choices) => ({
+                    type: "actions",
+                    elements: choices.map((choice) => ({
+                        type: "button",
+                        action_id: SLACK_COMMAND_ARG_ACTION_ID,
+                        text: { type: "plain_text", text: choice.label },
+                        value: choice.value,
+                        confirm: buildSlackArgMenuConfirm({ command: params.command, arg: params.arg }),
+                    })),
+                }))
+                : chunkItems(encodedChoices, SLACK_COMMAND_ARG_SELECT_OPTIONS_MAX).map((choices, index) => ({
+                    type: "actions",
+                    elements: [
+                        {
+                            type: "static_select",
+                            action_id: SLACK_COMMAND_ARG_ACTION_ID,
+                            confirm: buildSlackArgMenuConfirm({ command: params.command, arg: params.arg }),
+                            placeholder: {
+                                type: "plain_text",
+                                text: index === 0 ? `Choose ${params.arg}` : `Choose ${params.arg} (${index + 1})`,
+                            },
+                            options: choices.map((choice) => ({
+                                text: { type: "plain_text", text: choice.label.slice(0, 75) },
+                                value: choice.value,
+                            })),
+                        },
+                    ],
+                }));
+    const headerText = truncatePlainText(`/${params.command}: choose ${params.arg}`, SLACK_HEADER_TEXT_MAX);
+    const sectionText = truncatePlainText(params.title, 3000);
+    const contextText = truncatePlainText(`Select one option to continue /${params.command} (${params.arg})`, 3000);
     return [
+        {
+            type: "header",
+            text: { type: "plain_text", text: headerText },
+        },
         {
             type: "section",
-            text: { type: "mrkdwn", text: params.title },
+            text: { type: "mrkdwn", text: sectionText },
+        },
+        {
+            type: "context",
+            elements: [{ type: "mrkdwn", text: contextText }],
         },
         ...rows,
     ];
 }
-export function registerSlackMonitorSlashCommands(params) {
+export async function registerSlackMonitorSlashCommands(params) {
     const { ctx, account } = params;
     const cfg = ctx.cfg;
     const runtime = ctx.runtime;
     const supportsInteractiveArgMenus = typeof ctx.app.action === "function";
+    const supportsExternalArgMenus = typeof ctx.app.options === "function";
     const slashCommand = resolveSlackSlashCommandConfig(ctx.slashCommand ?? account.config.slashCommand);
     const handleSlashCommand = async (p) => {
         const { command, ack, respond, prompt, commandArgs, commandDefinition } = p;
@@ -108,10 +246,12 @@ export function registerSlackMonitorSlashCommands(params) {
                 return;
             }
             await ack();
-            if (ctx.botUserId && command.user_id === ctx.botUserId)
+            if (ctx.botUserId && command.user_id === ctx.botUserId) {
                 return;
+            }
             const channelInfo = await ctx.resolveChannelName(command.channel_id);
-            const channelType = channelInfo?.type ?? (command.channel_name === "directmessage" ? "im" : undefined);
+            const rawChannelType = channelInfo?.type ?? (command.channel_name === "directmessage" ? "im" : undefined);
+            const channelType = normalizeSlackChannelType(rawChannelType, command.channel_id);
             const isDirectMessage = channelType === "im";
             const isGroupDm = channelType === "mpim";
             const isRoom = channelType === "channel" || channelType === "group";
@@ -130,7 +270,9 @@ export function registerSlackMonitorSlashCommands(params) {
             const storeAllowFrom = await readChannelAllowFromStore("slack").catch(() => []);
             const effectiveAllowFrom = normalizeAllowList([...ctx.allowFrom, ...storeAllowFrom]);
             const effectiveAllowFromLower = normalizeAllowListLower(effectiveAllowFrom);
-            let commandAuthorized = true;
+            // Privileged command surface: compute CommandAuthorized, don't assume true.
+            // Keep this aligned with the Slack message path (message-handler/prepare.ts).
+            let commandAuthorized = false;
             let channelConfig = null;
             if (isDirectMessage) {
                 if (!ctx.dmEnabled || ctx.dmPolicy === "disabled") {
@@ -177,7 +319,6 @@ export function registerSlackMonitorSlashCommands(params) {
                         }
                         return;
                     }
-                    commandAuthorized = true;
                 }
             }
             if (isRoom) {
@@ -236,6 +377,13 @@ export function registerSlackMonitorSlashCommands(params) {
                 id: command.user_id,
                 name: senderName,
             }).allowed;
+            // DMs: allow chatting in dmPolicy=open, but keep privileged command gating intact by setting
+            // CommandAuthorized based on allowlists/access-groups (downstream decides which commands need it).
+            commandAuthorized = resolveCommandAuthorizedFromAuthorizers({
+                useAccessGroups: ctx.useAccessGroups,
+                authorizers: [{ configured: effectiveAllowFromLower.length > 0, allowed: ownerAllowed }],
+                modeWhenAccessGroupsOff: "configured",
+            });
             if (isRoomish) {
                 commandAuthorized = resolveCommandAuthorizedFromAuthorizers({
                     useAccessGroups: ctx.useAccessGroups,
@@ -243,6 +391,7 @@ export function registerSlackMonitorSlashCommands(params) {
                         { configured: effectiveAllowFromLower.length > 0, allowed: ownerAllowed },
                         { configured: channelUsersAllowlistConfigured, allowed: channelUserAllowed },
                     ],
+                    modeWhenAccessGroupsOff: "configured",
                 });
                 if (ctx.useAccessGroups && !commandAuthorized) {
                     await respond({
@@ -253,7 +402,8 @@ export function registerSlackMonitorSlashCommands(params) {
                 }
             }
             if (commandDefinition && supportsInteractiveArgMenus) {
-                const menu = resolveCommandArgMenu({
+                const reg = await getCommandsRegistry();
+                const menu = reg.resolveCommandArgMenu({
                     command: commandDefinition,
                     args: commandArgs,
                     cfg,
@@ -267,6 +417,8 @@ export function registerSlackMonitorSlashCommands(params) {
                         arg: menu.arg.name,
                         choices: menu.choices,
                         userId: command.user_id,
+                        supportsExternalSelect: supportsExternalArgMenus,
+                        createExternalMenuToken: (choices) => storeSlackExternalArgMenu({ choices, userId: command.user_id }),
                     });
                     await respond({
                         text: title,
@@ -278,28 +430,33 @@ export function registerSlackMonitorSlashCommands(params) {
             }
             const channelName = channelInfo?.name;
             const roomLabel = channelName ? `#${channelName}` : `#${command.channel_id}`;
+            const [{ resolveAgentRoute }, { finalizeInboundContext }, { dispatchReplyWithDispatcher }] = await Promise.all([
+                import("../../routing/resolve-route.js"),
+                import("../../auto-reply/reply/inbound-context.js"),
+                import("../../auto-reply/reply/provider-dispatcher.js"),
+            ]);
+            const [{ resolveConversationLabel }, { createReplyPrefixOptions }] = await Promise.all([
+                import("../../channels/conversation-label.js"),
+                import("../../channels/reply-prefix.js"),
+            ]);
             const route = resolveAgentRoute({
                 cfg,
                 channel: "slack",
                 accountId: account.accountId,
                 teamId: ctx.teamId || undefined,
                 peer: {
-                    kind: isDirectMessage ? "dm" : isRoom ? "channel" : "group",
+                    kind: isDirectMessage ? "direct" : isRoom ? "channel" : "group",
                     id: isDirectMessage ? command.user_id : command.channel_id,
                 },
             });
-            const channelDescription = [channelInfo?.topic, channelInfo?.purpose]
-                .map((entry) => entry?.trim())
-                .filter((entry) => Boolean(entry))
-                .filter((entry, index, list) => list.indexOf(entry) === index)
-                .join("\n");
-            const systemPromptParts = [
-                channelDescription ? `Channel description: ${channelDescription}` : null,
-                channelConfig?.systemPrompt?.trim() || null,
-            ].filter((entry) => Boolean(entry));
-            const groupSystemPrompt = systemPromptParts.length > 0 ? systemPromptParts.join("\n\n") : undefined;
+            const { untrustedChannelMetadata, groupSystemPrompt } = resolveSlackRoomContextHints({
+                isRoomish,
+                channelInfo,
+                channelConfig,
+            });
             const ctxPayload = finalizeInboundContext({
                 Body: prompt,
+                BodyForAgent: prompt,
                 RawBody: prompt,
                 CommandBody: prompt,
                 CommandArgs: commandArgs,
@@ -322,6 +479,7 @@ export function registerSlackMonitorSlashCommands(params) {
                 }) ?? (isDirectMessage ? senderName : roomLabel),
                 GroupSubject: isRoomish ? roomLabel : undefined,
                 GroupSystemPrompt: isRoomish ? groupSystemPrompt : undefined,
+                UntrustedContext: untrustedChannelMetadata ? [untrustedChannelMetadata] : undefined,
                 SenderName: senderName,
                 SenderId: command.user_id,
                 Provider: "slack",
@@ -337,34 +495,20 @@ export function registerSlackMonitorSlashCommands(params) {
                 OriginatingChannel: "slack",
                 OriginatingTo: `user:${command.user_id}`,
             });
-            const { counts } = await dispatchReplyWithDispatcher({
-                ctx: ctxPayload,
+            const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
                 cfg,
-                dispatcherOptions: {
-                    responsePrefix: resolveEffectiveMessagesConfig(cfg, route.agentId).responsePrefix,
-                    deliver: async (payload) => {
-                        await deliverSlackSlashReplies({
-                            replies: [payload],
-                            respond,
-                            ephemeral: slashCommand.ephemeral,
-                            textLimit: ctx.textLimit,
-                            chunkMode: resolveChunkMode(cfg, "slack", route.accountId),
-                            tableMode: resolveMarkdownTableMode({
-                                cfg,
-                                channel: "slack",
-                                accountId: route.accountId,
-                            }),
-                        });
-                    },
-                    onError: (err, info) => {
-                        runtime.error?.(danger(`slack slash ${info.kind} reply failed: ${String(err)}`));
-                    },
-                },
-                replyOptions: { skillFilter: channelConfig?.skills },
+                agentId: route.agentId,
+                channel: "slack",
+                accountId: route.accountId,
             });
-            if (counts.final + counts.tool + counts.block === 0) {
+            const deliverSlashPayloads = async (replies) => {
+                const [{ deliverSlackSlashReplies }, { resolveChunkMode }, { resolveMarkdownTableMode }] = await Promise.all([
+                    import("./replies.js"),
+                    import("../../auto-reply/chunk.js"),
+                    import("../../config/markdown-tables.js"),
+                ]);
                 await deliverSlackSlashReplies({
-                    replies: [],
+                    replies,
                     respond,
                     ephemeral: slashCommand.ephemeral,
                     textLimit: ctx.textLimit,
@@ -375,6 +519,24 @@ export function registerSlackMonitorSlashCommands(params) {
                         accountId: route.accountId,
                     }),
                 });
+            };
+            const { counts } = await dispatchReplyWithDispatcher({
+                ctx: ctxPayload,
+                cfg,
+                dispatcherOptions: {
+                    ...prefixOptions,
+                    deliver: async (payload) => deliverSlashPayloads([payload]),
+                    onError: (err, info) => {
+                        runtime.error?.(danger(`slack slash ${info.kind} reply failed: ${String(err)}`));
+                    },
+                },
+                replyOptions: {
+                    skillFilter: channelConfig?.skills,
+                    onModelSelected,
+                },
+            });
+            if (counts.final + counts.tool + counts.block === 0) {
+                await deliverSlashPayloads([]);
             }
         }
         catch (err) {
@@ -395,22 +557,31 @@ export function registerSlackMonitorSlashCommands(params) {
         providerSetting: account.config.commands?.nativeSkills,
         globalSetting: cfg.commands?.nativeSkills,
     });
-    const skillCommands = nativeEnabled && nativeSkillsEnabled ? listSkillCommandsForAgents({ cfg }) : [];
-    const nativeCommands = nativeEnabled
-        ? listNativeCommandSpecsForConfig(cfg, { skillCommands, provider: "slack" })
-        : [];
+    let reg;
+    let nativeCommands = [];
+    if (nativeEnabled) {
+        reg = await getCommandsRegistry();
+        const skillCommands = nativeSkillsEnabled
+            ? (await import("../../auto-reply/skill-commands.js")).listSkillCommandsForAgents({ cfg })
+            : [];
+        nativeCommands = reg.listNativeCommandSpecsForConfig(cfg, { skillCommands, provider: "slack" });
+    }
     if (nativeCommands.length > 0) {
+        const registry = reg;
+        if (!registry) {
+            throw new Error("Missing commands registry for native Slack commands.");
+        }
         for (const command of nativeCommands) {
             ctx.app.command(`/${command.name}`, async ({ command: cmd, ack, respond }) => {
-                const commandDefinition = findCommandByNativeName(command.name, "slack");
+                const commandDefinition = registry.findCommandByNativeName(command.name, "slack");
                 const rawText = cmd.text?.trim() ?? "";
                 const commandArgs = commandDefinition
-                    ? parseCommandArgs(commandDefinition, rawText)
+                    ? registry.parseCommandArgs(commandDefinition, rawText)
                     : rawText
                         ? { raw: rawText }
                         : undefined;
                 const prompt = commandDefinition
-                    ? buildCommandTextFromArgs(commandDefinition, commandArgs)
+                    ? registry.buildCommandTextFromArgs(commandDefinition, commandArgs)
                     : rawText
                         ? `/${command.name} ${rawText}`
                         : `/${command.name}`;
@@ -438,67 +609,109 @@ export function registerSlackMonitorSlashCommands(params) {
     else {
         logVerbose("slack: slash commands disabled");
     }
-    if (nativeCommands.length === 0 || !supportsInteractiveArgMenus)
+    if (nativeCommands.length === 0 || !supportsInteractiveArgMenus) {
         return;
-    ctx.app.action(SLACK_COMMAND_ARG_ACTION_ID, async (args) => {
-        const { ack, body, respond } = args;
-        const action = args.action;
-        await ack();
-        const respondFn = respond ??
-            (async (payload) => {
-                if (!body.channel?.id || !body.user?.id)
-                    return;
-                await ctx.app.client.chat.postEphemeral({
-                    token: ctx.botToken,
-                    channel: body.channel.id,
-                    user: body.user.id,
-                    text: payload.text,
-                    blocks: payload.blocks,
-                });
-            });
-        const parsed = parseSlackCommandArgValue(action?.value);
-        if (!parsed) {
-            await respondFn({
-                text: "Sorry, that button is no longer valid.",
-                response_type: "ephemeral",
-            });
+    }
+    const registerArgOptions = () => {
+        const optionsHandler = ctx.app.options;
+        if (typeof optionsHandler !== "function") {
             return;
         }
-        if (body.user?.id && parsed.userId !== body.user.id) {
-            await respondFn({
-                text: "That menu is for another user.",
-                response_type: "ephemeral",
+        optionsHandler(SLACK_COMMAND_ARG_ACTION_ID, async ({ ack, body }) => {
+            const typedBody = body;
+            pruneSlackExternalArgMenuStore();
+            const blockId = typedBody.actions?.[0]?.block_id ?? typedBody.block_id;
+            const token = readSlackExternalArgMenuToken(blockId);
+            if (!token) {
+                await ack({ options: [] });
+                return;
+            }
+            const entry = slackExternalArgMenuStore.get(token);
+            if (!entry) {
+                await ack({ options: [] });
+                return;
+            }
+            if (typedBody.user?.id && typedBody.user.id !== entry.userId) {
+                await ack({ options: [] });
+                return;
+            }
+            const query = typedBody.value?.trim().toLowerCase() ?? "";
+            const options = entry.choices
+                .filter((choice) => !query || choice.label.toLowerCase().includes(query))
+                .slice(0, SLACK_COMMAND_ARG_SELECT_OPTIONS_MAX)
+                .map((choice) => ({
+                text: { type: "plain_text", text: choice.label.slice(0, 75) },
+                value: choice.value,
+            }));
+            await ack({ options });
+        });
+    };
+    registerArgOptions();
+    const registerArgAction = (actionId) => {
+        ctx.app.action(actionId, async (args) => {
+            const { ack, body, respond } = args;
+            const action = args.action;
+            await ack();
+            const respondFn = respond ??
+                (async (payload) => {
+                    if (!body.channel?.id || !body.user?.id) {
+                        return;
+                    }
+                    await ctx.app.client.chat.postEphemeral({
+                        token: ctx.botToken,
+                        channel: body.channel.id,
+                        user: body.user.id,
+                        text: payload.text,
+                        blocks: payload.blocks,
+                    });
+                });
+            const actionValue = action?.value ?? action?.selected_option?.value;
+            const parsed = parseSlackCommandArgValue(actionValue);
+            if (!parsed) {
+                await respondFn({
+                    text: "Sorry, that button is no longer valid.",
+                    response_type: "ephemeral",
+                });
+                return;
+            }
+            if (body.user?.id && parsed.userId !== body.user.id) {
+                await respondFn({
+                    text: "That menu is for another user.",
+                    response_type: "ephemeral",
+                });
+                return;
+            }
+            const reg = await getCommandsRegistry();
+            const commandDefinition = reg.findCommandByNativeName(parsed.command, "slack");
+            const commandArgs = {
+                values: { [parsed.arg]: parsed.value },
+            };
+            const prompt = commandDefinition
+                ? reg.buildCommandTextFromArgs(commandDefinition, commandArgs)
+                : `/${parsed.command} ${parsed.value}`;
+            const user = body.user;
+            const userName = user && "name" in user && user.name
+                ? user.name
+                : user && "username" in user && user.username
+                    ? user.username
+                    : (user?.id ?? "");
+            const triggerId = "trigger_id" in body ? body.trigger_id : undefined;
+            const commandPayload = {
+                user_id: user?.id ?? "",
+                user_name: userName,
+                channel_id: body.channel?.id ?? "",
+                channel_name: body.channel?.name ?? body.channel?.id ?? "",
+                trigger_id: triggerId ?? String(Date.now()),
+            };
+            await handleSlashCommand({
+                command: commandPayload,
+                ack: async () => { },
+                respond: respondFn,
+                prompt,
+                commandArgs,
+                commandDefinition: commandDefinition ?? undefined,
             });
-            return;
-        }
-        const commandDefinition = findCommandByNativeName(parsed.command, "slack");
-        const commandArgs = {
-            values: { [parsed.arg]: parsed.value },
-        };
-        const prompt = commandDefinition
-            ? buildCommandTextFromArgs(commandDefinition, commandArgs)
-            : `/${parsed.command} ${parsed.value}`;
-        const user = body.user;
-        const userName = user && "name" in user && user.name
-            ? user.name
-            : user && "username" in user && user.username
-                ? user.username
-                : (user?.id ?? "");
-        const triggerId = "trigger_id" in body ? body.trigger_id : undefined;
-        const commandPayload = {
-            user_id: user?.id ?? "",
-            user_name: userName,
-            channel_id: body.channel?.id ?? "",
-            channel_name: body.channel?.name ?? body.channel?.id ?? "",
-            trigger_id: triggerId ?? String(Date.now()),
-        };
-        await handleSlashCommand({
-            command: commandPayload,
-            ack: async () => { },
-            respond: respondFn,
-            prompt,
-            commandArgs,
-            commandDefinition: commandDefinition ?? undefined,
         });
-    });
+    };
+    registerArgAction(SLACK_COMMAND_ARG_ACTION_ID);
 }