@poolzin/pool-bot 2026.2.21 → 2026.2.23

package/dist/discord/monitor/agent-components.js

@@ -1,15 +1,221 @@
-import { Button, StringSelectMenu, } from "@buape/carbon";
+import { Button, ChannelSelectMenu, MentionableSelectMenu, Modal, RoleSelectMenu, StringSelectMenu, UserSelectMenu, } from "@buape/carbon";
 import { ButtonStyle, ChannelType } from "discord-api-types/v10";
+import { resolveHumanDelayConfig } from "../../agents/identity.js";
+import { resolveChunkMode, resolveTextChunkLimit } from "../../auto-reply/chunk.js";
+import { formatInboundEnvelope, resolveEnvelopeFormatOptions } from "../../auto-reply/envelope.js";
+import { finalizeInboundContext } from "../../auto-reply/reply/inbound-context.js";
+import { dispatchReplyWithBufferedBlockDispatcher } from "../../auto-reply/reply/provider-dispatcher.js";
+import { createReplyReferencePlanner } from "../../auto-reply/reply/reply-reference.js";
+import { createReplyPrefixOptions } from "../../channels/reply-prefix.js";
+import { recordInboundSession } from "../../channels/session.js";
+import { resolveMarkdownTableMode } from "../../config/markdown-tables.js";
+import { readSessionUpdatedAt, resolveStorePath } from "../../config/sessions.js";
 import { logVerbose } from "../../globals.js";
 import { enqueueSystemEvent } from "../../infra/system-events.js";
 import { logDebug, logError } from "../../logger.js";
 import { buildPairingReply } from "../../pairing/pairing-messages.js";
 import { readChannelAllowFromStore, upsertChannelPairingRequest, } from "../../pairing/pairing-store.js";
 import { resolveAgentRoute } from "../../routing/resolve-route.js";
-import { normalizeDiscordAllowList, normalizeDiscordSlug, resolveDiscordAllowListMatch, resolveDiscordChannelConfigWithFallback, resolveDiscordGuildEntry, resolveDiscordUserAllowed, } from "./allow-list.js";
+import { createNonExitingRuntime } from "../../runtime.js";
+import { resolveDiscordComponentEntry, resolveDiscordModalEntry } from "../components-registry.js";
+import { createDiscordFormModal, formatDiscordComponentEventText, parseDiscordComponentCustomId, parseDiscordComponentCustomIdForCarbon, parseDiscordModalCustomId, parseDiscordModalCustomIdForCarbon, } from "../components.js";
+import { normalizeDiscordAllowList, normalizeDiscordSlug, resolveDiscordAllowListMatch, resolveDiscordChannelConfigWithFallback, resolveDiscordGuildEntry, resolveDiscordMemberAccessState, resolveDiscordOwnerAllowFrom, } from "./allow-list.js";
 import { formatDiscordUserTag } from "./format.js";
+import { buildDirectLabel, buildGuildLabel } from "./reply-context.js";
+import { deliverDiscordReply } from "./reply-delivery.js";
+import { sendTyping } from "./typing.js";
 const AGENT_BUTTON_KEY = "agent";
 const AGENT_SELECT_KEY = "agentsel";
+function resolveAgentComponentRoute(params) {
+    return resolveAgentRoute({
+        cfg: params.ctx.cfg,
+        channel: "discord",
+        accountId: params.ctx.accountId,
+        guildId: params.rawGuildId,
+        memberRoleIds: params.memberRoleIds,
+        peer: {
+            kind: params.isDirectMessage ? "direct" : "channel",
+            id: params.isDirectMessage ? params.userId : params.channelId,
+        },
+        parentPeer: params.parentId ? { kind: "channel", id: params.parentId } : undefined,
+    });
+}
+async function ackComponentInteraction(params) {
+    try {
+        await params.interaction.reply({
+            content: "✓",
+            ...params.replyOpts,
+        });
+    }
+    catch (err) {
+        logError(`${params.label}: failed to acknowledge interaction: ${String(err)}`);
+    }
+}
+function resolveDiscordChannelContext(interaction) {
+    const channel = interaction.channel;
+    const channelName = channel && "name" in channel ? channel.name : undefined;
+    const channelSlug = channelName ? normalizeDiscordSlug(channelName) : "";
+    const channelType = channel && "type" in channel ? channel.type : undefined;
+    const isThread = isThreadChannelType(channelType);
+    let parentId;
+    let parentName;
+    let parentSlug = "";
+    if (isThread && channel && "parentId" in channel) {
+        parentId = channel.parentId ?? undefined;
+        if ("parent" in channel) {
+            const parent = channel.parent;
+            if (parent?.name) {
+                parentName = parent.name;
+                parentSlug = normalizeDiscordSlug(parentName);
+            }
+        }
+    }
+    return { channelName, channelSlug, channelType, isThread, parentId, parentName, parentSlug };
+}
+async function resolveComponentInteractionContext(params) {
+    const { interaction, label } = params;
+    // Use interaction's actual channel_id (trusted source from Discord)
+    // This prevents channel spoofing attacks
+    const channelId = interaction.rawData.channel_id;
+    if (!channelId) {
+        logError(`${label}: missing channel_id in interaction`);
+        return null;
+    }
+    const user = interaction.user;
+    if (!user) {
+        logError(`${label}: missing user in interaction`);
+        return null;
+    }
+    const shouldDefer = params.defer !== false && "defer" in interaction;
+    let didDefer = false;
+    // Defer immediately to satisfy Discord's 3-second interaction ACK requirement.
+    // We use an ephemeral deferred reply so subsequent interaction.reply() calls
+    // can safely edit the original deferred response.
+    if (shouldDefer) {
+        try {
+            await interaction.defer({ ephemeral: true });
+            didDefer = true;
+        }
+        catch (err) {
+            logError(`${label}: failed to defer interaction: ${String(err)}`);
+        }
+    }
+    const replyOpts = didDefer ? {} : { ephemeral: true };
+    const username = formatUsername(user);
+    const userId = user.id;
+    // P1 FIX: Use rawData.guild_id as source of truth - interaction.guild can be null
+    // when guild is not cached even though guild_id is present in rawData
+    const rawGuildId = interaction.rawData.guild_id;
+    const isDirectMessage = !rawGuildId;
+    const memberRoleIds = Array.isArray(interaction.rawData.member?.roles)
+        ? interaction.rawData.member.roles.map((roleId) => String(roleId))
+        : [];
+    return {
+        channelId,
+        user,
+        username,
+        userId,
+        replyOpts,
+        rawGuildId,
+        isDirectMessage,
+        memberRoleIds,
+    };
+}
+async function ensureGuildComponentMemberAllowed(params) {
+    const { interaction, guildInfo, channelId, rawGuildId, channelCtx, memberRoleIds, user, replyOpts, componentLabel, unauthorizedReply, } = params;
+    if (!rawGuildId) {
+        return true;
+    }
+    const channelConfig = resolveDiscordChannelConfigWithFallback({
+        guildInfo,
+        channelId,
+        channelName: channelCtx.channelName,
+        channelSlug: channelCtx.channelSlug,
+        parentId: channelCtx.parentId,
+        parentName: channelCtx.parentName,
+        parentSlug: channelCtx.parentSlug,
+        scope: channelCtx.isThread ? "thread" : "channel",
+    });
+    const { memberAllowed } = resolveDiscordMemberAccessState({
+        channelConfig,
+        guildInfo,
+        memberRoleIds,
+        sender: {
+            id: user.id,
+            name: user.username,
+            tag: user.discriminator ? `${user.username}#${user.discriminator}` : undefined,
+        },
+    });
+    if (memberAllowed) {
+        return true;
+    }
+    logVerbose(`agent ${componentLabel}: blocked user ${user.id} (not in users/roles allowlist)`);
+    try {
+        await interaction.reply({
+            content: unauthorizedReply,
+            ...replyOpts,
+        });
+    }
+    catch {
+        // Interaction may have expired
+    }
+    return false;
+}
+async function ensureComponentUserAllowed(params) {
+    const allowList = normalizeDiscordAllowList(params.entry.allowedUsers, [
+        "discord:",
+        "user:",
+        "pk:",
+    ]);
+    if (!allowList) {
+        return true;
+    }
+    const match = resolveDiscordAllowListMatch({
+        allowList,
+        candidate: {
+            id: params.user.id,
+            name: params.user.username,
+            tag: formatDiscordUserTag(params.user),
+        },
+    });
+    if (match.allowed) {
+        return true;
+    }
+    logVerbose(`discord component ${params.componentLabel}: blocked user ${params.user.id} (not in allowedUsers)`);
+    try {
+        await params.interaction.reply({
+            content: params.unauthorizedReply,
+            ...params.replyOpts,
+        });
+    }
+    catch {
+        // Interaction may have expired
+    }
+    return false;
+}
+async function ensureAgentComponentInteractionAllowed(params) {
+    const guildInfo = resolveDiscordGuildEntry({
+        guild: params.interaction.guild ?? undefined,
+        guildEntries: params.ctx.guildEntries,
+    });
+    const channelCtx = resolveDiscordChannelContext(params.interaction);
+    const memberAllowed = await ensureGuildComponentMemberAllowed({
+        interaction: params.interaction,
+        guildInfo,
+        channelId: params.channelId,
+        rawGuildId: params.rawGuildId,
+        channelCtx,
+        memberRoleIds: params.memberRoleIds,
+        user: params.user,
+        replyOpts: params.replyOpts,
+        componentLabel: params.componentLabel,
+        unauthorizedReply: params.unauthorizedReply,
+    });
+    if (!memberAllowed) {
+        return null;
+    }
+    return { parentId: channelCtx.parentId };
+}
 /**
  * Build agent button custom ID: agent:componentId=<id>
  * The channelId is NOT embedded in customId - we use interaction.rawData.channel_id instead
@@ -59,14 +265,14 @@ function isThreadChannelType(channelType) {
         channelType === ChannelType.AnnouncementThread);
 }
 async function ensureDmComponentAuthorized(params) {
-    const { ctx, interaction, user, componentLabel } = params;
+    const { ctx, interaction, user, componentLabel, replyOpts } = params;
     const dmPolicy = ctx.dmPolicy ?? "pairing";
     if (dmPolicy === "disabled") {
         logVerbose(`agent ${componentLabel}: blocked (DM policy disabled)`);
         try {
             await interaction.reply({
                 content: "DM interactions are disabled.",
-                ephemeral: true,
+                ...replyOpts,
             });
         }
         catch {
@@ -111,7 +317,7 @@ async function ensureDmComponentAuthorized(params) {
                         code,
                     })
                     : "Pairing already requested. Ask the bot owner to approve your code.",
-                ephemeral: true,
+                ...replyOpts,
             });
         }
         catch {
@@ -123,7 +329,7 @@ async function ensureDmComponentAuthorized(params) {
     try {
         await interaction.reply({
             content: `You are not authorized to use this ${componentLabel}.`,
-            ephemeral: true,
+            ...replyOpts,
         });
     }
     catch {
@@ -131,6 +337,597 @@ async function ensureDmComponentAuthorized(params) {
     }
     return false;
 }
+async function resolveInteractionContextWithDmAuth(params) {
+    const interactionCtx = await resolveComponentInteractionContext({
+        interaction: params.interaction,
+        label: params.label,
+        defer: params.defer,
+    });
+    if (!interactionCtx) {
+        return null;
+    }
+    if (interactionCtx.isDirectMessage) {
+        const authorized = await ensureDmComponentAuthorized({
+            ctx: params.ctx,
+            interaction: params.interaction,
+            user: interactionCtx.user,
+            componentLabel: params.componentLabel,
+            replyOpts: interactionCtx.replyOpts,
+        });
+        if (!authorized) {
+            return null;
+        }
+    }
+    return interactionCtx;
+}
+function normalizeComponentId(value) {
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        return trimmed ? trimmed : undefined;
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return String(value);
+    }
+    return undefined;
+}
+function parseDiscordComponentData(data, customId) {
+    if (!data || typeof data !== "object") {
+        return null;
+    }
+    const rawComponentId = "cid" in data
+        ? data.cid
+        : data.componentId;
+    const rawModalId = "mid" in data ? data.mid : data.modalId;
+    let componentId = normalizeComponentId(rawComponentId);
+    let modalId = normalizeComponentId(rawModalId);
+    if (!componentId && customId) {
+        const parsed = parseDiscordComponentCustomId(customId);
+        if (parsed) {
+            componentId = parsed.componentId;
+            modalId = parsed.modalId;
+        }
+    }
+    if (!componentId) {
+        return null;
+    }
+    return { componentId, modalId };
+}
+function parseDiscordModalId(data, customId) {
+    if (data && typeof data === "object") {
+        const rawModalId = "mid" in data ? data.mid : data.modalId;
+        const modalId = normalizeComponentId(rawModalId);
+        if (modalId) {
+            return modalId;
+        }
+    }
+    if (customId) {
+        return parseDiscordModalCustomId(customId);
+    }
+    return null;
+}
+function resolveInteractionCustomId(interaction) {
+    if (!interaction?.rawData || typeof interaction.rawData !== "object") {
+        return undefined;
+    }
+    if (!("data" in interaction.rawData)) {
+        return undefined;
+    }
+    const data = interaction.rawData.data;
+    const customId = data?.custom_id;
+    if (typeof customId !== "string") {
+        return undefined;
+    }
+    const trimmed = customId.trim();
+    return trimmed ? trimmed : undefined;
+}
+function mapOptionLabels(options, values) {
+    if (!options || options.length === 0) {
+        return values;
+    }
+    const map = new Map(options.map((option) => [option.value, option.label]));
+    return values.map((value) => map.get(value) ?? value);
+}
+function mapSelectValues(entry, values) {
+    if (entry.selectType === "string") {
+        return mapOptionLabels(entry.options, values);
+    }
+    if (entry.selectType === "user") {
+        return values.map((value) => `user:${value}`);
+    }
+    if (entry.selectType === "role") {
+        return values.map((value) => `role:${value}`);
+    }
+    if (entry.selectType === "mentionable") {
+        return values.map((value) => `mentionable:${value}`);
+    }
+    if (entry.selectType === "channel") {
+        return values.map((value) => `channel:${value}`);
+    }
+    return values;
+}
+function resolveModalFieldValues(field, interaction) {
+    const fields = interaction.fields;
+    const optionLabels = field.options?.map((option) => ({
+        value: option.value,
+        label: option.label,
+    }));
+    const required = field.required === true;
+    try {
+        switch (field.type) {
+            case "text": {
+                const value = required ? fields.getText(field.id, true) : fields.getText(field.id);
+                return value ? [value] : [];
+            }
+            case "select":
+            case "checkbox":
+            case "radio": {
+                const values = required
+                    ? fields.getStringSelect(field.id, true)
+                    : (fields.getStringSelect(field.id) ?? []);
+                return mapOptionLabels(optionLabels, values);
+            }
+            case "role-select": {
+                try {
+                    const roles = required
+                        ? fields.getRoleSelect(field.id, true)
+                        : (fields.getRoleSelect(field.id) ?? []);
+                    return roles.map((role) => role.name ?? role.id);
+                }
+                catch {
+                    const values = required
+                        ? fields.getStringSelect(field.id, true)
+                        : (fields.getStringSelect(field.id) ?? []);
+                    return values;
+                }
+            }
+            case "user-select": {
+                const users = required
+                    ? fields.getUserSelect(field.id, true)
+                    : (fields.getUserSelect(field.id) ?? []);
+                return users.map((user) => formatDiscordUserTag(user));
+            }
+            default:
+                return [];
+        }
+    }
+    catch (err) {
+        logError(`agent modal: failed to read field ${field.id}: ${String(err)}`);
+        return [];
+    }
+}
+function formatModalSubmissionText(entry, interaction) {
+    const lines = [`Form "${entry.title}" submitted.`];
+    for (const field of entry.fields) {
+        const values = resolveModalFieldValues(field, interaction);
+        if (values.length === 0) {
+            continue;
+        }
+        lines.push(`- ${field.label}: ${values.join(", ")}`);
+    }
+    if (lines.length === 1) {
+        lines.push("- (no values)");
+    }
+    return lines.join("\n");
+}
+async function dispatchDiscordComponentEvent(params) {
+    const { ctx, interaction, interactionCtx, channelCtx, guildInfo, eventText } = params;
+    const runtime = ctx.runtime ?? createNonExitingRuntime();
+    const route = resolveAgentRoute({
+        cfg: ctx.cfg,
+        channel: "discord",
+        accountId: ctx.accountId,
+        guildId: interactionCtx.rawGuildId,
+        memberRoleIds: interactionCtx.memberRoleIds,
+        peer: {
+            kind: interactionCtx.isDirectMessage ? "direct" : "channel",
+            id: interactionCtx.isDirectMessage ? interactionCtx.userId : interactionCtx.channelId,
+        },
+        parentPeer: channelCtx.parentId ? { kind: "channel", id: channelCtx.parentId } : undefined,
+    });
+    const sessionKey = params.routeOverrides?.sessionKey ?? route.sessionKey;
+    const agentId = params.routeOverrides?.agentId ?? route.agentId;
+    const accountId = params.routeOverrides?.accountId ?? route.accountId;
+    const fromLabel = interactionCtx.isDirectMessage
+        ? buildDirectLabel(interactionCtx.user)
+        : buildGuildLabel({
+            guild: interaction.guild ?? undefined,
+            channelName: channelCtx.channelName ?? interactionCtx.channelId,
+            channelId: interactionCtx.channelId,
+        });
+    const senderName = interactionCtx.user.globalName ?? interactionCtx.user.username;
+    const senderUsername = interactionCtx.user.username;
+    const senderTag = formatDiscordUserTag(interactionCtx.user);
+    const groupChannel = !interactionCtx.isDirectMessage && channelCtx.channelSlug
+        ? `#${channelCtx.channelSlug}`
+        : undefined;
+    const groupSubject = interactionCtx.isDirectMessage ? undefined : groupChannel;
+    const channelConfig = resolveDiscordChannelConfigWithFallback({
+        guildInfo,
+        channelId: interactionCtx.channelId,
+        channelName: channelCtx.channelName,
+        channelSlug: channelCtx.channelSlug,
+        parentId: channelCtx.parentId,
+        parentName: channelCtx.parentName,
+        parentSlug: channelCtx.parentSlug,
+        scope: channelCtx.isThread ? "thread" : "channel",
+    });
+    const groupSystemPrompt = channelConfig?.systemPrompt?.trim() || undefined;
+    const ownerAllowFrom = resolveDiscordOwnerAllowFrom({
+        channelConfig,
+        guildInfo,
+        sender: { id: interactionCtx.user.id, name: interactionCtx.user.username, tag: senderTag },
+    });
+    const storePath = resolveStorePath(ctx.cfg.session?.store, { agentId });
+    const envelopeOptions = resolveEnvelopeFormatOptions(ctx.cfg);
+    const previousTimestamp = readSessionUpdatedAt({
+        storePath,
+        sessionKey,
+    });
+    const timestamp = Date.now();
+    const combinedBody = formatInboundEnvelope({
+        channel: "Discord",
+        from: fromLabel,
+        timestamp,
+        body: eventText,
+        chatType: interactionCtx.isDirectMessage ? "direct" : "channel",
+        senderLabel: senderName,
+        previousTimestamp,
+        envelope: envelopeOptions,
+    });
+    const ctxPayload = finalizeInboundContext({
+        Body: combinedBody,
+        BodyForAgent: eventText,
+        RawBody: eventText,
+        CommandBody: eventText,
+        From: interactionCtx.isDirectMessage
+            ? `discord:${interactionCtx.userId}`
+            : `discord:channel:${interactionCtx.channelId}`,
+        To: `channel:${interactionCtx.channelId}`,
+        SessionKey: sessionKey,
+        AccountId: accountId,
+        ChatType: interactionCtx.isDirectMessage ? "direct" : "channel",
+        ConversationLabel: fromLabel,
+        SenderName: senderName,
+        SenderId: interactionCtx.userId,
+        SenderUsername: senderUsername,
+        SenderTag: senderTag,
+        GroupSubject: groupSubject,
+        GroupChannel: groupChannel,
+        GroupSystemPrompt: interactionCtx.isDirectMessage ? undefined : groupSystemPrompt,
+        GroupSpace: guildInfo?.id ?? guildInfo?.slug ?? interactionCtx.rawGuildId ?? undefined,
+        OwnerAllowFrom: ownerAllowFrom,
+        Provider: "discord",
+        Surface: "discord",
+        WasMentioned: true,
+        CommandAuthorized: true,
+        CommandSource: "text",
+        MessageSid: interaction.rawData.id,
+        Timestamp: timestamp,
+        OriginatingChannel: "discord",
+        OriginatingTo: `channel:${interactionCtx.channelId}`,
+    });
+    await recordInboundSession({
+        storePath,
+        sessionKey: ctxPayload.SessionKey ?? sessionKey,
+        ctx: ctxPayload,
+        updateLastRoute: interactionCtx.isDirectMessage
+            ? {
+                sessionKey: route.mainSessionKey,
+                channel: "discord",
+                to: `user:${interactionCtx.userId}`,
+                accountId,
+            }
+            : undefined,
+        onRecordError: (err) => {
+            logVerbose(`discord: failed updating component session meta: ${String(err)}`);
+        },
+    });
+    const deliverTarget = `channel:${interactionCtx.channelId}`;
+    const typingChannelId = interactionCtx.channelId;
+    const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
+        cfg: ctx.cfg,
+        agentId,
+        channel: "discord",
+        accountId,
+    });
+    const tableMode = resolveMarkdownTableMode({
+        cfg: ctx.cfg,
+        channel: "discord",
+        accountId,
+    });
+    const textLimit = resolveTextChunkLimit(ctx.cfg, "discord", accountId, {
+        fallbackLimit: 2000,
+    });
+    const token = ctx.token ?? "";
+    const replyToMode = ctx.discordConfig?.replyToMode ?? ctx.cfg.channels?.discord?.replyToMode ?? "off";
+    const replyReference = createReplyReferencePlanner({
+        replyToMode,
+        startId: params.replyToId,
+    });
+    await dispatchReplyWithBufferedBlockDispatcher({
+        ctx: ctxPayload,
+        cfg: ctx.cfg,
+        replyOptions: { onModelSelected },
+        dispatcherOptions: {
+            ...prefixOptions,
+            humanDelay: resolveHumanDelayConfig(ctx.cfg, agentId),
+            deliver: async (payload) => {
+                const replyToId = replyReference.use();
+                await deliverDiscordReply({
+                    replies: [payload],
+                    target: deliverTarget,
+                    token,
+                    accountId,
+                    rest: interaction.client.rest,
+                    runtime,
+                    replyToId,
+                    textLimit,
+                    maxLinesPerMessage: ctx.discordConfig?.maxLinesPerMessage,
+                    tableMode,
+                    chunkMode: resolveChunkMode(ctx.cfg, "discord", accountId),
+                });
+                replyReference.markSent();
+            },
+            onReplyStart: async () => {
+                try {
+                    await sendTyping({ client: interaction.client, channelId: typingChannelId });
+                }
+                catch (err) {
+                    logVerbose(`discord: typing failed for component reply: ${String(err)}`);
+                }
+            },
+            onError: (err) => {
+                logError(`discord component dispatch failed: ${String(err)}`);
+            },
+        },
+    });
+}
+async function handleDiscordComponentEvent(params) {
+    const parsed = parseDiscordComponentData(params.data, resolveInteractionCustomId(params.interaction));
+    if (!parsed) {
+        logError(`${params.label}: failed to parse component data`);
+        try {
+            await params.interaction.reply({
+                content: "This component is no longer valid.",
+                ephemeral: true,
+            });
+        }
+        catch {
+            // Interaction may have expired
+        }
+        return;
+    }
+    const entry = resolveDiscordComponentEntry({ id: parsed.componentId, consume: false });
+    if (!entry) {
+        try {
+            await params.interaction.reply({
+                content: "This component has expired.",
+                ephemeral: true,
+            });
+        }
+        catch {
+            // Interaction may have expired
+        }
+        return;
+    }
+    const interactionCtx = await resolveInteractionContextWithDmAuth({
+        ctx: params.ctx,
+        interaction: params.interaction,
+        label: params.label,
+        componentLabel: params.componentLabel,
+    });
+    if (!interactionCtx) {
+        return;
+    }
+    const { channelId, user, replyOpts, rawGuildId, memberRoleIds } = interactionCtx;
+    const guildInfo = resolveDiscordGuildEntry({
+        guild: params.interaction.guild ?? undefined,
+        guildEntries: params.ctx.guildEntries,
+    });
+    const channelCtx = resolveDiscordChannelContext(params.interaction);
+    const unauthorizedReply = `You are not authorized to use this ${params.componentLabel}.`;
+    const memberAllowed = await ensureGuildComponentMemberAllowed({
+        interaction: params.interaction,
+        guildInfo,
+        channelId,
+        rawGuildId,
+        channelCtx,
+        memberRoleIds,
+        user,
+        replyOpts,
+        componentLabel: params.componentLabel,
+        unauthorizedReply,
+    });
+    if (!memberAllowed) {
+        return;
+    }
+    const componentAllowed = await ensureComponentUserAllowed({
+        entry,
+        interaction: params.interaction,
+        user,
+        replyOpts,
+        componentLabel: params.componentLabel,
+        unauthorizedReply,
+    });
+    if (!componentAllowed) {
+        return;
+    }
+    const consumed = resolveDiscordComponentEntry({
+        id: parsed.componentId,
+        consume: !entry.reusable,
+    });
+    if (!consumed) {
+        try {
+            await params.interaction.reply({
+                content: "This component has expired.",
+                ephemeral: true,
+            });
+        }
+        catch {
+            // Interaction may have expired
+        }
+        return;
+    }
+    if (consumed.kind === "modal-trigger") {
+        try {
+            await params.interaction.reply({
+                content: "This form is no longer available.",
+                ephemeral: true,
+            });
+        }
+        catch {
+            // Interaction may have expired
+        }
+        return;
+    }
+    const values = params.values ? mapSelectValues(consumed, params.values) : undefined;
+    const eventText = formatDiscordComponentEventText({
+        kind: consumed.kind === "select" ? "select" : "button",
+        label: consumed.label,
+        values,
+    });
+    try {
+        await params.interaction.reply({ content: "✓", ...replyOpts });
+    }
+    catch (err) {
+        logError(`${params.label}: failed to acknowledge interaction: ${String(err)}`);
+    }
+    await dispatchDiscordComponentEvent({
+        ctx: params.ctx,
+        interaction: params.interaction,
+        interactionCtx,
+        channelCtx,
+        guildInfo,
+        eventText,
+        replyToId: consumed.messageId ?? params.interaction.message?.id,
+        routeOverrides: {
+            sessionKey: consumed.sessionKey,
+            agentId: consumed.agentId,
+            accountId: consumed.accountId,
+        },
+    });
+}
+async function handleDiscordModalTrigger(params) {
+    const parsed = parseDiscordComponentData(params.data, resolveInteractionCustomId(params.interaction));
+    if (!parsed) {
+        logError(`${params.label}: failed to parse modal trigger data`);
+        try {
+            await params.interaction.reply({
+                content: "This button is no longer valid.",
+                ephemeral: true,
+            });
+        }
+        catch {
+            // Interaction may have expired
+        }
+        return;
+    }
+    const entry = resolveDiscordComponentEntry({ id: parsed.componentId, consume: false });
+    if (!entry || entry.kind !== "modal-trigger") {
+        try {
+            await params.interaction.reply({
+                content: "This button has expired.",
+                ephemeral: true,
+            });
+        }
+        catch {
+            // Interaction may have expired
+        }
+        return;
+    }
+    const modalId = entry.modalId ?? parsed.modalId;
+    if (!modalId) {
+        try {
+            await params.interaction.reply({
+                content: "This form is no longer available.",
+                ephemeral: true,
+            });
+        }
+        catch {
+            // Interaction may have expired
+        }
+        return;
+    }
+    const interactionCtx = await resolveInteractionContextWithDmAuth({
+        ctx: params.ctx,
+        interaction: params.interaction,
+        label: params.label,
+        componentLabel: "form",
+        defer: false,
+    });
+    if (!interactionCtx) {
+        return;
+    }
+    const { channelId, user, replyOpts, rawGuildId, memberRoleIds } = interactionCtx;
+    const guildInfo = resolveDiscordGuildEntry({
+        guild: params.interaction.guild ?? undefined,
+        guildEntries: params.ctx.guildEntries,
+    });
+    const channelCtx = resolveDiscordChannelContext(params.interaction);
+    const unauthorizedReply = "You are not authorized to use this form.";
+    const memberAllowed = await ensureGuildComponentMemberAllowed({
+        interaction: params.interaction,
+        guildInfo,
+        channelId,
+        rawGuildId,
+        channelCtx,
+        memberRoleIds,
+        user,
+        replyOpts,
+        componentLabel: "form",
+        unauthorizedReply,
+    });
+    if (!memberAllowed) {
+        return;
+    }
+    const componentAllowed = await ensureComponentUserAllowed({
+        entry,
+        interaction: params.interaction,
+        user,
+        replyOpts,
+        componentLabel: "form",
+        unauthorizedReply,
+    });
+    if (!componentAllowed) {
+        return;
+    }
+    const consumed = resolveDiscordComponentEntry({
+        id: parsed.componentId,
+        consume: !entry.reusable,
+    });
+    if (!consumed) {
+        try {
+            await params.interaction.reply({
+                content: "This form has expired.",
+                ephemeral: true,
+            });
+        }
+        catch {
+            // Interaction may have expired
+        }
+        return;
+    }
+    const resolvedModalId = consumed.modalId ?? modalId;
+    const modalEntry = resolveDiscordModalEntry({ id: resolvedModalId, consume: false });
+    if (!modalEntry) {
+        try {
+            await params.interaction.reply({
+                content: "This form has expired.",
+                ephemeral: true,
+            });
+        }
+        catch {
+            // Interaction may have expired
+        }
+        return;
+    }
+    try {
+        await params.interaction.showModal(createDiscordFormModal(modalEntry));
+    }
+    catch (err) {
+        logError(`${params.label}: failed to show modal: ${String(err)}`);
+    }
+}
 export class AgentComponentButton extends Button {
     label = AGENT_BUTTON_KEY;
     customId = `${AGENT_BUTTON_KEY}:seed=1`;
@@ -157,112 +954,41 @@ export class AgentComponentButton extends Button {
             return;
         }
         const { componentId } = parsed;
-        // P1 FIX: Use interaction's actual channel_id instead of trusting customId
-        // This prevents channel ID spoofing attacks where an attacker crafts a button
-        // with a different channelId to inject events into other sessions
-        const channelId = interaction.rawData.channel_id;
-        if (!channelId) {
-            logError("agent button: missing channel_id in interaction");
-            return;
-        }
-        const user = interaction.user;
-        if (!user) {
-            logError("agent button: missing user in interaction");
+        const interactionCtx = await resolveInteractionContextWithDmAuth({
+            ctx: this.ctx,
+            interaction,
+            label: "agent button",
+            componentLabel: "button",
+        });
+        if (!interactionCtx) {
             return;
         }
-        const username = formatUsername(user);
-        const userId = user.id;
-        // P1 FIX: Use rawData.guild_id as source of truth - interaction.guild can be null
-        // when guild is not cached even though guild_id is present in rawData
-        const rawGuildId = interaction.rawData.guild_id;
-        const isDirectMessage = !rawGuildId;
-        if (isDirectMessage) {
-            const authorized = await ensureDmComponentAuthorized({
-                ctx: this.ctx,
-                interaction,
-                user,
-                componentLabel: "button",
-            });
-            if (!authorized) {
-                return;
-            }
-        }
-        // P2 FIX: Check user allowlist before processing component interaction
-        // This prevents unauthorized users from injecting system events
-        const guild = interaction.guild;
-        const guildInfo = resolveDiscordGuildEntry({
-            guild: guild ?? undefined,
-            guildEntries: this.ctx.guildEntries,
+        const { channelId, user, username, userId, replyOpts, rawGuildId, isDirectMessage, memberRoleIds, } = interactionCtx;
+        // Check user allowlist before processing component interaction
+        // This prevents unauthorized users from injecting system events.
+        const allowed = await ensureAgentComponentInteractionAllowed({
+            ctx: this.ctx,
+            interaction,
+            channelId,
+            rawGuildId,
+            memberRoleIds,
+            user,
+            replyOpts,
+            componentLabel: "button",
+            unauthorizedReply: "You are not authorized to use this button.",
         });
-        // Resolve channel info for thread detection and allowlist inheritance
-        const channel = interaction.channel;
-        const channelName = channel && "name" in channel ? channel.name : undefined;
-        const channelSlug = channelName ? normalizeDiscordSlug(channelName) : "";
-        const channelType = channel && "type" in channel ? channel.type : undefined;
-        const isThread = isThreadChannelType(channelType);
-        // Resolve thread parent for allowlist inheritance
-        // Note: We can get parentId from channel but cannot fetch parent name without a client.
-        // The parentId alone enables ID-based parent config matching. Name-based matching
-        // requires the channel cache to have parent info available.
-        let parentId;
-        let parentName;
-        let parentSlug = "";
-        if (isThread && channel && "parentId" in channel) {
-            parentId = channel.parentId ?? undefined;
-            // Try to get parent name from channel's parent if available
-            if ("parent" in channel) {
-                const parent = channel.parent;
-                if (parent?.name) {
-                    parentName = parent.name;
-                    parentSlug = normalizeDiscordSlug(parentName);
-                }
-            }
-        }
-        // Only check guild allowlists if this is a guild interaction
-        if (rawGuildId) {
-            const channelConfig = resolveDiscordChannelConfigWithFallback({
-                guildInfo,
-                channelId,
-                channelName,
-                channelSlug,
-                parentId,
-                parentName,
-                parentSlug,
-                scope: isThread ? "thread" : "channel",
-            });
-            const channelUsers = channelConfig?.users ?? guildInfo?.users;
-            if (Array.isArray(channelUsers) && channelUsers.length > 0) {
-                const userOk = resolveDiscordUserAllowed({
-                    allowList: channelUsers,
-                    userId,
-                    userName: user.username,
-                    userTag: user.discriminator ? `${user.username}#${user.discriminator}` : undefined,
-                });
-                if (!userOk) {
-                    logVerbose(`agent button: blocked user ${userId} (not in allowlist)`);
-                    try {
-                        await interaction.reply({
-                            content: "You are not authorized to use this button.",
-                            ephemeral: true,
-                        });
-                    }
-                    catch {
-                        // Interaction may have expired
-                    }
-                    return;
-                }
-            }
+        if (!allowed) {
+            return;
         }
-        // Resolve route with full context (guildId, proper peer kind)
-        const route = resolveAgentRoute({
-            cfg: this.ctx.cfg,
-            channel: "discord",
-            accountId: this.ctx.accountId,
-            guildId: rawGuildId,
-            peer: {
-                kind: isDirectMessage ? "dm" : "channel",
-                id: isDirectMessage ? userId : channelId,
-            },
+        const { parentId } = allowed;
+        const route = resolveAgentComponentRoute({
+            ctx: this.ctx,
+            rawGuildId,
+            memberRoleIds,
+            isDirectMessage,
+            userId,
+            channelId,
+            parentId,
         });
         const eventText = `[Discord component: ${componentId} clicked by ${username} (${userId})]`;
         logDebug(`agent button: enqueuing event for channel ${channelId}: ${eventText}`);
@@ -270,16 +996,7 @@ export class AgentComponentButton extends Button {
             sessionKey: route.sessionKey,
             contextKey: `discord:agent-button:${channelId}:${componentId}:${userId}`,
         });
-        // Acknowledge the interaction
-        try {
-            await interaction.reply({
-                content: "✓",
-                ephemeral: true,
-            });
-        }
-        catch (err) {
-            logError(`agent button: failed to acknowledge interaction: ${String(err)}`);
-        }
+        await ackComponentInteraction({ interaction, replyOpts, label: "agent button" });
     }
 }
 export class AgentSelectMenu extends StringSelectMenu {
@@ -307,127 +1024,285 @@ export class AgentSelectMenu extends StringSelectMenu {
             return;
         }
         const { componentId } = parsed;
-        // Use interaction's actual channel_id (trusted source from Discord)
-        // This prevents channel spoofing attacks
-        const channelId = interaction.rawData.channel_id;
-        if (!channelId) {
-            logError("agent select: missing channel_id in interaction");
+        const interactionCtx = await resolveInteractionContextWithDmAuth({
+            ctx: this.ctx,
+            interaction,
+            label: "agent select",
+            componentLabel: "select menu",
+        });
+        if (!interactionCtx) {
             return;
         }
-        const user = interaction.user;
-        if (!user) {
-            logError("agent select: missing user in interaction");
+        const { channelId, user, username, userId, replyOpts, rawGuildId, isDirectMessage, memberRoleIds, } = interactionCtx;
+        // Check user allowlist before processing component interaction.
+        const allowed = await ensureAgentComponentInteractionAllowed({
+            ctx: this.ctx,
+            interaction,
+            channelId,
+            rawGuildId,
+            memberRoleIds,
+            user,
+            replyOpts,
+            componentLabel: "select",
+            unauthorizedReply: "You are not authorized to use this select menu.",
+        });
+        if (!allowed) {
             return;
         }
-        const username = formatUsername(user);
-        const userId = user.id;
-        // P1 FIX: Use rawData.guild_id as source of truth - interaction.guild can be null
-        // when guild is not cached even though guild_id is present in rawData
-        const rawGuildId = interaction.rawData.guild_id;
-        const isDirectMessage = !rawGuildId;
-        if (isDirectMessage) {
-            const authorized = await ensureDmComponentAuthorized({
+        const { parentId } = allowed;
+        // Extract selected values
+        const values = interaction.values ?? [];
+        const valuesText = values.length > 0 ? ` (selected: ${values.join(", ")})` : "";
+        const route = resolveAgentComponentRoute({
+            ctx: this.ctx,
+            rawGuildId,
+            memberRoleIds,
+            isDirectMessage,
+            userId,
+            channelId,
+            parentId,
+        });
+        const eventText = `[Discord select menu: ${componentId} interacted by ${username} (${userId})${valuesText}]`;
+        logDebug(`agent select: enqueuing event for channel ${channelId}: ${eventText}`);
+        enqueueSystemEvent(eventText, {
+            sessionKey: route.sessionKey,
+            contextKey: `discord:agent-select:${channelId}:${componentId}:${userId}`,
+        });
+        await ackComponentInteraction({ interaction, replyOpts, label: "agent select" });
+    }
+}
+class DiscordComponentButton extends Button {
+    label = "component";
+    customId = "*";
+    style = ButtonStyle.Primary;
+    customIdParser = parseDiscordComponentCustomIdForCarbon;
+    ctx;
+    constructor(ctx) {
+        super();
+        this.ctx = ctx;
+    }
+    async run(interaction, data) {
+        const parsed = parseDiscordComponentData(data, resolveInteractionCustomId(interaction));
+        if (parsed?.modalId) {
+            await handleDiscordModalTrigger({
                 ctx: this.ctx,
                 interaction,
-                user,
-                componentLabel: "select menu",
+                data,
+                label: "discord component modal",
             });
-            if (!authorized) {
-                return;
-            }
+            return;
         }
-        // Check user allowlist before processing component interaction
-        const guild = interaction.guild;
-        const guildInfo = resolveDiscordGuildEntry({
-            guild: guild ?? undefined,
-            guildEntries: this.ctx.guildEntries,
+        await handleDiscordComponentEvent({
+            ctx: this.ctx,
+            interaction,
+            data,
+            componentLabel: "button",
+            label: "discord component button",
         });
-        // Resolve channel info for thread detection and allowlist inheritance
-        const channel = interaction.channel;
-        const channelName = channel && "name" in channel ? channel.name : undefined;
-        const channelSlug = channelName ? normalizeDiscordSlug(channelName) : "";
-        const channelType = channel && "type" in channel ? channel.type : undefined;
-        const isThread = isThreadChannelType(channelType);
-        // Resolve thread parent for allowlist inheritance
-        let parentId;
-        let parentName;
-        let parentSlug = "";
-        if (isThread && channel && "parentId" in channel) {
-            parentId = channel.parentId ?? undefined;
-            // Try to get parent name from channel's parent if available
-            if ("parent" in channel) {
-                const parent = channel.parent;
-                if (parent?.name) {
-                    parentName = parent.name;
-                    parentSlug = normalizeDiscordSlug(parentName);
-                }
+    }
+}
+class DiscordComponentStringSelect extends StringSelectMenu {
+    customId = "*";
+    options = [];
+    customIdParser = parseDiscordComponentCustomIdForCarbon;
+    ctx;
+    constructor(ctx) {
+        super();
+        this.ctx = ctx;
+    }
+    async run(interaction, data) {
+        await handleDiscordComponentEvent({
+            ctx: this.ctx,
+            interaction,
+            data,
+            componentLabel: "select menu",
+            label: "discord component select",
+            values: interaction.values ?? [],
+        });
+    }
+}
+class DiscordComponentUserSelect extends UserSelectMenu {
+    customId = "*";
+    customIdParser = parseDiscordComponentCustomIdForCarbon;
+    ctx;
+    constructor(ctx) {
+        super();
+        this.ctx = ctx;
+    }
+    async run(interaction, data) {
+        await handleDiscordComponentEvent({
+            ctx: this.ctx,
+            interaction,
+            data,
+            componentLabel: "user select",
+            label: "discord component user select",
+            values: interaction.values ?? [],
+        });
+    }
+}
+class DiscordComponentRoleSelect extends RoleSelectMenu {
+    customId = "*";
+    customIdParser = parseDiscordComponentCustomIdForCarbon;
+    ctx;
+    constructor(ctx) {
+        super();
+        this.ctx = ctx;
+    }
+    async run(interaction, data) {
+        await handleDiscordComponentEvent({
+            ctx: this.ctx,
+            interaction,
+            data,
+            componentLabel: "role select",
+            label: "discord component role select",
+            values: interaction.values ?? [],
+        });
+    }
+}
+class DiscordComponentMentionableSelect extends MentionableSelectMenu {
+    customId = "*";
+    customIdParser = parseDiscordComponentCustomIdForCarbon;
+    ctx;
+    constructor(ctx) {
+        super();
+        this.ctx = ctx;
+    }
+    async run(interaction, data) {
+        await handleDiscordComponentEvent({
+            ctx: this.ctx,
+            interaction,
+            data,
+            componentLabel: "mentionable select",
+            label: "discord component mentionable select",
+            values: interaction.values ?? [],
+        });
+    }
+}
+class DiscordComponentChannelSelect extends ChannelSelectMenu {
+    customId = "*";
+    customIdParser = parseDiscordComponentCustomIdForCarbon;
+    ctx;
+    constructor(ctx) {
+        super();
+        this.ctx = ctx;
+    }
+    async run(interaction, data) {
+        await handleDiscordComponentEvent({
+            ctx: this.ctx,
+            interaction,
+            data,
+            componentLabel: "channel select",
+            label: "discord component channel select",
+            values: interaction.values ?? [],
+        });
+    }
+}
+class DiscordComponentModal extends Modal {
+    title = "Pool Bot form";
+    customId = "*";
+    components = [];
+    customIdParser = parseDiscordModalCustomIdForCarbon;
+    ctx;
+    constructor(ctx) {
+        super();
+        this.ctx = ctx;
+    }
+    async run(interaction, data) {
+        const modalId = parseDiscordModalId(data, resolveInteractionCustomId(interaction));
+        if (!modalId) {
+            logError("discord component modal: missing modal id");
+            try {
+                await interaction.reply({
+                    content: "This form is no longer valid.",
+                    ephemeral: true,
+                });
+            }
+            catch {
+                // Interaction may have expired
             }
+            return;
         }
-        // Only check guild allowlists if this is a guild interaction
-        if (rawGuildId) {
-            const channelConfig = resolveDiscordChannelConfigWithFallback({
-                guildInfo,
-                channelId,
-                channelName,
-                channelSlug,
-                parentId,
-                parentName,
-                parentSlug,
-                scope: isThread ? "thread" : "channel",
-            });
-            const channelUsers = channelConfig?.users ?? guildInfo?.users;
-            if (Array.isArray(channelUsers) && channelUsers.length > 0) {
-                const userOk = resolveDiscordUserAllowed({
-                    allowList: channelUsers,
-                    userId,
-                    userName: user.username,
-                    userTag: user.discriminator ? `${user.username}#${user.discriminator}` : undefined,
+        const modalEntry = resolveDiscordModalEntry({ id: modalId, consume: false });
+        if (!modalEntry) {
+            try {
+                await interaction.reply({
+                    content: "This form has expired.",
+                    ephemeral: true,
                 });
-                if (!userOk) {
-                    logVerbose(`agent select: blocked user ${userId} (not in allowlist)`);
-                    try {
-                        await interaction.reply({
-                            content: "You are not authorized to use this select menu.",
-                            ephemeral: true,
-                        });
-                    }
-                    catch {
-                        // Interaction may have expired
-                    }
-                    return;
-                }
             }
+            catch {
+                // Interaction may have expired
+            }
+            return;
         }
-        // Extract selected values
-        const values = interaction.values ?? [];
-        const valuesText = values.length > 0 ? ` (selected: ${values.join(", ")})` : "";
-        // Resolve route with full context (guildId, proper peer kind)
-        const route = resolveAgentRoute({
-            cfg: this.ctx.cfg,
-            channel: "discord",
-            accountId: this.ctx.accountId,
-            guildId: rawGuildId,
-            peer: {
-                kind: isDirectMessage ? "dm" : "channel",
-                id: isDirectMessage ? userId : channelId,
-            },
+        const interactionCtx = await resolveInteractionContextWithDmAuth({
+            ctx: this.ctx,
+            interaction,
+            label: "discord component modal",
+            componentLabel: "form",
+            defer: false,
         });
-        const eventText = `[Discord select menu: ${componentId} interacted by ${username} (${userId})${valuesText}]`;
-        logDebug(`agent select: enqueuing event for channel ${channelId}: ${eventText}`);
-        enqueueSystemEvent(eventText, {
-            sessionKey: route.sessionKey,
-            contextKey: `discord:agent-select:${channelId}:${componentId}:${userId}`,
+        if (!interactionCtx) {
+            return;
+        }
+        const { channelId, user, replyOpts, rawGuildId, memberRoleIds } = interactionCtx;
+        const guildInfo = resolveDiscordGuildEntry({
+            guild: interaction.guild ?? undefined,
+            guildEntries: this.ctx.guildEntries,
+        });
+        const channelCtx = resolveDiscordChannelContext(interaction);
+        const memberAllowed = await ensureGuildComponentMemberAllowed({
+            interaction,
+            guildInfo,
+            channelId,
+            rawGuildId,
+            channelCtx,
+            memberRoleIds,
+            user,
+            replyOpts,
+            componentLabel: "form",
+            unauthorizedReply: "You are not authorized to use this form.",
+        });
+        if (!memberAllowed) {
+            return;
+        }
+        const consumed = resolveDiscordModalEntry({
+            id: modalId,
+            consume: !modalEntry.reusable,
         });
-        // Acknowledge the interaction
+        if (!consumed) {
+            try {
+                await interaction.reply({
+                    content: "This form has expired.",
+                    ephemeral: true,
+                });
+            }
+            catch {
+                // Interaction may have expired
+            }
+            return;
+        }
         try {
-            await interaction.reply({
-                content: "✓",
-                ephemeral: true,
-            });
+            await interaction.acknowledge();
         }
         catch (err) {
-            logError(`agent select: failed to acknowledge interaction: ${String(err)}`);
+            logError(`discord component modal: failed to acknowledge: ${String(err)}`);
         }
+        const eventText = formatModalSubmissionText(consumed, interaction);
+        await dispatchDiscordComponentEvent({
+            ctx: this.ctx,
+            interaction,
+            interactionCtx,
+            channelCtx,
+            guildInfo,
+            eventText,
+            replyToId: consumed.messageId,
+            routeOverrides: {
+                sessionKey: consumed.sessionKey,
+                agentId: consumed.agentId,
+                accountId: consumed.accountId,
+            },
+        });
     }
 }
 export function createAgentComponentButton(ctx) {
@@ -436,3 +1311,24 @@ export function createAgentComponentButton(ctx) {
 export function createAgentSelectMenu(ctx) {
     return new AgentSelectMenu(ctx);
 }
+export function createDiscordComponentButton(ctx) {
+    return new DiscordComponentButton(ctx);
+}
+export function createDiscordComponentStringSelect(ctx) {
+    return new DiscordComponentStringSelect(ctx);
+}
+export function createDiscordComponentUserSelect(ctx) {
+    return new DiscordComponentUserSelect(ctx);
+}
+export function createDiscordComponentRoleSelect(ctx) {
+    return new DiscordComponentRoleSelect(ctx);
+}
+export function createDiscordComponentMentionableSelect(ctx) {
+    return new DiscordComponentMentionableSelect(ctx);
+}
+export function createDiscordComponentChannelSelect(ctx) {
+    return new DiscordComponentChannelSelect(ctx);
+}
+export function createDiscordComponentModal(ctx) {
+    return new DiscordComponentModal(ctx);
+}