@helyx/bot 0.4.8 → 0.4.11

package/dist/index.d.ts

@@ -9,5 +9,5 @@ export interface BotHandle {
 export declare function startBot(processEnvironment?: NodeJS.ProcessEnv): Promise<BotHandle>;
 export declare function resolveBotWorkerEntryPoint(entryUrl?: string): string;
 export declare function readBotVersion(): string;
-export declare function gatewayIntentsForModules(modules: readonly ModuleDefinition[]): GatewayIntentBits[];
+export declare function gatewayIntentsForModules(modules: readonly ModuleDefinition[], messageContentEnabled?: boolean): GatewayIntentBits[];
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -18,7 +18,7 @@ import { loadConfiguredModulePackages, platformServiceOptions, } from "./modules
 import { resolveModulePackageSpecifiers } from "./module-configuration.js";
 import { createPermissionsModule } from "./permissions-module.js";
 import { createManagementModule } from "./management-module.js";
-import { DiscordMemberRoleService, DiscordResourceInspection, installModuleEvents, } from "./events.js";
+import { DiscordMessageDeliveryService, DiscordMemberEnforcementService, DiscordMemberRoleService, DiscordResourceInspection, installModuleEvents, } from "./events.js";
 import { DiscordModuleLoggingService } from "./module-logging.js";
 import { BotControlService, createBotControlServer, DiscordGuildResourceDirectory, } from "./control-server.js";
 import { startShardSupervisor } from "./shard-supervisor.js";
@@ -29,6 +29,7 @@ import { createSupportModule } from "./support-module.js";
 import { DiscordOwnedMessageDeletionService } from "./discord-owned-message-service.js";
 import { CoreResourceAuthorizationService } from "./resource-authorization.js";
 import { createLocalScheduledTaskRoute, createScheduledTaskRunner, schedulerOperationalHealth, } from "./scheduled-task-runner.js";
+import { createLocalNumericWriteBehind } from "./numeric-write-behind.js";
 export { loadConfiguredModulePackages } from "./modules.js";
 export { resolveModulePackageSpecifiers } from "./module-configuration.js";
 export * from "./control-server.js";
@@ -125,7 +126,7 @@ async function startUnshardedBot(processEnvironment) {
         }, "Module databases ready");
         const featureModules = modulePackages.map(({ definition }) => definition);
         const client = new Client({
-            intents: gatewayIntentsForModules(featureModules),
+            intents: gatewayIntentsForModules(featureModules, environment.HELYX_MESSAGE_CONTENT_ENABLED),
             partials: [Partials.Message, Partials.Channel, Partials.Reaction],
             allowedMentions: { parse: [] },
         });
@@ -234,15 +235,25 @@ async function startUnshardedBot(processEnvironment) {
             ...publicModules,
             ...(operationsModule ? [operationsModule] : []),
         ];
-        const platformServices = new Map(createPlatformServices(database, publicModules, platformServiceOptions(environment, publicModules)));
+        const platformServices = new Map();
+        const serviceAccess = new ServiceRegistry(platformServices);
+        for (const [name, service] of createPlatformServices(database, publicModules, {
+            ...platformServiceOptions(environment, publicModules),
+            activationServices: serviceAccess,
+        })) {
+            platformServices.set(name, service);
+        }
+        const numericWriteBehind = createLocalNumericWriteBehind(platformServices, publicModules);
+        platformServices.set(HELYX_SERVICE_NAMES.numericWriteBehind, numericWriteBehind);
         platformServices.set(HELYX_SERVICE_NAMES.resourceAuthorization, new CoreResourceAuthorizationService(platformServices.get(HELYX_SERVICE_NAMES.permissions)));
+        platformServices.set(HELYX_SERVICE_NAMES.discordMessages, new DiscordMessageDeliveryService(client));
         platformServices.set(HELYX_SERVICE_NAMES.discordOwnedMessages, new DiscordOwnedMessageDeletionService(client));
+        platformServices.set(HELYX_SERVICE_NAMES.memberEnforcement, new DiscordMemberEnforcementService(client));
         platformServices.set(HELYX_SERVICE_NAMES.memberRoles, new DiscordMemberRoleService(client));
         platformServices.set(HELYX_SERVICE_NAMES.discordResources, new DiscordResourceInspection(client));
         if (featureModules.some(({ manifest }) => manifest.id === "helyx.logging")) {
             platformServices.set(HELYX_SERVICE_NAMES.moduleLogging, new DiscordModuleLoggingService(client, database, publicModules, bootstrapLogger));
         }
-        const serviceAccess = new ServiceRegistry(platformServices);
         const runtime = createRuntime({
             modules,
             logger: bootstrapLogger,
@@ -305,14 +316,29 @@ async function startUnshardedBot(processEnvironment) {
                     process.exitCode = 1;
                     bootstrapLogger.error({ event: "control.stop_failed", error: safeError(error) }, "Private bot control shutdown failed");
                 });
-            try {
-                await moduleEvents.stop();
-                await runtime.stop();
-            }
-            catch (error) {
+            await moduleEvents.stop().catch((error) => {
+                process.exitCode = 1;
+                bootstrapLogger.error({ event: "module_events.stop_failed", error: safeError(error) }, "Module event shutdown failed");
+            });
+            await runtime.stop().catch((error) => {
                 process.exitCode = 1;
                 bootstrapLogger.error({ event: "runtime.stop_failed", error: safeError(error) }, "Runtime shutdown failed");
-            }
+            });
+            await numericWriteBehind
+                .stop()
+                .then(({ drained }) => {
+                if (drained)
+                    return;
+                process.exitCode = 1;
+                bootstrapLogger.error({ event: "numeric_write_behind.shutdown_not_drained" }, "Numeric write-behind exceeded its bounded shutdown drain");
+            })
+                .catch((error) => {
+                process.exitCode = 1;
+                bootstrapLogger.error({
+                    event: "numeric_write_behind.shutdown_failed",
+                    error: safeError(error),
+                }, "Numeric write-behind shutdown failed");
+            });
             await client.destroy();
             await closeDatabase();
         }
@@ -364,13 +390,26 @@ async function startUnshardedBot(processEnvironment) {
             await cloudConnector.stop().catch(() => undefined);
             if (controlServer)
                 await controlServer.close().catch(() => undefined);
-            try {
-                await moduleEvents.stop();
-                await runtime.stop();
-            }
-            catch (stopError) {
+            await moduleEvents.stop().catch((stopError) => {
+                bootstrapLogger.error({
+                    event: "module_events.cleanup_failed",
+                    error: safeError(stopError),
+                }, "Module event cleanup failed");
+            });
+            await runtime.stop().catch((stopError) => {
                 bootstrapLogger.error({ event: "runtime.cleanup_failed", error: safeError(stopError) }, "Runtime cleanup failed");
-            }
+            });
+            const numericCleanup = await numericWriteBehind
+                .stop()
+                .catch((stopError) => {
+                bootstrapLogger.error({
+                    event: "numeric_write_behind.cleanup_failed",
+                    error: safeError(stopError),
+                }, "Numeric write-behind cleanup failed");
+                return { drained: false };
+            });
+            if (!numericCleanup.drained)
+                bootstrapLogger.error({ event: "numeric_write_behind.cleanup_not_drained" }, "Numeric write-behind cleanup did not drain");
             await client.destroy();
             throw error;
         }
@@ -407,16 +446,27 @@ function deploymentReference(processEnvironment) {
         processEnvironment.GIT_COMMIT_SHA;
     return value?.trim().slice(0, 12) || undefined;
 }
-export function gatewayIntentsForModules(modules) {
+export function gatewayIntentsForModules(modules, messageContentEnabled = false) {
     const intents = [GatewayIntentBits.Guilds];
     if (modules.some((module) => module.events?.messageReactionAdd?.length ||
         module.events?.messageReactionRemove?.length)) {
         intents.push(GatewayIntentBits.GuildMessageReactions);
     }
-    if (modules.some((module) => module.events?.messageDelete?.length)) {
+    const hasPrivilegedMessageCreate = modules.some((module) => module.events?.privilegedMessageCreate?.length);
+    const requiresMessageContent = modules.some((module) => module.requiredDiscordCapabilities?.includes("message-content"));
+    if (((hasPrivilegedMessageCreate || requiresMessageContent) &&
+        messageContentEnabled) ||
+        modules.some((module) => module.events?.guildMessageCreate?.length ||
+            module.events?.messageDelete?.length)) {
         intents.push(GatewayIntentBits.GuildMessages);
     }
-    if (modules.some((module) => module.events?.guildMemberAdd?.length)) {
+    if ((hasPrivilegedMessageCreate || requiresMessageContent) &&
+        messageContentEnabled) {
+        intents.push(GatewayIntentBits.MessageContent);
+    }
+    if (modules.some((module) => module.requiredDiscordCapabilities?.includes("guild-members") ||
+        module.events?.guildMemberAdd?.length ||
+        module.events?.guildMemberRemove?.length)) {
         intents.push(GatewayIntentBits.GuildMembers);
     }
     if (modules.some((module) => module.events?.guildEmojiDelete?.length ||

package/dist/interactions.js

@@ -17,14 +17,18 @@ export function installInteractions(client, modules, registration, logger, servi
     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) => ({
+    const buttonItems = 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) => ({
+    })));
+    const buttons = uniqueMap(buttonItems.filter(({ contribution }) => contribution.customId !== undefined), ({ contribution }) => contribution.customId, "button custom ID");
+    const buttonPrefixes = componentPrefixes(buttonItems, "button");
+    const modalItems = modules.flatMap((module) => (module.interactions?.modals ?? []).map((contribution) => ({
         moduleId: module.manifest.id,
         contribution,
-    }))), ({ contribution }) => contribution.customId, "modal custom ID");
+    })));
+    const modals = uniqueMap(modalItems.filter(({ contribution }) => contribution.customId !== undefined), ({ contribution }) => contribution.customId, "modal custom ID");
+    const modalPrefixes = componentPrefixes(modalItems, "modal");
     const selects = uniqueMap(modules.flatMap((module) => (module.interactions?.selects ?? []).map((contribution) => ({
         moduleId: module.manifest.id,
         contribution,
@@ -67,7 +71,24 @@ export function installInteractions(client, modules, registration, logger, servi
     });
     async function handleInteraction(interaction) {
         try {
-            if (interaction.isChatInputCommand()) {
+            if (interaction.isAutocomplete()) {
+                const registered = commands.get(interaction.commandName);
+                const subcommandName = registered?.contribution.subcommands?.length
+                    ? interaction.options.getSubcommand(false)
+                    : null;
+                const subcommand = subcommandName
+                    ? registered?.contribution.subcommands?.find(({ name }) => name === subcommandName)
+                    : undefined;
+                if (!registered ||
+                    !subcommand?.autocomplete ||
+                    !(await authorizeAutocomplete(interaction, registered.moduleId, subcommand.permissionId ??
+                        `${registered.contribution.name}.${subcommand.name}`, services, registration.selfAuthorizingGuildModuleIds?.has(registered.moduleId) ?? false, subcommand.authorization === "resource-scoped"))) {
+                    await interaction.respond([]);
+                    return;
+                }
+                await subcommand.autocomplete(createAutocompleteContext(interaction, services));
+            }
+            else if (interaction.isChatInputCommand()) {
                 const registered = commands.get(interaction.commandName);
                 if (registered) {
                     const { contribution: command, moduleId } = registered;
@@ -107,7 +128,8 @@ export function installInteractions(client, modules, registration, logger, servi
                 }
             }
             else if (interaction.isButton()) {
-                const button = buttons.get(interaction.customId);
+                const button = buttons.get(interaction.customId) ??
+                    resolveComponentPrefix(buttonPrefixes, interaction.customId);
                 const context = button
                     ? createContext(interaction, services)
                     : undefined;
@@ -115,6 +137,11 @@ export function installInteractions(client, modules, registration, logger, servi
                     button?.contribution.acknowledgement === "deferred-ephemeral") {
                     await context.deferReply?.(true);
                 }
+                if (button &&
+                    interaction.isButton() &&
+                    button.contribution.acknowledgement === "deferred-update") {
+                    await interaction.deferUpdate();
+                }
                 if (button &&
                     context &&
                     (await authorizeComponent(interaction, button.moduleId, services))) {
@@ -122,7 +149,8 @@ export function installInteractions(client, modules, registration, logger, servi
                 }
             }
             else if (interaction.isModalSubmit()) {
-                const modal = modals.get(interaction.customId);
+                const modal = modals.get(interaction.customId) ??
+                    resolveComponentPrefix(modalPrefixes, interaction.customId);
                 if (modal &&
                     (await authorizeComponent(interaction, modal.moduleId, services))) {
                     await modal.contribution.execute(createModalContext(interaction, services));
@@ -188,6 +216,9 @@ export function toCommandDefinition(registered) {
     if (!!command.execute === !!command.subcommands?.length) {
         throw new Error(`Command ${command.name} must define either execute or subcommands`);
     }
+    if (command.options?.length && command.subcommands?.length) {
+        throw new Error(`Command ${command.name} cannot define both direct options and subcommands`);
+    }
     const contextTypes = {
         guild: InteractionContextType.Guild,
         bot_dm: InteractionContextType.BotDM,
@@ -202,6 +233,9 @@ export function toCommandDefinition(registered) {
         .setDescription(command.description)
         .setContexts(command.contexts.map((context) => contextTypes[context]))
         .setIntegrationTypes(command.integrationTypes.map((integrationType) => integrationTypes[integrationType]));
+    for (const option of command.options ?? []) {
+        addCommandOption(builder, option);
+    }
     for (const subcommand of command.subcommands ?? []) {
         builder.addSubcommand((subcommandBuilder) => {
             subcommandBuilder
@@ -217,6 +251,8 @@ export function toCommandDefinition(registered) {
 }
 function addCommandOption(builder, option) {
     if (option.type === "string") {
+        if (option.autocomplete && option.choices?.length)
+            throw new Error(`Command option ${option.name} cannot use choices and autocomplete together`);
         builder.addStringOption((optionBuilder) => {
             optionBuilder
                 .setName(option.name)
@@ -228,6 +264,8 @@ function addCommandOption(builder, option) {
                 optionBuilder.setMaxLength(option.maxLength);
             if (option.choices)
                 optionBuilder.addChoices(...option.choices);
+            if (option.autocomplete)
+                optionBuilder.setAutocomplete(option.autocomplete);
             return optionBuilder;
         });
         return;
@@ -239,6 +277,13 @@ function addCommandOption(builder, option) {
             .setRequired(option.required ?? false));
         return;
     }
+    if (option.type === "user") {
+        builder.addUserOption((optionBuilder) => optionBuilder
+            .setName(option.name)
+            .setDescription(option.description)
+            .setRequired(option.required ?? false));
+        return;
+    }
     if (option.type === "role") {
         builder.addRoleOption((optionBuilder) => optionBuilder
             .setName(option.name)
@@ -270,9 +315,43 @@ export function uniqueMap(items, keyOf, label) {
     }
     return result;
 }
+function componentPrefixes(items, label) {
+    const prefixes = [];
+    for (const item of items) {
+        const { customId, customIdPrefix } = item.contribution;
+        if ((customId === undefined) === (customIdPrefix === undefined)) {
+            throw new Error(`${label} contribution must declare exactly one custom ID or prefix`);
+        }
+        const route = customId ?? customIdPrefix;
+        if (route.length < 1 ||
+            route.length > 100 ||
+            !/^[A-Za-z0-9._:-]+$/u.test(route)) {
+            throw new Error(`${label} custom ID routing value is invalid`);
+        }
+        if (customIdPrefix !== undefined)
+            prefixes.push(item);
+    }
+    for (let index = 0; index < prefixes.length; index += 1) {
+        const prefix = prefixes[index].contribution.customIdPrefix;
+        if (prefixes.some((candidate, candidateIndex) => candidateIndex !== index &&
+            (candidate.contribution.customIdPrefix ?? "").startsWith(prefix))) {
+            throw new Error(`Ambiguous ${label} custom ID prefix: ${prefix}`);
+        }
+    }
+    return prefixes;
+}
+function resolveComponentPrefix(items, customId) {
+    if (customId.length < 1 ||
+        customId.length > 100 ||
+        !/^[A-Za-z0-9._:-]+$/u.test(customId)) {
+        return undefined;
+    }
+    return items.find(({ contribution }) => customId.startsWith(contribution.customIdPrefix ?? ""));
+}
 function createContext(interaction, services) {
     return {
         interactionId: interaction.id,
+        ...("customId" in interaction ? { customId: interaction.customId } : {}),
         userId: interaction.user.id,
         userDisplayName: interaction.user.globalName ?? interaction.user.username,
         userRoleIds: interaction.member instanceof GuildMember
@@ -301,6 +380,9 @@ function createContext(interaction, services) {
         ...(interaction.isMessageComponent()
             ? {
                 updateResponse: async (response) => interaction.update(toUpdateOptions(response)).then(() => undefined),
+                editSourceMessage: async (response) => interaction.webhook
+                    .editMessage(interaction.message.id, toUpdateOptions(response))
+                    .then(() => undefined),
             }
             : {}),
         showModal: async (modal) => interaction.showModal(toModal(modal)).then(() => undefined),
@@ -315,6 +397,16 @@ function createCommandContext(interaction, services) {
         ...createContext(interaction, services),
         getStringOption: (name) => interaction.options.getString(name),
         getBooleanOption: (name) => interaction.options.getBoolean(name),
+        getUserOption: (name) => {
+            const user = interaction.options.getUser(name);
+            return user
+                ? {
+                    id: user.id,
+                    displayName: user.globalName ?? user.username,
+                    isBot: user.bot,
+                }
+                : null;
+        },
         getRoleOption: (name) => {
             const role = interaction.options.getRole(name);
             return role ? { id: role.id, name: role.name } : null;
@@ -335,12 +427,48 @@ function createCommandContext(interaction, services) {
         },
     };
 }
+function createAutocompleteContext(interaction, services) {
+    const focused = interaction.options.getFocused(true);
+    const actor = permissionActor(interaction);
+    return {
+        interactionId: interaction.id,
+        userId: actor.userId,
+        userRoleIds: actor.roleIds,
+        userPermissions: actor.permissions,
+        isServerOwner: actor.isServerOwner,
+        isAdministrator: actor.isAdministrator,
+        ...(interaction.guildId ? { serverId: interaction.guildId } : {}),
+        focusedOptionName: focused.name,
+        focusedValue: String(focused.value),
+        services,
+        respond: async (choices) => {
+            if (choices.length > 25)
+                throw new Error("Autocomplete supports at most 25 choices");
+            const values = new Set();
+            const normalized = choices.map(({ name, value }) => {
+                const choiceName = name.trim().normalize("NFC");
+                const choiceValue = value.trim().normalize("NFC");
+                if (choiceName.length < 1 ||
+                    choiceName.length > 100 ||
+                    choiceValue.length < 1 ||
+                    choiceValue.length > 100)
+                    throw new Error("Autocomplete names and values must be between 1 and 100 characters");
+                if (values.has(choiceValue))
+                    throw new Error("Autocomplete choice values must be unique");
+                values.add(choiceValue);
+                return { name: choiceName, value: choiceValue };
+            });
+            await interaction.respond(normalized);
+        },
+    };
+}
 function createModalContext(interaction, services) {
     const updateResponse = interaction.isFromMessage()
         ? async (response) => interaction.update(toUpdateOptions(response)).then(() => undefined)
         : undefined;
     return {
         interactionId: interaction.id,
+        customId: interaction.customId,
         userId: interaction.user.id,
         userDisplayName: interaction.user.globalName ?? interaction.user.username,
         userRoleIds: interaction.member instanceof GuildMember
@@ -467,17 +595,7 @@ export async function authorizeCommand(interaction, moduleId, commandId, rateLim
         if (!resourceScopedCommand) {
             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,
-            };
+            const actor = permissionActor(interaction);
             if (!canUseCommand(actor, policy)) {
                 await interaction.reply({
                     content: "You do not have permission to use this command.",
@@ -506,6 +624,32 @@ export async function authorizeCommand(interaction, moduleId, commandId, rateLim
     }
     return true;
 }
+async function authorizeAutocomplete(interaction, moduleId, commandId, services, selfAuthorizingGuildCommand, resourceScopedCommand) {
+    if (!interaction.guildId || selfAuthorizingGuildCommand)
+        return true;
+    const installations = services.get(HELYX_SERVICE_NAMES.installations);
+    if (!(await installations.isModuleEnabled(interaction.guildId, moduleId)))
+        return false;
+    if (resourceScopedCommand)
+        return true;
+    const permissions = services.get(HELYX_SERVICE_NAMES.permissions);
+    const policy = await permissions.getEffectivePolicy(interaction.guildId, moduleId, commandId);
+    return canUseCommand(permissionActor(interaction), policy);
+}
+function permissionActor(interaction) {
+    return {
+        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,
+    };
+}
 export function normalizeDiscordPermission(permission) {
     return permission.replaceAll(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();
 }
@@ -629,19 +773,10 @@ function toSelectRows(response) {
     return rows;
 }
 export function toUpdateOptions(response) {
-    const options = toReplyOptions({
+    return 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)
@@ -760,6 +895,10 @@ export function toModal(definition) {
     return modal;
 }
 async function sendFailure(interaction) {
+    if (interaction.isAutocomplete()) {
+        await interaction.respond([]).catch(() => undefined);
+        return;
+    }
     if (!interaction.isRepliable())
         return;
     const message = "Something went wrong while handling that interaction.";

package/dist/management-module.js

@@ -18,6 +18,7 @@ const VALUE_MODAL_ID = "helyx.management.value.modal";
 const VALUE_FIELD_ID = "value";
 const SESSION_PURPOSE = "modules.manage";
 const PAGE_SIZE = 25;
+const MAX_DISCORD_SETTING_SELECTIONS = 25;
 const SESSION_LIFETIME_MS = 15 * 60 * 1_000;
 const VIOLET = 0x7c3aed;
 const SUCCESS = 0x16a34a;
@@ -177,7 +178,14 @@ export function createManagementModule(configurableModules, resources) {
                             return;
                         }
                         try {
-                            module.configuration?.validate(value);
+                            const validated = module.configuration?.validate(value);
+                            if (validated && module.configuration?.validateUpdate) {
+                                await module.configuration.validateUpdate({
+                                    guildId: context.serverId,
+                                    value: validated,
+                                    services: context.services,
+                                });
+                            }
                         }
                         catch (error) {
                             await context.reply(validationResponse(error instanceof Error
@@ -563,8 +571,12 @@ function settingValueResponse(setting) {
                 {
                     type: "discord-channel",
                     customId: VALUE_SELECT_ID,
-                    placeholder: "Choose a channel",
+                    placeholder: setting.multiple
+                        ? "Choose channels"
+                        : "Choose a channel",
                     channelTypes: setting.channelTypes,
+                    minValues: 1,
+                    maxValues: setting.multiple ? MAX_DISCORD_SETTING_SELECTIONS : 1,
                 },
             ],
         };
@@ -631,6 +643,8 @@ function initialDraft(module, existing) {
     return result;
 }
 function emptyValue(setting) {
+    if (setting.type === "discord-channel" && setting.multiple)
+        return [];
     if (setting.type === "discord-role" && setting.multiple)
         return [];
     if (setting.type === "string" ||
@@ -655,10 +669,13 @@ function selectedValue(setting, values) {
         return values[0];
     }
     if (setting.type === "discord-channel") {
-        if (values.length !== 1 || !isSnowflake(values[0])) {
-            throw new Error("Selected channel is invalid");
+        if (values.length < 1 ||
+            values.length > (setting.multiple ? MAX_DISCORD_SETTING_SELECTIONS : 1) ||
+            new Set(values).size !== values.length ||
+            values.some((value) => !isSnowflake(value))) {
+            throw new Error("Selected channel value is invalid");
         }
-        return values[0];
+        return setting.multiple ? [...values] : values[0];
     }
     if (setting.type === "discord-role") {
         if (values.length < 1 ||
@@ -723,9 +740,21 @@ async function validateDiscordSettings(directory, guildId, module, values) {
         if (configured === "" || configured === undefined)
             continue;
         if (setting.type === "discord-channel") {
-            const channel = typeof configured === "string" ? channels.get(configured) : undefined;
-            if (!channel || !setting.channelTypes.includes(channel.type)) {
-                return `${setting.label} must be an available supported Discord channel.`;
+            if (setting.multiple !== Array.isArray(configured)) {
+                return `${setting.label} has an invalid Discord channel selection.`;
+            }
+            const configuredChannels = Array.isArray(configured)
+                ? configured
+                : [configured];
+            if (configuredChannels.length > MAX_DISCORD_SETTING_SELECTIONS ||
+                new Set(configuredChannels).size !== configuredChannels.length ||
+                configuredChannels.some((channelId) => {
+                    if (typeof channelId !== "string")
+                        return true;
+                    const channel = channels.get(channelId);
+                    return !channel || !setting.channelTypes.includes(channel.type);
+                })) {
+                return `${setting.label} must contain available supported Discord channels.`;
             }
         }
         if (setting.type === "discord-role") {
@@ -776,8 +805,11 @@ function settingStatus(setting, value) {
     }
     if (setting.type === "boolean")
         return value === true ? "Enabled" : "Disabled";
-    if (setting.type === "discord-channel")
-        return "Channel selected";
+    if (setting.type === "discord-channel") {
+        return Array.isArray(value)
+            ? `${String(value.length)} channels selected`
+            : "Channel selected";
+    }
     if (setting.type === "discord-role") {
         return Array.isArray(value)
             ? `${String(value.length)} roles selected`

package/dist/message-classification.d.ts

@@ -0,0 +1,5 @@
+import { type Message } from "discord.js";
+import type { GuildMessageClassification } from "@helyx/sdk";
+export declare function classifyGuildMessage(message: Pick<Message, "attachments" | "content" | "embeds" | "flags" | "stickers">): GuildMessageClassification;
+export declare const unavailableGuildMessageClassification: GuildMessageClassification;
+//# sourceMappingURL=message-classification.d.ts.map