@helyx/bot 0.4.9 → 0.4.13

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,
@@ -124,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;
@@ -132,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))) {
@@ -139,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));
@@ -205,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,
@@ -219,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
@@ -260,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,6 +294,7 @@ function addCommandOption(builder, option) {
     const channelTypes = {
         guild_text: ChannelType.GuildText,
         guild_announcement: ChannelType.GuildAnnouncement,
+        guild_category: ChannelType.GuildCategory,
     };
     builder.addChannelOption((optionBuilder) => {
         optionBuilder
@@ -291,9 +316,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
@@ -318,10 +377,14 @@ function createContext(interaction, services) {
                 ...(ephemeral ? { flags: MessageFlags.Ephemeral } : {}),
             });
         },
+        deleteReplyAfter: (milliseconds) => scheduleReplyDeletion(interaction, milliseconds),
         reply: (response) => replyToInteraction(interaction, response),
         ...(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),
@@ -336,6 +399,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;
@@ -397,6 +470,7 @@ function createModalContext(interaction, services) {
         : undefined;
     return {
         interactionId: interaction.id,
+        customId: interaction.customId,
         userId: interaction.user.id,
         userDisplayName: interaction.user.globalName ?? interaction.user.username,
         userRoleIds: interaction.member instanceof GuildMember
@@ -418,6 +492,7 @@ function createModalContext(interaction, services) {
                 ...(ephemeral ? { flags: MessageFlags.Ephemeral } : {}),
             });
         },
+        deleteReplyAfter: (milliseconds) => scheduleReplyDeletion(interaction, milliseconds),
         reply: (response) => replyToInteraction(interaction, response),
         ...(updateResponse ? { updateResponse } : {}),
         getField: (customId) => interaction.fields.getTextInputValue(customId),
@@ -445,6 +520,16 @@ function createModalContext(interaction, services) {
         addChannelMessageReaction: (channelId, messageId, emojiIdentifier) => addChannelMessageReaction(interaction.client, channelId, messageId, emojiIdentifier),
     };
 }
+function scheduleReplyDeletion(interaction, milliseconds) {
+    if (!Number.isInteger(milliseconds) ||
+        milliseconds < 1_000 ||
+        milliseconds > 900_000)
+        throw new Error("Reply deletion delay must be between 1 second and 15 minutes");
+    const timer = setTimeout(() => {
+        void interaction.deleteReply().catch(() => undefined);
+    }, milliseconds);
+    timer.unref();
+}
 function createSelectContext(interaction, services) {
     return {
         ...createContext(interaction, services),
@@ -667,9 +752,7 @@ function toSelectRows(response) {
                 .setPlaceholder(select.placeholder)
                 .setMinValues(select.minValues ?? 1)
                 .setMaxValues(select.maxValues ?? 1)
-                .setChannelTypes(...select.channelTypes.map((type) => type === "guild_announcement"
-                ? ChannelType.GuildAnnouncement
-                : ChannelType.GuildText))));
+                .setChannelTypes(...select.channelTypes.map(discordChannelType))));
             continue;
         }
         if (select.type === "discord-role") {
@@ -701,19 +784,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)
@@ -818,9 +892,7 @@ export function toModal(definition) {
                 .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));
+                .setChannelTypes(...field.channelTypes.map(discordChannelType));
             if (field.placeholder !== undefined)
                 input.setPlaceholder(field.placeholder);
             if (field.defaultValues?.length)
@@ -831,6 +903,13 @@ export function toModal(definition) {
     }
     return modal;
 }
+function discordChannelType(type) {
+    if (type === "guild_announcement")
+        return ChannelType.GuildAnnouncement;
+    if (type === "guild_category")
+        return ChannelType.GuildCategory;
+    return ChannelType.GuildText;
+}
 async function sendFailure(interaction) {
     if (interaction.isAutocomplete()) {
         await interaction.respond([]).catch(() => undefined);

package/dist/management-module.d.ts

@@ -2,7 +2,7 @@ import { type ModuleDefinition } from "@helyx/sdk";
 export interface ManagementGuildResources {
     channels: readonly {
         id: string;
-        type: "guild_text" | "guild_announcement";
+        type: "guild_text" | "guild_announcement" | "guild_category";
     }[];
     roles: readonly {
         id: string;

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

package/dist/message-classification.js

@@ -0,0 +1,75 @@
+import { MessageFlags } from "discord.js";
+const LINK_PATTERN = /https?:\/\/[^\s<>]+/giu;
+const GIF_LINK_PATTERN = /(?:https?:\/\/[^\s<>]*(?:\.gif(?:[?#][^\s<>]*)?|giphy\.com|tenor\.com|media\.discordapp\.net[^\s<>]*\.gif))/giu;
+const CUSTOM_EMOJI_PATTERN = /<a?:[a-zA-Z0-9_]{2,32}:\d{17,20}>/gu;
+const UNICODE_EMOJI_PATTERN = /(?:\p{Regional_Indicator}{2}|[0-9#*]\uFE0F?\u20E3|\p{Extended_Pictographic}(?:\uFE0F|\p{Emoji_Modifier})?(?:\u200D\p{Extended_Pictographic}(?:\uFE0F|\p{Emoji_Modifier})?)*)/gu;
+export function classifyGuildMessage(message) {
+    const kinds = new Set();
+    const content = message.content.trim();
+    const withoutLinks = content.replace(LINK_PATTERN, " ").trim();
+    const withoutEmoji = withoutLinks
+        .replace(CUSTOM_EMOJI_PATTERN, " ")
+        .replace(UNICODE_EMOJI_PATTERN, " ")
+        .replace(/\u200D|\uFE0F|\p{Emoji_Modifier}|\s/gu, "");
+    if (matches(LINK_PATTERN, content))
+        kinds.add("link");
+    if (withoutLinks.length > 0 &&
+        withoutEmoji.length === 0 &&
+        (matches(CUSTOM_EMOJI_PATTERN, withoutLinks) ||
+            matches(UNICODE_EMOJI_PATTERN, withoutLinks)))
+        kinds.add("emoji");
+    else if (withoutEmoji.length > 0)
+        kinds.add("text");
+    const voiceMessage = message.flags.has(MessageFlags.IsVoiceMessage);
+    if (voiceMessage)
+        kinds.add("voice-message");
+    for (const attachment of message.attachments.values()) {
+        const contentType = attachment.contentType?.toLowerCase() ?? "";
+        const filename = attachment.name.toLowerCase();
+        if (voiceMessage)
+            continue;
+        if (contentType === "image/gif" || filename.endsWith(".gif"))
+            kinds.add("gif");
+        else if (contentType.startsWith("image/"))
+            kinds.add("image");
+        else
+            kinds.add("file");
+    }
+    for (const embed of message.embeds) {
+        const urls = [embed.url, embed.image?.url, embed.thumbnail?.url]
+            .filter((value) => Boolean(value))
+            .join(" ");
+        if (matches(GIF_LINK_PATTERN, urls))
+            kinds.add("gif");
+        else if (embed.image || embed.thumbnail)
+            kinds.add("image");
+    }
+    if (matches(GIF_LINK_PATTERN, content))
+        kinds.add("gif");
+    if (message.stickers.size > 0)
+        kinds.add("sticker");
+    return {
+        available: true,
+        kinds: [
+            "text",
+            "emoji",
+            "link",
+            "image",
+            "gif",
+            "file",
+            "sticker",
+            "voice-message",
+        ].filter((kind) => kinds.has(kind)),
+    };
+}
+export const unavailableGuildMessageClassification = {
+    available: false,
+    kinds: [],
+};
+function matches(pattern, value) {
+    pattern.lastIndex = 0;
+    const result = pattern.test(value);
+    pattern.lastIndex = 0;
+    return result;
+}
+//# sourceMappingURL=message-classification.js.map

package/dist/modules.js

@@ -90,12 +90,21 @@ async function loadDefinitions(specifiers, importer) {
     return orderedManifests.map((manifest) => byId.get(manifest.id));
 }
 export function validateContributionParity(definition) {
+    const requiredDiscordCapabilities = definition.requiredDiscordCapabilities ?? [];
+    if (new Set(requiredDiscordCapabilities).size !==
+        requiredDiscordCapabilities.length ||
+        requiredDiscordCapabilities.some((capability) => capability !== "guild-members" && capability !== "message-content")) {
+        throw new Error("Module requests an unsupported or duplicate Discord capability");
+    }
     const executableCommands = (definition.interactions?.commands ?? []).map(({ name }) => name);
     const executableEvents = [
+        ...(definition.events?.privilegedMessageCreate ?? []),
+        ...(definition.events?.guildMessageCreate ?? []),
         ...(definition.events?.messageReactionAdd ?? []),
         ...(definition.events?.messageReactionRemove ?? []),
         ...(definition.events?.messageDelete ?? []),
         ...(definition.events?.guildMemberAdd ?? []),
+        ...(definition.events?.guildMemberRemove ?? []),
         ...(definition.events?.guildRoleDelete ?? []),
         ...(definition.events?.guildRoleUpdate ?? []),
         ...(definition.events?.channelDelete ?? []),

package/dist/numeric-write-behind-proxy.d.ts

@@ -0,0 +1,62 @@
+import { type NumericWriteBehindCommittedBatch, type NumericWriteBehindEnqueueInput, type NumericWriteBehindMemberScope, type NumericWriteBehindScope, type NumericWriteBehindService } from "@helyx/sdk";
+import { type ShardIdentity } from "./shard-contracts.js";
+export declare class WorkerNumericWriteBehindProxy implements NumericWriteBehindService {
+    #private;
+    constructor(identity: ShardIdentity);
+    enqueue(input: NumericWriteBehindEnqueueInput): Promise<{
+        outcome: "accepted" | "cooldown" | "suppressed" | "paused" | "capacity" | "unavailable";
+    }>;
+    pendingMemberSnapshot(input: NumericWriteBehindMemberScope): Promise<{
+        increments: Readonly<Record<string, number>>;
+        maxima: Readonly<Record<string, Date>>;
+        oldestAcceptedAt: Date | null;
+    }>;
+    flushMember(input: NumericWriteBehindMemberScope): Promise<void>;
+    flushGuild(input: NumericWriteBehindScope & {
+        guildId: string;
+    }): Promise<void>;
+    flushSubject(input: NumericWriteBehindScope & {
+        subjectId: string;
+    }): Promise<void>;
+    flushModule(input: NumericWriteBehindScope): Promise<void>;
+    runMemberBarrier<Result>(input: NumericWriteBehindMemberScope, operation: () => Promise<Result>): Promise<Result>;
+    runGuildBarrier<Result>(input: NumericWriteBehindScope & {
+        guildId: string;
+    }, operation: () => Promise<Result>): Promise<Result>;
+    runSubjectBarrier<Result>(input: NumericWriteBehindScope & {
+        subjectId: string;
+    }, operation: () => Promise<Result>): Promise<Result>;
+    suppressSubject(input: NumericWriteBehindScope & {
+        subjectId: string;
+        cutoff: Date;
+    }): Promise<{
+        suppressionId: string;
+        discarded: number;
+    }>;
+    suppressGuild(input: NumericWriteBehindScope & {
+        guildId: string;
+    }): Promise<{
+        suppressionId: string;
+        discarded: number;
+    }>;
+    releaseGuild(input: NumericWriteBehindScope & {
+        guildId: string;
+        suppressionId: string;
+    }): Promise<{
+        released: boolean;
+    }>;
+    releaseSubject(input: NumericWriteBehindScope & {
+        subjectId: string;
+        suppressionId: string;
+    }): Promise<{
+        released: boolean;
+    }>;
+    clearMemberCooldown(input: NumericWriteBehindMemberScope): Promise<void>;
+    clearSubjectCooldown(input: NumericWriteBehindScope & {
+        subjectId: string;
+    }): Promise<void>;
+    subscribeCommitted(input: NumericWriteBehindScope, handler: (batch: NumericWriteBehindCommittedBatch) => void | Promise<void>): () => void;
+    stop(): void;
+}
+export declare function encodeNumericIpcValue(input: unknown): unknown;
+//# sourceMappingURL=numeric-write-behind-proxy.d.ts.map