@helyx/bot 0.1.0

package/dist/interactions.js

@@ -0,0 +1,666 @@
+import { HELYX_SERVICE_NAMES } from "@helyx/sdk";
+import { canUseCommand } from "@helyx/core";
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, ChannelSelectMenuBuilder, EmbedBuilder, Events, GuildMember, ApplicationIntegrationType, ChannelType, InteractionContextType, LabelBuilder, MessageFlags, MentionableSelectMenuBuilder, ModalBuilder, RoleSelectMenuBuilder, StringSelectMenuBuilder, SlashCommandBuilder, TextInputBuilder, TextInputStyle, UserSelectMenuBuilder, TextDisplayBuilder, PermissionFlagsBits, escapeMarkdown, } from "discord.js";
+const buttonStyles = {
+    primary: ButtonStyle.Primary,
+    secondary: ButtonStyle.Secondary,
+    success: ButtonStyle.Success,
+    danger: ButtonStyle.Danger,
+};
+export function installInteractions(client, modules, registration, logger, services) {
+    const commands = uniqueMap(modules.flatMap((module) => (module.interactions?.commands ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    }))), ({ contribution }) => contribution.name, "command name");
+    const globalCommands = [...commands.values()].filter(({ contribution }) => contribution.registration === "global");
+    const guildCommands = [...commands.values()].filter(({ contribution }) => contribution.registration === "guild");
+    if (guildCommands.length > 0 && !registration.internalGuildId) {
+        throw new Error("DISCORD_INTERNAL_GUILD_ID is required when guild commands are loaded");
+    }
+    const buttons = uniqueMap(modules.flatMap((module) => (module.interactions?.buttons ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    }))), ({ contribution }) => contribution.customId, "button custom ID");
+    const modals = uniqueMap(modules.flatMap((module) => (module.interactions?.modals ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    }))), ({ contribution }) => contribution.customId, "modal custom ID");
+    const selects = uniqueMap(modules.flatMap((module) => (module.interactions?.selects ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    }))), ({ contribution }) => contribution.customId, "select custom ID");
+    let resolveRegistration;
+    let rejectRegistration;
+    const registrationReady = new Promise((resolve, reject) => {
+        resolveRegistration = resolve;
+        rejectRegistration = reject;
+    });
+    client.once(Events.ClientReady, (readyClient) => {
+        void registerCommands().then(resolveRegistration, (error) => {
+            logger.error({ event: "commands.registration_failed", error: safeError(error) }, "Application command registration failed");
+            rejectRegistration(error);
+        });
+        async function registerCommands() {
+            await registration.prepare?.(readyClient);
+            const globalDefinitions = globalCommands.map(toCommandDefinition);
+            await readyClient.application.commands.set(globalDefinitions);
+            if (registration.internalGuildId) {
+                const guildDefinitions = guildCommands.map(toCommandDefinition);
+                await readyClient.application.commands.set(guildDefinitions, registration.internalGuildId);
+            }
+            logger.info({
+                event: "commands.registered",
+                globalCount: globalCommands.length,
+                guildCount: guildCommands.length,
+                ...(registration.internalGuildId
+                    ? { internalGuildId: registration.internalGuildId }
+                    : {}),
+            }, "Application commands registered");
+        }
+    });
+    client.on(Events.InteractionCreate, (interaction) => {
+        void handleInteraction(interaction);
+    });
+    async function handleInteraction(interaction) {
+        try {
+            if (interaction.isChatInputCommand()) {
+                const registered = commands.get(interaction.commandName);
+                if (registered) {
+                    const { contribution: command, moduleId } = registered;
+                    const subcommandName = command.subcommands?.length
+                        ? interaction.options.getSubcommand(false)
+                        : null;
+                    const subcommand = subcommandName
+                        ? command.subcommands?.find(({ name }) => name === subcommandName)
+                        : undefined;
+                    const execute = resolveCommandExecutor(command, subcommandName);
+                    if (!execute) {
+                        logger.warn({
+                            event: "interaction.stale_command",
+                            commandName: command.name,
+                            ...(subcommandName ? { subcommandName } : {}),
+                        }, "Interaction used an outdated command definition");
+                        const choices = (command.subcommands ?? [])
+                            .map(({ name }) => `\`/${command.name} ${name}\``)
+                            .join(" or ");
+                        await interaction.reply({
+                            content: choices
+                                ? `This command was recently updated. Refresh Discord, then use ${choices}.`
+                                : "This command was recently updated. Refresh Discord and try again.",
+                            flags: MessageFlags.Ephemeral,
+                        });
+                        return;
+                    }
+                    const commandId = subcommandName
+                        ? `${command.name}.${subcommandName}`
+                        : command.name;
+                    if (await authorizeCommand(interaction, moduleId, commandId, subcommand?.rateLimit ?? command.rateLimit, services)) {
+                        const context = createCommandContext(interaction, services);
+                        await execute(context);
+                    }
+                }
+            }
+            else if (interaction.isButton()) {
+                const button = buttons.get(interaction.customId);
+                if (button &&
+                    (await authorizeComponent(interaction, button.moduleId, services))) {
+                    await button.contribution.execute(createContext(interaction, services));
+                }
+            }
+            else if (interaction.isModalSubmit()) {
+                const modal = modals.get(interaction.customId);
+                if (modal &&
+                    (await authorizeComponent(interaction, modal.moduleId, services))) {
+                    await modal.contribution.execute(createModalContext(interaction, services));
+                }
+            }
+            else if (interaction.isStringSelectMenu() ||
+                interaction.isChannelSelectMenu() ||
+                interaction.isRoleSelectMenu()) {
+                const select = selects.get(interaction.customId);
+                if (select &&
+                    (await authorizeComponent(interaction, select.moduleId, services))) {
+                    await select.contribution.execute(createSelectContext(interaction, services));
+                }
+            }
+        }
+        catch (error) {
+            logger.error({ event: "interaction.failed", error: safeError(error) }, "Module interaction failed");
+            await sendFailure(interaction);
+        }
+    }
+    return registrationReady;
+}
+export function resolveCommandExecutor(command, subcommandName) {
+    if (command.subcommands?.length) {
+        if (!subcommandName)
+            return undefined;
+        const subcommand = command.subcommands.find(({ name }) => name === subcommandName);
+        return subcommand ? (context) => subcommand.execute(context) : undefined;
+    }
+    return command.execute
+        ? (context) => command.execute?.(context) ?? Promise.resolve()
+        : undefined;
+}
+export function toCommandDefinition(registered) {
+    const command = registered.contribution;
+    if (!!command.execute === !!command.subcommands?.length) {
+        throw new Error(`Command ${command.name} must define either execute or subcommands`);
+    }
+    const contextTypes = {
+        guild: InteractionContextType.Guild,
+        bot_dm: InteractionContextType.BotDM,
+        private_channel: InteractionContextType.PrivateChannel,
+    };
+    const integrationTypes = {
+        guild_install: ApplicationIntegrationType.GuildInstall,
+        user_install: ApplicationIntegrationType.UserInstall,
+    };
+    const builder = new SlashCommandBuilder()
+        .setName(command.name)
+        .setDescription(command.description)
+        .setContexts(command.contexts.map((context) => contextTypes[context]))
+        .setIntegrationTypes(command.integrationTypes.map((integrationType) => integrationTypes[integrationType]));
+    for (const subcommand of command.subcommands ?? []) {
+        builder.addSubcommand((subcommandBuilder) => {
+            subcommandBuilder
+                .setName(subcommand.name)
+                .setDescription(subcommand.description);
+            for (const option of subcommand.options ?? []) {
+                addCommandOption(subcommandBuilder, option);
+            }
+            return subcommandBuilder;
+        });
+    }
+    return builder.toJSON();
+}
+function addCommandOption(builder, option) {
+    if (option.type === "string") {
+        builder.addStringOption((optionBuilder) => {
+            optionBuilder
+                .setName(option.name)
+                .setDescription(option.description)
+                .setRequired(option.required ?? false);
+            if (option.minLength !== undefined)
+                optionBuilder.setMinLength(option.minLength);
+            if (option.maxLength !== undefined)
+                optionBuilder.setMaxLength(option.maxLength);
+            if (option.choices)
+                optionBuilder.addChoices(...option.choices);
+            return optionBuilder;
+        });
+        return;
+    }
+    if (option.type === "boolean") {
+        builder.addBooleanOption((optionBuilder) => optionBuilder
+            .setName(option.name)
+            .setDescription(option.description)
+            .setRequired(option.required ?? false));
+        return;
+    }
+    if (option.type === "role") {
+        builder.addRoleOption((optionBuilder) => optionBuilder
+            .setName(option.name)
+            .setDescription(option.description)
+            .setRequired(option.required ?? false));
+        return;
+    }
+    const channelTypes = {
+        guild_text: ChannelType.GuildText,
+        guild_announcement: ChannelType.GuildAnnouncement,
+    };
+    builder.addChannelOption((optionBuilder) => {
+        optionBuilder
+            .setName(option.name)
+            .setDescription(option.description)
+            .setRequired(option.required ?? false);
+        if (option.channelTypes)
+            optionBuilder.addChannelTypes(...option.channelTypes.map((type) => channelTypes[type]));
+        return optionBuilder;
+    });
+}
+export function uniqueMap(items, keyOf, label) {
+    const result = new Map();
+    for (const item of items) {
+        const key = keyOf(item);
+        if (result.has(key))
+            throw new Error(`Duplicate ${label}: ${key}`);
+        result.set(key, item);
+    }
+    return result;
+}
+function createContext(interaction, services) {
+    return {
+        interactionId: interaction.id,
+        userId: interaction.user.id,
+        userDisplayName: interaction.user.globalName ?? interaction.user.username,
+        userRoleIds: interaction.member instanceof GuildMember
+            ? [...interaction.member.roles.cache.keys()]
+            : (interaction.member?.roles ?? []),
+        ...(interaction.guildId ? { serverId: interaction.guildId } : {}),
+        ...(interaction.channelId ? { channelId: interaction.channelId } : {}),
+        ...(interaction.isButton() ? { messageId: interaction.message.id } : {}),
+        services,
+        reply: async (response) => interaction.reply(toReplyOptions(response)).then(() => undefined),
+        ...(interaction.isMessageComponent()
+            ? {
+                updateResponse: async (response) => interaction.update(toUpdateOptions(response)).then(() => undefined),
+            }
+            : {}),
+        showModal: async (modal) => interaction.showModal(toModal(modal)).then(() => undefined),
+        sendToChannel: (channelId, response) => sendToChannel(interaction.client, channelId, response),
+        deleteChannelMessage: (channelId, messageId) => deleteChannelMessage(interaction.client, channelId, messageId),
+        addChannelMessageReaction: (channelId, messageId, emojiIdentifier) => addChannelMessageReaction(interaction.client, channelId, messageId, emojiIdentifier),
+    };
+}
+function createCommandContext(interaction, services) {
+    return {
+        ...createContext(interaction, services),
+        getStringOption: (name) => interaction.options.getString(name),
+        getBooleanOption: (name) => interaction.options.getBoolean(name),
+        getRoleOption: (name) => {
+            const role = interaction.options.getRole(name);
+            return role ? { id: role.id, name: role.name } : null;
+        },
+        getChannelOption: (name) => {
+            const channel = interaction.options.getChannel(name);
+            if (!channel)
+                return null;
+            return {
+                id: channel.id,
+                name: channel.name ?? channel.id,
+                type: channel.type === ChannelType.GuildText
+                    ? "guild_text"
+                    : channel.type === ChannelType.GuildAnnouncement
+                        ? "guild_announcement"
+                        : "other",
+            };
+        },
+    };
+}
+function createModalContext(interaction, services) {
+    const updateResponse = interaction.isFromMessage()
+        ? async (response) => interaction.update(toUpdateOptions(response)).then(() => undefined)
+        : undefined;
+    return {
+        interactionId: interaction.id,
+        userId: interaction.user.id,
+        userDisplayName: interaction.user.globalName ?? interaction.user.username,
+        userRoleIds: interaction.member instanceof GuildMember
+            ? [...interaction.member.roles.cache.keys()]
+            : (interaction.member?.roles ?? []),
+        ...(interaction.guildId ? { serverId: interaction.guildId } : {}),
+        ...(interaction.channelId ? { channelId: interaction.channelId } : {}),
+        services,
+        reply: async (response) => interaction.reply(toReplyOptions(response)).then(() => undefined),
+        ...(updateResponse ? { updateResponse } : {}),
+        getField: (customId) => interaction.fields.getTextInputValue(customId),
+        getStringSelectValues: (customId) => interaction.fields.getStringSelectValues(customId),
+        getSelectedUserIds: (customId) => [
+            ...(interaction.fields.getSelectedUsers(customId, false)?.keys() ?? []),
+        ],
+        getSelectedRoleIds: (customId) => [
+            ...(interaction.fields.getSelectedRoles(customId, false)?.keys() ?? []),
+        ],
+        getSelectedMentionables: (customId) => {
+            const selected = interaction.fields.getSelectedMentionables(customId, false);
+            return {
+                userIds: [...(selected?.users.keys() ?? [])],
+                roleIds: [...(selected?.roles.keys() ?? [])],
+            };
+        },
+        getSelectedChannelIds: (customId) => [
+            ...(interaction.fields.getSelectedChannels(customId, false)?.keys() ??
+                []),
+        ],
+        sendToChannel: (channelId, response) => sendToChannel(interaction.client, channelId, response),
+        deleteChannelMessage: (channelId, messageId) => deleteChannelMessage(interaction.client, channelId, messageId),
+        addChannelMessageReaction: (channelId, messageId, emojiIdentifier) => addChannelMessageReaction(interaction.client, channelId, messageId, emojiIdentifier),
+    };
+}
+function createSelectContext(interaction, services) {
+    return {
+        ...createContext(interaction, services),
+        selectedValues: interaction.values,
+    };
+}
+export async function sendToChannel(client, channelId, response) {
+    const channel = await client.channels.fetch(channelId);
+    if (!channel?.isSendable())
+        throw new Error("Configured channel is not sendable");
+    const options = toReplyOptions({ ...response, ephemeral: false });
+    const message = await channel.send(options);
+    return { messageId: message.id };
+}
+export async function deleteChannelMessage(client, channelId, messageId) {
+    const channel = await client.channels.fetch(channelId);
+    if (!channel?.isTextBased()) {
+        throw new Error("Configured channel cannot contain messages");
+    }
+    await channel.messages.delete(messageId);
+}
+async function addChannelMessageReaction(client, channelId, messageId, emojiIdentifier) {
+    const channel = await client.channels.fetch(channelId);
+    if (!channel?.isTextBased()) {
+        throw new Error("Configured channel cannot contain messages");
+    }
+    const message = await channel.messages.fetch(messageId);
+    await message.react(emojiIdentifier);
+}
+async function authorizeComponent(interaction, moduleId, services) {
+    if (!interaction.guildId)
+        return true;
+    const installations = services.get(HELYX_SERVICE_NAMES.installations);
+    if (await installations.isModuleEnabled(interaction.guildId, moduleId)) {
+        return true;
+    }
+    await interaction.reply({
+        content: "This module is disabled in this server. Ask a server administrator to enable it with `/helyx` or in the Helyx dashboard.",
+        flags: MessageFlags.Ephemeral,
+    });
+    return false;
+}
+async function authorizeCommand(interaction, moduleId, commandId, rateLimit, services) {
+    if (!interaction.guildId)
+        return true;
+    if (!(await authorizeComponent(interaction, moduleId, services)))
+        return false;
+    const permissions = services.get(HELYX_SERVICE_NAMES.permissions);
+    const policy = await permissions.getEffectivePolicy(interaction.guildId, moduleId, commandId);
+    const actor = {
+        userId: interaction.user.id,
+        roleIds: interaction.member instanceof GuildMember
+            ? [...interaction.member.roles.cache.keys()]
+            : (interaction.member?.roles ?? []),
+        permissions: interaction.memberPermissions
+            ?.toArray()
+            .map(normalizeDiscordPermission) ?? [],
+        isServerOwner: interaction.guild?.ownerId === interaction.user.id,
+        isAdministrator: interaction.memberPermissions?.has(PermissionFlagsBits.Administrator) ??
+            false,
+    };
+    if (!canUseCommand(actor, policy)) {
+        await interaction.reply({
+            content: "You do not have permission to use this command.",
+            flags: MessageFlags.Ephemeral,
+        });
+        return false;
+    }
+    if (rateLimit) {
+        const limits = services.get(HELYX_SERVICE_NAMES.rateLimits);
+        const result = await limits.consume({
+            scope: rateLimit.scope,
+            subjectId: rateLimit.scope === "guild" ? interaction.guildId : interaction.user.id,
+            action: `${moduleId}:${commandId}`,
+            limit: rateLimit.limit,
+            windowSeconds: rateLimit.windowSeconds,
+        });
+        if (!result.allowed) {
+            await interaction.reply({
+                content: `This command is temporarily rate limited. Try again <t:${Math.ceil(result.resetsAt.getTime() / 1_000)}:R>.`,
+                flags: MessageFlags.Ephemeral,
+            });
+            return false;
+        }
+    }
+    return true;
+}
+export function normalizeDiscordPermission(permission) {
+    return permission.replaceAll(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();
+}
+export function toReplyOptions(response) {
+    const allowedMentions = toAllowedUserMentions(response.allowedUserMentionIds);
+    const selectRows = toSelectRows(response);
+    if (response.componentsV2) {
+        const flags = response.ephemeral
+            ? MessageFlags.IsComponentsV2 | MessageFlags.Ephemeral
+            : MessageFlags.IsComponentsV2;
+        return {
+            flags,
+            ...(allowedMentions ? { allowedMentions } : {}),
+            components: [
+                {
+                    type: 17,
+                    ...(response.componentsV2.accentColor === undefined
+                        ? {}
+                        : { accent_color: response.componentsV2.accentColor }),
+                    components: response.componentsV2.text.map((text) => ({
+                        type: 10,
+                        content: text.markdown === false
+                            ? escapeMarkdown(text.content)
+                            : text.content,
+                    })),
+                },
+                ...selectRows,
+                ...(response.buttons?.length
+                    ? [
+                        {
+                            type: 1,
+                            components: response.buttons.map((button) => ({
+                                type: 2,
+                                custom_id: button.customId,
+                                label: button.label,
+                                style: buttonStyles[button.style],
+                                ...(button.emojiIdentifier
+                                    ? { emoji: toButtonEmoji(button.emojiIdentifier) }
+                                    : {}),
+                            })),
+                        },
+                    ]
+                    : []),
+            ],
+        };
+    }
+    const embed = response.embed
+        ? new EmbedBuilder()
+            .setTitle(response.embed.title)
+            .setDescription(response.embed.description)
+            .setColor(response.embed.color ?? 0x7c3aed)
+        : undefined;
+    if (embed && response.embed?.footer)
+        embed.setFooter({ text: response.embed.footer });
+    const components = response.buttons?.length
+        ? [
+            new ActionRowBuilder().addComponents(response.buttons.map((button) => {
+                const builder = new ButtonBuilder()
+                    .setCustomId(button.customId)
+                    .setLabel(button.label)
+                    .setStyle(buttonStyles[button.style]);
+                if (button.emojiIdentifier) {
+                    builder.setEmoji(toButtonEmoji(button.emojiIdentifier));
+                }
+                return builder;
+            })),
+        ]
+        : [];
+    components.push(...selectRows);
+    return {
+        ...(response.ephemeral ? { flags: MessageFlags.Ephemeral } : {}),
+        ...(allowedMentions ? { allowedMentions } : {}),
+        ...(embed ? { embeds: [embed] } : {}),
+        components,
+    };
+}
+function toSelectRows(response) {
+    const rows = [];
+    for (const select of response.selects ?? []) {
+        if (select.type === "discord-channel") {
+            rows.push(new ActionRowBuilder().addComponents(new ChannelSelectMenuBuilder()
+                .setCustomId(select.customId)
+                .setPlaceholder(select.placeholder)
+                .setMinValues(select.minValues ?? 1)
+                .setMaxValues(select.maxValues ?? 1)
+                .setChannelTypes(...select.channelTypes.map((type) => type === "guild_announcement"
+                ? ChannelType.GuildAnnouncement
+                : ChannelType.GuildText))));
+            continue;
+        }
+        if (select.type === "discord-role") {
+            rows.push(new ActionRowBuilder().addComponents(new RoleSelectMenuBuilder()
+                .setCustomId(select.customId)
+                .setPlaceholder(select.placeholder)
+                .setMinValues(select.minValues ?? 1)
+                .setMaxValues(select.maxValues ?? 1)));
+            continue;
+        }
+        rows.push(new ActionRowBuilder().addComponents(new StringSelectMenuBuilder()
+            .setCustomId(select.customId)
+            .setPlaceholder(select.placeholder)
+            .setMinValues(select.minValues ?? 1)
+            .setMaxValues(select.maxValues ?? 1)
+            .addOptions(select.options.map((option) => ({
+            label: option.label,
+            value: option.value,
+            ...(option.description
+                ? { description: option.description }
+                : {}),
+        })))));
+    }
+    return rows;
+}
+export function toUpdateOptions(response) {
+    const options = toReplyOptions({
+        ...response,
+        ephemeral: false,
+    });
+    return response.componentsV2
+        ? {
+            ...options,
+            // Discord requires legacy fields to be cleared when an existing
+            // message is first converted to Components V2.
+            content: null,
+            embeds: [],
+        }
+        : options;
+}
+function toAllowedUserMentions(userIds) {
+    if (userIds === undefined)
+        return undefined;
+    if (userIds.length > 100 ||
+        new Set(userIds).size !== userIds.length ||
+        userIds.some((userId) => !/^\d{17,20}$/u.test(userId))) {
+        throw new Error("Allowed user mentions must be unique Discord snowflakes");
+    }
+    return { parse: [], users: [...userIds] };
+}
+function toButtonEmoji(emojiIdentifier) {
+    const custom = /^([A-Za-z0-9_]{2,32}):(\d{17,20})$/u.exec(emojiIdentifier);
+    return custom
+        ? { name: custom[1], id: custom[2] }
+        : { name: emojiIdentifier };
+}
+export function toModal(definition) {
+    const modal = new ModalBuilder()
+        .setCustomId(definition.customId)
+        .setTitle(definition.title);
+    for (const text of definition.text ?? []) {
+        modal.addTextDisplayComponents(new TextDisplayBuilder().setContent(text.markdown === false ? escapeMarkdown(text.content) : text.content));
+    }
+    for (const field of definition.fields) {
+        const label = new LabelBuilder().setLabel(field.label);
+        if (field.description !== undefined)
+            label.setDescription(field.description);
+        if (field.type === undefined || field.type === "text") {
+            const input = new TextInputBuilder()
+                .setCustomId(field.customId)
+                .setStyle(field.style === "paragraph"
+                ? TextInputStyle.Paragraph
+                : TextInputStyle.Short)
+                .setRequired(field.required ?? false);
+            if (field.minLength !== undefined)
+                input.setMinLength(field.minLength);
+            if (field.maxLength !== undefined)
+                input.setMaxLength(field.maxLength);
+            if (field.placeholder !== undefined)
+                input.setPlaceholder(field.placeholder);
+            if (field.value !== undefined)
+                input.setValue(field.value);
+            label.setTextInputComponent(input);
+        }
+        else if (field.type === "string-select") {
+            const input = new StringSelectMenuBuilder()
+                .setCustomId(field.customId)
+                .setRequired(field.required ?? false)
+                .setMinValues(field.minValues ?? (field.required ? 1 : 0))
+                .setMaxValues(field.maxValues ?? 1)
+                .addOptions(field.options.map((option) => ({ ...option })));
+            if (field.placeholder !== undefined)
+                input.setPlaceholder(field.placeholder);
+            label.setStringSelectMenuComponent(input);
+        }
+        else if (field.type === "discord-user") {
+            const input = new UserSelectMenuBuilder()
+                .setCustomId(field.customId)
+                .setRequired(field.required ?? false)
+                .setMinValues(field.minValues ?? (field.required ? 1 : 0))
+                .setMaxValues(field.maxValues ?? 1);
+            if (field.placeholder !== undefined)
+                input.setPlaceholder(field.placeholder);
+            if (field.defaultValues?.length)
+                input.setDefaultUsers(...field.defaultValues);
+            label.setUserSelectMenuComponent(input);
+        }
+        else if (field.type === "discord-role") {
+            const input = new RoleSelectMenuBuilder()
+                .setCustomId(field.customId)
+                .setRequired(field.required ?? false)
+                .setMinValues(field.minValues ?? (field.required ? 1 : 0))
+                .setMaxValues(field.maxValues ?? 1);
+            if (field.placeholder !== undefined)
+                input.setPlaceholder(field.placeholder);
+            if (field.defaultValues?.length)
+                input.setDefaultRoles(...field.defaultValues);
+            label.setRoleSelectMenuComponent(input);
+        }
+        else if (field.type === "discord-mentionable") {
+            const input = new MentionableSelectMenuBuilder()
+                .setCustomId(field.customId)
+                .setRequired(field.required ?? false)
+                .setMinValues(field.minValues ?? (field.required ? 1 : 0))
+                .setMaxValues(field.maxValues ?? 1);
+            if (field.placeholder !== undefined)
+                input.setPlaceholder(field.placeholder);
+            if (field.defaultValues?.length) {
+                input.addDefaultUsers(...field.defaultValues
+                    .filter((value) => value.type === "user")
+                    .map((value) => value.id));
+                input.addDefaultRoles(...field.defaultValues
+                    .filter((value) => value.type === "role")
+                    .map((value) => value.id));
+            }
+            label.setMentionableSelectMenuComponent(input);
+        }
+        else if (field.type === "discord-channel") {
+            const input = new ChannelSelectMenuBuilder()
+                .setCustomId(field.customId)
+                .setRequired(field.required ?? false)
+                .setMinValues(field.minValues ?? (field.required ? 1 : 0))
+                .setMaxValues(field.maxValues ?? 1)
+                .setChannelTypes(...field.channelTypes.map((type) => type === "guild_announcement"
+                ? ChannelType.GuildAnnouncement
+                : ChannelType.GuildText));
+            if (field.placeholder !== undefined)
+                input.setPlaceholder(field.placeholder);
+            if (field.defaultValues?.length)
+                input.setDefaultChannels(...field.defaultValues);
+            label.setChannelSelectMenuComponent(input);
+        }
+        modal.addLabelComponents(label);
+    }
+    return modal;
+}
+async function sendFailure(interaction) {
+    if (!interaction.isRepliable() || interaction.replied || interaction.deferred)
+        return;
+    await interaction
+        .reply({
+        content: "Something went wrong while handling that interaction.",
+        flags: MessageFlags.Ephemeral,
+    })
+        .catch(() => undefined);
+}
+function safeError(error) {
+    const value = error instanceof Error ? error : new Error(String(error));
+    return { name: value.name, message: value.message };
+}
+//# sourceMappingURL=interactions.js.map

package/dist/management-module.d.ts

@@ -0,0 +1,15 @@
+import { type ModuleDefinition } from "@helyx/sdk";
+export interface ManagementGuildResources {
+    channels: readonly {
+        id: string;
+        type: "guild_text" | "guild_announcement";
+    }[];
+    roles: readonly {
+        id: string;
+    }[];
+}
+export interface ManagementResourceDirectory {
+    getGuildResources(guildId: string): Promise<ManagementGuildResources>;
+}
+export declare function createManagementModule(configurableModules: readonly ModuleDefinition[], resources: ManagementResourceDirectory): ModuleDefinition;
+//# sourceMappingURL=management-module.d.ts.map