@helyx/bot 0.4.31 → 0.4.32

package/dist/events.js

@@ -29,10 +29,26 @@ export function installModuleEvents(client, modules, logger, services) {
         moduleId: module.manifest.id,
         contribution,
     })));
+    const reactionRemoveAllContributions = modules.flatMap((module) => (module.events?.messageReactionRemoveAll ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    })));
+    const reactionRemoveEmojiContributions = modules.flatMap((module) => (module.events?.messageReactionRemoveEmoji ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    })));
+    const messageUpdateContributions = modules.flatMap((module) => (module.events?.guildMessageUpdate ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    })));
     const messageDeleteContributions = modules.flatMap((module) => (module.events?.messageDelete ?? []).map((contribution) => ({
         moduleId: module.manifest.id,
         contribution,
     })));
+    const messageDeleteBulkContributions = modules.flatMap((module) => (module.events?.guildMessageDeleteBulk ?? []).map((contribution) => ({
+        moduleId: module.manifest.id,
+        contribution,
+    })));
     const memberAddContributions = modules.flatMap((module) => (module.events?.guildMemberAdd ?? []).map((contribution) => ({
         moduleId: module.manifest.id,
         contribution,
@@ -70,7 +86,11 @@ export function installModuleEvents(client, modules, logger, services) {
         guildVoiceSessionContributions.length === 0 &&
         reactionContributions.length === 0 &&
         reactionRemoveContributions.length === 0 &&
+        reactionRemoveAllContributions.length === 0 &&
+        reactionRemoveEmojiContributions.length === 0 &&
+        messageUpdateContributions.length === 0 &&
         messageDeleteContributions.length === 0 &&
+        messageDeleteBulkContributions.length === 0 &&
         memberAddContributions.length === 0 &&
         memberRemoveContributions.length === 0 &&
         guildRoleDeleteContributions.length === 0 &&
@@ -101,6 +121,11 @@ export function installModuleEvents(client, modules, logger, services) {
                             (await item.contribution.isEligible({
                                 serverId: message.guildId,
                                 channelId: message.channelId,
+                                userId: message.author.id,
+                                userIsBot: message.author.bot,
+                                userIsSystem: message.author.system || message.system,
+                                webhookId: message.webhookId,
+                                content: message.content,
                                 services,
                             }))) {
                             eligible.push(item);
@@ -156,12 +181,40 @@ export function installModuleEvents(client, modules, logger, services) {
                 queue.enqueue(guildId, () => handleReactionRemove(reaction, user, details.burst));
         });
     }
+    if (reactionRemoveAllContributions.length > 0) {
+        client.on(Events.MessageReactionRemoveAll, (message) => {
+            if (message.guildId)
+                queue.enqueue(message.guildId, () => handleReactionRemoveAll(message));
+        });
+    }
+    if (reactionRemoveEmojiContributions.length > 0) {
+        client.on(Events.MessageReactionRemoveEmoji, (reaction) => {
+            const guildId = reaction.message.guildId;
+            if (guildId)
+                queue.enqueue(guildId, () => handleReactionRemoveEmoji(reaction));
+        });
+    }
+    if (messageUpdateContributions.length > 0) {
+        client.on(Events.MessageUpdate, (_before, message) => {
+            if (message.guildId)
+                queue.enqueue(message.guildId, () => handleMessageUpdate(message));
+        });
+    }
     if (messageDeleteContributions.length > 0) {
         client.on(Events.MessageDelete, (message) => {
             if (message.guildId)
                 queue.enqueue(message.guildId, () => handleMessageDelete(message));
         });
     }
+    if (messageDeleteBulkContributions.length > 0) {
+        client.on(Events.MessageBulkDelete, (messages, channel) => {
+            if (channel.isDMBased())
+                return;
+            queue.enqueue(channel.guild.id, () => handleMessageDeleteBulk(channel.guild.id, channel.id, [
+                ...messages.keys(),
+            ]));
+        });
+    }
     if (memberAddContributions.length > 0) {
         client.on(Events.GuildMemberAdd, (member) => {
             queue.enqueue(member.guild.id, () => handleMemberAdd(member));
@@ -360,6 +413,7 @@ export function installModuleEvents(client, modules, logger, services) {
             const installations = services.get(HELYX_SERVICE_NAMES.installations);
             const member = await message.guild?.members.fetch(user.id);
             const userRoleIds = member ? [...member.roles.cache.keys()] : [];
+            const parentChannelId = messageParentChannelId(message);
             for (const { moduleId, contribution } of reactionContributions) {
                 if (!(await installations.isModuleEnabled(message.guildId, moduleId))) {
                     continue;
@@ -368,12 +422,21 @@ export function installModuleEvents(client, modules, logger, services) {
                     await contribution.execute({
                         serverId: message.guildId,
                         channelId: message.channelId,
+                        ...(parentChannelId ? { parentChannelId } : {}),
                         messageId: message.id,
                         userId: receivedUser.id,
                         userRoleIds,
                         emojiKey: reactionEmojiKey(reaction),
+                        emojiIdentifier: reactionEmojiIdentifier(reaction),
+                        reactionCount: Math.max(0, reaction.count ?? 0),
                         reactionType: burst ? "burst" : "normal",
+                        sourceAuthorId: message.author?.id ?? "",
+                        sourceAuthorIsBot: message.author?.bot ?? false,
+                        sourceAuthorIsWebhook: Boolean(message.webhookId),
+                        sourceAuthorIsSystem: (message.author?.system ?? false) || (message.system ?? false),
+                        sourceCreatedAt: message.createdAt ?? new Date(0),
                         services,
+                        fetchSourceMessage: () => sourceMessageSnapshot(message, messageClassificationAvailable),
                         removeAddedReaction: () => reaction.users.remove(user.id).then(() => undefined),
                         removeUserReaction: async (emojiIdentifier) => {
                             const refreshed = await message.fetch();
@@ -465,10 +528,16 @@ export function installModuleEvents(client, modules, logger, services) {
         try {
             if (receivedUser.bot)
                 return;
-            const message = receivedReaction.message;
+            const reaction = receivedReaction.partial
+                ? await receivedReaction.fetch()
+                : receivedReaction;
+            const message = reaction.message.partial
+                ? await reaction.message.fetch()
+                : reaction.message;
             if (!message.guildId || !message.channelId)
                 return;
             const installations = services.get(HELYX_SERVICE_NAMES.installations);
+            const parentChannelId = messageParentChannelId(message);
             for (const { moduleId, contribution } of reactionRemoveContributions) {
                 if (!(await installations.isModuleEnabled(message.guildId, moduleId))) {
                     continue;
@@ -477,9 +546,12 @@ export function installModuleEvents(client, modules, logger, services) {
                     await contribution.execute({
                         serverId: message.guildId,
                         channelId: message.channelId,
+                        ...(parentChannelId ? { parentChannelId } : {}),
                         messageId: message.id,
                         userId: receivedUser.id,
-                        emojiKey: reactionEmojiKey(receivedReaction),
+                        emojiKey: reactionEmojiKey(reaction),
+                        emojiIdentifier: reactionEmojiIdentifier(reaction),
+                        reactionCount: Math.max(0, reaction.count ?? 0),
                         reactionType: burst ? "burst" : "normal",
                         services,
                     });
@@ -502,6 +574,101 @@ export function installModuleEvents(client, modules, logger, services) {
             }, "Module reaction-remove event failed");
         }
     }
+    async function handleReactionRemoveAll(receivedMessage) {
+        const message = receivedMessage.partial
+            ? await receivedMessage.fetch().catch(() => receivedMessage)
+            : receivedMessage;
+        if (!message.guildId || !message.channelId)
+            return;
+        const installations = services.get(HELYX_SERVICE_NAMES.installations);
+        for (const { moduleId, contribution } of reactionRemoveAllContributions) {
+            try {
+                if (!(await installations.isModuleEnabled(message.guildId, moduleId)))
+                    continue;
+                await contribution.execute({
+                    serverId: message.guildId,
+                    channelId: message.channelId,
+                    messageId: message.id,
+                    services,
+                });
+            }
+            catch (error) {
+                logger.warn({
+                    event: "module.reaction_remove_all_failed",
+                    moduleId,
+                    error: safeError(error),
+                    messageId: message.id,
+                    guildId: message.guildId,
+                }, "Module reaction-remove-all event failed");
+            }
+        }
+    }
+    async function handleReactionRemoveEmoji(receivedReaction) {
+        const reaction = receivedReaction.partial
+            ? await receivedReaction.fetch().catch(() => receivedReaction)
+            : receivedReaction;
+        const message = reaction.message;
+        if (!message.guildId || !message.channelId)
+            return;
+        const installations = services.get(HELYX_SERVICE_NAMES.installations);
+        for (const { moduleId, contribution } of reactionRemoveEmojiContributions) {
+            try {
+                if (!(await installations.isModuleEnabled(message.guildId, moduleId)))
+                    continue;
+                await contribution.execute({
+                    serverId: message.guildId,
+                    channelId: message.channelId,
+                    messageId: message.id,
+                    emojiKey: reactionEmojiKey(reaction),
+                    emojiIdentifier: reactionEmojiIdentifier(reaction),
+                    services,
+                });
+            }
+            catch (error) {
+                logger.warn({
+                    event: "module.reaction_remove_emoji_failed",
+                    moduleId,
+                    error: safeError(error),
+                    messageId: message.id,
+                    guildId: message.guildId,
+                }, "Module reaction-remove-emoji event failed");
+            }
+        }
+    }
+    async function handleMessageUpdate(receivedMessage) {
+        if (!receivedMessage.guildId || !receivedMessage.channelId)
+            return;
+        const installations = services.get(HELYX_SERVICE_NAMES.installations);
+        for (const { moduleId, contribution } of messageUpdateContributions) {
+            try {
+                if (!(await installations.isModuleEnabled(receivedMessage.guildId, moduleId)))
+                    continue;
+                await contribution.execute({
+                    serverId: receivedMessage.guildId,
+                    channelId: receivedMessage.channelId,
+                    messageId: receivedMessage.id,
+                    services,
+                    fetchSourceMessage: async () => {
+                        const message = receivedMessage.partial
+                            ? await receivedMessage.fetch().catch(() => null)
+                            : receivedMessage;
+                        return message
+                            ? sourceMessageSnapshot(message, messageClassificationAvailable)
+                            : null;
+                    },
+                });
+            }
+            catch (error) {
+                logger.warn({
+                    event: "module.message_update_failed",
+                    moduleId,
+                    error: safeError(error),
+                    messageId: receivedMessage.id,
+                    guildId: receivedMessage.guildId,
+                }, "Module message-update event failed");
+            }
+        }
+    }
     async function handleMessageDelete(message) {
         if (!message.guildId || !message.channelId)
             return;
@@ -529,6 +696,34 @@ export function installModuleEvents(client, modules, logger, services) {
             }
         }
     }
+    async function handleMessageDeleteBulk(guildId, channelId, messageIds) {
+        if (messageIds.length === 0)
+            return;
+        const installations = services.get(HELYX_SERVICE_NAMES.installations);
+        const boundedIds = messageIds.slice(0, 100);
+        for (const { moduleId, contribution } of messageDeleteBulkContributions) {
+            try {
+                if (!(await installations.isModuleEnabled(guildId, moduleId)))
+                    continue;
+                await contribution.execute({
+                    serverId: guildId,
+                    channelId,
+                    messageIds: boundedIds,
+                    services,
+                });
+            }
+            catch (error) {
+                logger.warn({
+                    event: "module.message_delete_bulk_failed",
+                    moduleId,
+                    error: safeError(error),
+                    guildId,
+                    channelId,
+                    messageCount: boundedIds.length,
+                }, "Module message-delete-bulk event failed");
+            }
+        }
+    }
     async function handleVoiceState(before, after) {
         const memberId = after.id;
         const key = `${after.guild.id}:${memberId}`;
@@ -676,6 +871,78 @@ export function reactionEmojiKey(reaction) {
         ? `custom:${reaction.emoji.id}`
         : `unicode:${(reaction.emoji.name ?? "").normalize("NFKC")}`;
 }
+export function reactionEmojiIdentifier(reaction) {
+    if (!reaction.emoji.id)
+        return reaction.emoji.name ?? "";
+    return `${reaction.emoji.name ?? "emoji"}:${reaction.emoji.id}`;
+}
+async function sourceMessageSnapshot(receivedMessage, contentAvailable) {
+    const message = receivedMessage.partial
+        ? await receivedMessage.fetch()
+        : receivedMessage;
+    const parentChannelId = message.channel.isThread()
+        ? (message.channel.parentId ?? undefined)
+        : undefined;
+    const authorDisplayName = message.member?.displayName ??
+        message.author.globalName ??
+        message.author.username;
+    const attachments = contentAvailable
+        ? [...message.attachments.values()].slice(0, 10).map((attachment) => ({
+            name: attachment.name.slice(0, 255),
+            url: attachment.url,
+            contentType: attachment.contentType,
+            size: attachment.size,
+            image: attachment.contentType === "image/png" ||
+                attachment.contentType === "image/jpeg" ||
+                attachment.contentType === "image/gif" ||
+                attachment.contentType === "image/webp",
+            spoiler: attachment.spoiler,
+        }))
+        : [];
+    return {
+        serverId: message.guildId,
+        channelId: message.channelId,
+        ...(message.channel.isThread()
+            ? message.channel.parent?.name
+                ? { channelName: message.channel.parent.name }
+                : {}
+            : "name" in message.channel && typeof message.channel.name === "string"
+                ? { channelName: message.channel.name }
+                : {}),
+        ...(parentChannelId ? { parentChannelId } : {}),
+        messageId: message.id,
+        jumpUrl: message.url,
+        authorId: message.author.id,
+        authorDisplayName,
+        authorAvatarUrl: message.author.displayAvatarURL({ size: 128 }),
+        authorIsBot: message.author.bot,
+        authorIsWebhook: Boolean(message.webhookId),
+        authorIsSystem: message.author.system || message.system,
+        createdAt: message.createdAt,
+        editedAt: message.editedAt,
+        ageRestricted: messageChannelAgeRestricted(message),
+        contentAvailable,
+        content: contentAvailable ? message.content.slice(0, 4_000) : "",
+        attachments,
+        reactions: [...message.reactions.cache.values()]
+            .slice(0, 20)
+            .map((reaction) => ({
+            emojiKey: reactionEmojiKey(reaction),
+            emojiIdentifier: reactionEmojiIdentifier(reaction),
+            count: Math.max(0, reaction.count),
+        })),
+    };
+}
+function messageChannelAgeRestricted(message) {
+    const channel = message.channel;
+    if (channel.isThread())
+        return channel.parent?.nsfw ?? false;
+    return "nsfw" in channel && channel.nsfw === true;
+}
+function messageParentChannelId(message) {
+    const channel = message.channel;
+    return channel?.isThread?.() ? (channel.parentId ?? undefined) : undefined;
+}
 export function reactionCacheKey(emojiIdentifier) {
     const custom = /^(?:[A-Za-z0-9_]{2,32}):(\d{17,20})$/u.exec(emojiIdentifier);
     return custom?.[1] ?? emojiIdentifier;
@@ -767,6 +1034,34 @@ export class DiscordMessageDeliveryService {
             };
         }
     }
+    async fetchSource(input) {
+        validateSnowflake(input.guildId, "guild");
+        validateSnowflake(input.channelId, "channel");
+        validateSnowflake(input.messageId, "message");
+        const guild = await this.client.guilds.fetch(input.guildId);
+        if (guild.id !== input.guildId)
+            throw new Error("Discord guild validation failed");
+        const channel = await guild.channels.fetch(input.channelId);
+        if (!channel ||
+            channel.guild.id !== guild.id ||
+            !channel.isTextBased() ||
+            channel.isDMBased() ||
+            !channel.viewable)
+            throw new Error("Discord source-message channel is unavailable");
+        try {
+            const message = await channel.messages.fetch(input.messageId);
+            if (message.guildId !== input.guildId ||
+                message.channelId !== input.channelId ||
+                message.id !== input.messageId)
+                throw new Error("Discord source message validation failed");
+            return sourceMessageSnapshot(message, this.client.options.intents.has(GatewayIntentBits.MessageContent));
+        }
+        catch (error) {
+            if (isUnknownMessage(error))
+                return null;
+            throw error;
+        }
+    }
 }
 export class DiscordMemberEnforcementService {
     client;
@@ -1162,6 +1457,43 @@ export class DiscordResourceInspection {
             };
         });
     }
+    async listMembers(input) {
+        validateSnowflake(input.guildId, "guild");
+        if (input.after)
+            validateSnowflake(input.after, "member cursor");
+        if (!Number.isSafeInteger(input.limit) ||
+            input.limit < 1 ||
+            input.limit > 100)
+            throw new Error("Discord member list limit is invalid");
+        if (!this.client.options.intents.has(GatewayIntentBits.GuildMembers))
+            throw new Error("Discord guild-members intent is unavailable");
+        const guild = await this.client.guilds.fetch(input.guildId);
+        if (guild.id !== input.guildId)
+            throw new Error("Discord guild validation failed");
+        const members = await guild.members.fetch({
+            limit: input.limit,
+            ...(input.after ? { after: input.after } : {}),
+        });
+        const ordered = [...members.values()].sort((left, right) => BigInt(left.id) < BigInt(right.id)
+            ? -1
+            : BigInt(left.id) > BigInt(right.id)
+                ? 1
+                : 0);
+        const items = ordered.map((member) => {
+            const avatarUrl = memberAvatarUrl(member);
+            return {
+                userId: member.id,
+                displayName: member.displayName,
+                ...(avatarUrl ? { avatarUrl } : {}),
+                isBot: member.user.bot,
+            };
+        });
+        const nextCursor = items.at(-1)?.userId;
+        return {
+            items,
+            ...(items.length === input.limit && nextCursor ? { nextCursor } : {}),
+        };
+    }
     async #resolveMemberGuild(input) {
         validateSnowflake(input.guildId, "guild");
         if (input.userIds.length > 50 ||
@@ -1295,6 +1627,7 @@ export class DiscordResourceInspection {
                 addReactions: false,
                 readMessageHistory: false,
                 manageMessages: false,
+                ageRestricted: false,
             };
         const guildMatches = channel.guild.id === guild.id;
         const me = guild.members.me ?? (await guild.members.fetchMe());
@@ -1322,6 +1655,9 @@ export class DiscordResourceInspection {
                 (effective?.has(PermissionFlagsBits.ReadMessageHistory) ?? false),
             manageMessages: guildMatches &&
                 (effective?.has(PermissionFlagsBits.ManageMessages) ?? false),
+            ageRestricted: "nsfw" in channel && typeof channel.nsfw === "boolean"
+                ? channel.nsfw
+                : false,
         };
     }
     async inspectMessage(input) {

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[], messageContentEnabled?: boolean): GatewayIntentBits[];
+export declare function gatewayIntentsForModules(modules: readonly ModuleDefinition[], messageContentEnabled?: boolean, guildMembersEnabled?: boolean): GatewayIntentBits[];
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -27,7 +27,10 @@ import { parseShardWorkerLaunchContract, startShardWorker, } from "./shard-worke
 import { createDeveloperOperationsModule } from "./developer-operations-module.js";
 import { shardHealthSnapshotSchema } from "./shard-contracts.js";
 import { createSupportModule } from "./support-module.js";
+import { createOAuthModule } from "./oauth-module.js";
+import { HttpOAuthService } from "./oauth-service.js";
 import { DiscordOwnedMessageDeletionService } from "./discord-owned-message-service.js";
+import { DiscordGuildHealthInspection } from "./discord-guild-health.js";
 import { CoreResourceAuthorizationService } from "./resource-authorization.js";
 import { createLocalScheduledTaskRoute, createScheduledTaskRunner, schedulerOperationalHealth, } from "./scheduled-task-runner.js";
 import { createLocalNumericWriteBehind } from "./numeric-write-behind.js";
@@ -129,7 +132,7 @@ async function startUnshardedBot(processEnvironment) {
         }, "Module databases ready");
         const featureModules = modulePackages.map(({ definition }) => definition);
         const client = new Client({
-            intents: gatewayIntentsForModules(featureModules, environment.HELYX_MESSAGE_CONTENT_ENABLED),
+            intents: gatewayIntentsForModules(featureModules, environment.HELYX_MESSAGE_CONTENT_ENABLED, environment.HELYX_GUILD_MEMBERS_ENABLED),
             partials: [Partials.Message, Partials.Channel, Partials.Reaction],
             allowedMentions: { parse: [] },
         });
@@ -152,10 +155,14 @@ async function startUnshardedBot(processEnvironment) {
             })
             : undefined;
         const supportModule = createSupportModule(cloudConnector);
+        const oauthModule = environment.HELYX_OAUTH_ENABLED
+            ? createOAuthModule()
+            : undefined;
         const publicModules = [
             managementModule,
             permissionsModule,
             supportModule,
+            ...(oauthModule ? [oauthModule] : []),
             ...(cloudManagementModule ? [cloudManagementModule] : []),
             ...featureModules,
         ];
@@ -172,6 +179,7 @@ async function startUnshardedBot(processEnvironment) {
                     managementModule,
                     permissionsModule,
                     supportModule,
+                    ...(oauthModule ? [oauthModule] : []),
                     ...(cloudManagementModule ? [cloudManagementModule] : []),
                 ].map(({ manifest }) => manifest),
                 modules: featureModules.map(({ manifest }) => manifest),
@@ -257,6 +265,9 @@ async function startUnshardedBot(processEnvironment) {
             }));
             platformServices.set(HELYX_SERVICE_NAMES.verificationMembers, new DiscordVerificationMemberService(client));
         }
+        if (environment.HELYX_OAUTH_ENABLED &&
+            environment.HELYX_OAUTH_INTERNAL_SECRET)
+            platformServices.set(HELYX_SERVICE_NAMES.oauth, new HttpOAuthService(environment.HELYX_CLOUD_API_URL, environment.HELYX_OAUTH_INTERNAL_SECRET));
         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)));
@@ -265,6 +276,7 @@ async function startUnshardedBot(processEnvironment) {
         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));
+        platformServices.set(HELYX_SERVICE_NAMES.discordGuildHealth, new DiscordGuildHealthInspection(client, publicModules, serviceAccess));
         if (featureModules.some(({ manifest }) => manifest.id === "helyx.logging")) {
             platformServices.set(HELYX_SERVICE_NAMES.moduleLogging, new DiscordModuleLoggingService(client, database, publicModules, bootstrapLogger));
         }
@@ -277,6 +289,7 @@ async function startUnshardedBot(processEnvironment) {
             managementModule.manifest.id,
             permissionsModule.manifest.id,
             supportModule.manifest.id,
+            ...(oauthModule ? [oauthModule.manifest.id] : []),
             ...(cloudManagementModule ? [cloudManagementModule.manifest.id] : []),
             ...(operationsModule ? [operationsModule.manifest.id] : []),
         ]);
@@ -288,6 +301,7 @@ async function startUnshardedBot(processEnvironment) {
             prepare: prepareGuilds,
             selfAuthorizingGuildModuleIds: new Set([
                 supportModule.manifest.id,
+                ...(oauthModule ? [oauthModule.manifest.id] : []),
                 ...(operationsModule ? [operationsModule.manifest.id] : []),
             ]),
         }, bootstrapLogger, serviceAccess);
@@ -469,10 +483,12 @@ function deploymentReference(processEnvironment) {
         processEnvironment.GIT_COMMIT_SHA;
     return value?.trim().slice(0, 12) || undefined;
 }
-export function gatewayIntentsForModules(modules, messageContentEnabled = false) {
+export function gatewayIntentsForModules(modules, messageContentEnabled = false, guildMembersEnabled = false) {
     const intents = [GatewayIntentBits.Guilds];
     if (modules.some((module) => module.events?.messageReactionAdd?.length ||
-        module.events?.messageReactionRemove?.length)) {
+        module.events?.messageReactionRemove?.length ||
+        module.events?.messageReactionRemoveAll?.length ||
+        module.events?.messageReactionRemoveEmoji?.length)) {
         intents.push(GatewayIntentBits.GuildMessageReactions);
     }
     const hasPrivilegedMessageCreate = modules.some((module) => module.events?.privilegedMessageCreate?.length);
@@ -480,16 +496,19 @@ export function gatewayIntentsForModules(modules, messageContentEnabled = false)
     if (((hasPrivilegedMessageCreate || requiresMessageContent) &&
         messageContentEnabled) ||
         modules.some((module) => module.events?.guildMessageCreate?.length ||
-            module.events?.messageDelete?.length)) {
+            module.events?.guildMessageUpdate?.length ||
+            module.events?.messageDelete?.length ||
+            module.events?.guildMessageDeleteBulk?.length)) {
         intents.push(GatewayIntentBits.GuildMessages);
     }
     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)) {
+    if (guildMembersEnabled ||
+        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?.guildVoiceSession?.length)) {

package/dist/interactions.js

@@ -6,6 +6,7 @@ const buttonStyles = {
     secondary: ButtonStyle.Secondary,
     success: ButtonStyle.Success,
     danger: ButtonStyle.Danger,
+    link: ButtonStyle.Link,
 };
 export function installInteractions(client, modules, registration, logger, services) {
     const commands = uniqueMap(modules.flatMap((module) => (module.interactions?.commands ?? []).map((contribution) => ({
@@ -702,9 +703,14 @@ 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;
+        if (response.content !== undefined) {
+            throw new Error("Components V2 responses cannot include plain content");
+        }
+        let flags = Number(MessageFlags.IsComponentsV2);
+        if (response.ephemeral)
+            flags |= MessageFlags.Ephemeral;
+        if (response.suppressEmbeds)
+            flags |= MessageFlags.SuppressEmbeds;
         return {
             flags,
             ...(allowedMentions ? { allowedMentions } : {}),
@@ -728,9 +734,11 @@ export function toReplyOptions(response) {
                             type: 1,
                             components: response.buttons.map((button) => ({
                                 type: 2,
-                                custom_id: button.customId,
                                 label: button.label,
                                 style: buttonStyles[button.style],
+                                ...(button.style === "link"
+                                    ? { url: button.url }
+                                    : { custom_id: button.customId }),
                                 ...(button.emojiIdentifier
                                     ? { emoji: toButtonEmoji(button.emojiIdentifier) }
                                     : {}),
@@ -750,13 +758,29 @@ export function toReplyOptions(response) {
         : undefined;
     if (embed && response.embed?.footer)
         embed.setFooter({ text: response.embed.footer });
+    if (embed && response.embed?.url)
+        embed.setURL(response.embed.url);
+    if (embed && response.embed?.author)
+        embed.setAuthor({
+            name: response.embed.author.name,
+            ...(response.embed.author.iconUrl
+                ? { iconURL: response.embed.author.iconUrl }
+                : {}),
+        });
+    if (embed && response.embed?.timestamp)
+        embed.setTimestamp(new Date(response.embed.timestamp));
+    if (embed && response.embed?.imageUrl)
+        embed.setImage(response.embed.imageUrl);
     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.style === "link")
+                    builder.setURL(button.url);
+                else
+                    builder.setCustomId(button.customId);
                 if (button.emojiIdentifier) {
                     builder.setEmoji(toButtonEmoji(button.emojiIdentifier));
                 }
@@ -769,8 +793,14 @@ export function toReplyOptions(response) {
         : [];
     components.push(...selectRows);
     return {
-        ...(response.ephemeral ? { flags: MessageFlags.Ephemeral } : {}),
+        ...(response.ephemeral || response.suppressEmbeds
+            ? {
+                flags: (response.ephemeral ? MessageFlags.Ephemeral : 0) |
+                    (response.suppressEmbeds ? MessageFlags.SuppressEmbeds : 0),
+            }
+            : {}),
         ...(allowedMentions ? { allowedMentions } : {}),
+        ...(response.content === undefined ? {} : { content: response.content }),
         ...(embed ? { embeds: [embed] } : {}),
         components,
     };