@helyx/bot 1.2.1 → 1.3.0

package/dist/discord-violation-thread-service.d.ts

@@ -1,6 +1,7 @@
 import type { ViolationEvidenceReference, ViolationThreadConfigurationInspection, ViolationThreadDeliveryResult, ViolationThreadService } from "@helyx/sdk";
 import { type Client } from "discord.js";
 import type { TransientViolationEvidenceStore } from "./transient-violation-evidence.js";
+import { type ViolationEvidenceMessageContext } from "./discord-violation-evidence-message.js";
 /** Guild-owner-routed adapter for role-gated private violation threads. */
 export declare class DiscordViolationThreadAdapter implements ViolationThreadService {
     #private;
@@ -14,13 +15,21 @@ export declare class DiscordViolationThreadAdapter implements ViolationThreadSer
     removeMember(input: Parameters<ViolationThreadService["removeMember"]>[0]): ReturnType<ViolationThreadService["removeMember"]>;
     send(input: Parameters<ViolationThreadService["send"]>[0]): ReturnType<ViolationThreadService["send"]>;
     close(input: Parameters<ViolationThreadService["close"]>[0]): ReturnType<ViolationThreadService["close"]>;
+    editControls(input: Parameters<NonNullable<ViolationThreadService["editControls"]>>[0]): Promise<{
+        outcome: "updated";
+    } | {
+        outcome: "failed";
+        safeCode: string;
+    }>;
     reconcile(input: Parameters<ViolationThreadService["reconcile"]>[0]): ReturnType<ViolationThreadService["reconcile"]>;
 }
 export interface DiscordViolationEvidenceDeliveryInput {
     guildId: string;
     threadId: string;
+    openingMessageId?: string;
     evidenceReference: ViolationEvidenceReference;
     operationKey: string;
+    context?: ViolationEvidenceMessageContext;
 }
 /** Bot-private capability; never installed in the module service map. */
 export declare class DiscordViolationEvidenceDeliveryAdapter {

package/dist/discord-violation-thread-service.js

@@ -1,7 +1,11 @@
 import { VIOLATION_THREAD_LIMITS, VIOLATION_THREAD_REQUIRED_PERMISSIONS, VIOLATION_THREAD_RUNTIME_PERMISSIONS, } from "@helyx/sdk";
-import { ChannelType, DiscordAPIError, MessageFlags, PermissionFlagsBits, } from "discord.js";
+import { ChannelType, DiscordAPIError, PermissionFlagsBits, } from "discord.js";
 import { createHash } from "node:crypto";
 import { toReplyOptions } from "./interactions.js";
+import { closeAndDeleteViolationThread } from "./discord-violation-thread-close.js";
+import { violationEvidenceMessage, } from "./discord-violation-evidence-message.js";
+import { configureViolationNotificationUsers, inspectViolationNotificationUsers, } from "./discord-violation-notification-users.js";
+import { violationLayoutOpening, violationLayoutControls, violationLayoutEvidence, } from "./discord-violation-layout-message.js";
 const SNOWFLAKE_PATTERN = /^\d{17,20}$/u;
 const OPERATION_KEY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,159}$/u;
 const MAX_OPERATION_CACHE_ENTRIES = 10_000;
@@ -51,15 +55,34 @@ export class DiscordViolationThreadAdapter {
         if (!guild)
             return deniedInspection("guild_mismatch", "guild_not_owned");
         const channel = await guild.channels
-            .fetch(input.parentChannelId)
+            .fetch(input.parentChannelId, { force: true })
             .catch(() => null);
         if (!channel ||
             channel.guild.id !== guild.id ||
             channel.type !== ChannelType.GuildText)
             return deniedInspection("channel_missing", "parent_channel_missing");
+        const notificationUsers = await inspectViolationNotificationUsers(guild, channel, input.moderatorUserIds ?? []);
+        if (notificationUsers.outcome !== "allowed")
+            return {
+                outcome: "denied",
+                configurationRevision: null,
+                accessRole: null,
+                missingPermissions: [],
+                requiredChanges: [],
+                safeCode: notificationUsers.safeCode,
+            };
         if (input.accessRoleId === null) {
-            const moderatorRoles = await Promise.all(input.moderatorRoleIds.map((roleId) => guild.roles.fetch(roleId).catch(() => null)));
-            const revision = configurationRevision(channel, null, input.moderatorRoleIds);
+            if (input.moderatorRoleIds.includes(guild.roles.everyone.id))
+                return {
+                    outcome: "denied",
+                    configurationRevision: configurationRevision(channel, null, input.moderatorRoleIds, input.moderatorUserIds),
+                    accessRole: null,
+                    missingPermissions: [],
+                    requiredChanges: [],
+                    safeCode: "moderator_role_unsafe",
+                };
+            const moderatorRoles = await Promise.all(input.moderatorRoleIds.map((roleId) => guild.roles.fetch(roleId, { force: true }).catch(() => null)));
+            const revision = configurationRevision(channel, null, input.moderatorRoleIds, input.moderatorUserIds);
             if (moderatorRoles.some((role) => role === null))
                 return {
                     outcome: "role_missing",
@@ -74,7 +97,8 @@ export class DiscordViolationThreadAdapter {
             const missingPermissions = VIOLATION_THREAD_REQUIRED_PERMISSIONS.filter((name) => name === "MANAGE_ROLES"
                 ? !botMember?.permissions.has(PermissionFlagsBits.ManageRoles)
                 : !permissions?.has(PERMISSION_FLAGS[name]));
-            if (missingPermissions.length > 0)
+            if (missingPermissions.includes("MANAGE_ROLES") ||
+                missingPermissions.includes("MANAGE_CHANNELS"))
                 return {
                     outcome: "denied",
                     configurationRevision: revision,
@@ -87,24 +111,28 @@ export class DiscordViolationThreadAdapter {
                 outcome: "allowed",
                 configurationRevision: revision,
                 accessRole: null,
-                missingPermissions: [],
-                requiredChanges: ["create_access_role"],
+                missingPermissions,
+                requiredChanges: [
+                    "create_access_role",
+                    ...requiredConfigurationChanges(channel, guild, null, moderatorRoles),
+                    ...notificationUsers.requiredChanges,
+                ],
             };
         }
         const accessRole = await guild.roles
-            .fetch(input.accessRoleId)
+            .fetch(input.accessRoleId, { force: true })
             .catch(() => null);
         if (!accessRole)
             return {
                 outcome: "role_missing",
-                configurationRevision: configurationRevision(channel, null, input.moderatorRoleIds),
+                configurationRevision: configurationRevision(channel, null, input.moderatorRoleIds, input.moderatorUserIds),
                 accessRole: null,
                 missingPermissions: [],
                 requiredChanges: [],
                 safeCode: "access_role_missing",
             };
         const accessInspection = await inspectAccessRole(guild, channel.id, accessRole);
-        const revision = configurationRevision(channel, accessRole, input.moderatorRoleIds);
+        const revision = configurationRevision(channel, accessRole, input.moderatorRoleIds, input.moderatorUserIds);
         if (accessInspection.outcome !== "safe")
             return {
                 outcome: "unsafe_access_role",
@@ -124,7 +152,7 @@ export class DiscordViolationThreadAdapter {
                 requiredChanges: [],
                 safeCode: "moderator_role_unsafe",
             };
-        const moderatorRoles = await Promise.all(input.moderatorRoleIds.map((roleId) => guild.roles.fetch(roleId).catch(() => null)));
+        const moderatorRoles = await Promise.all(input.moderatorRoleIds.map((roleId) => guild.roles.fetch(roleId, { force: true }).catch(() => null)));
         if (moderatorRoles.some((role) => role === null))
             return {
                 outcome: "role_missing",
@@ -153,7 +181,10 @@ export class DiscordViolationThreadAdapter {
             configurationRevision: revision,
             accessRole: accessInspection,
             missingPermissions,
-            requiredChanges: requiredConfigurationChanges(channel, guild, accessRole, moderatorRoles),
+            requiredChanges: [
+                ...requiredConfigurationChanges(channel, guild, accessRole, moderatorRoles),
+                ...notificationUsers.requiredChanges,
+            ],
         };
     }
     async createAccessRole(input) {
@@ -226,17 +257,27 @@ export class DiscordViolationThreadAdapter {
         if (current.outcome !== "allowed" ||
             current.configurationRevision !== input.expectedConfigurationRevision)
             return { outcome: "stale_inspection" };
+        if (current.missingPermissions.includes("MANAGE_CHANNELS"))
+            return { outcome: "missing_permission", safeCode: "manage_channels" };
         const guild = this.client.guilds.cache.get(input.guildId);
-        const channel = (await guild.channels.fetch(input.parentChannelId));
+        const channel = await guild.channels
+            .fetch(input.parentChannelId, { force: true })
+            .catch(() => null);
+        if (!channel || channel.type !== ChannelType.GuildText)
+            return { outcome: "channel_missing" };
+        const accessRole = await guild.roles
+            .fetch(input.accessRoleId, { force: true })
+            .catch(() => null);
+        if (!accessRole)
+            return { outcome: "role_missing" };
+        const notificationUsers = await inspectViolationNotificationUsers(guild, channel, input.moderatorUserIds ?? []);
+        if (notificationUsers.outcome !== "allowed")
+            return { outcome: "failed", safeCode: notificationUsers.safeCode };
+        if (configurationRevision(channel, accessRole, input.moderatorRoleIds, input.moderatorUserIds) !== input.expectedConfigurationRevision)
+            return { outcome: "stale_inspection" };
         const botMember = guild.members.me;
         try {
-            await channel.permissionOverwrites.edit(guild.roles.everyone, { ViewChannel: false }, { reason: auditReason(input.operationKey) });
-            await channel.permissionOverwrites.edit(input.accessRoleId, {
-                ViewChannel: true,
-                ReadMessageHistory: true,
-                SendMessages: false,
-                SendMessagesInThreads: true,
-            }, { reason: auditReason(input.operationKey) });
+            // Retain the bot's access before hiding a previously public parent.
             await channel.permissionOverwrites.edit(botMember, {
                 ViewChannel: true,
                 ReadMessageHistory: true,
@@ -245,6 +286,12 @@ export class DiscordViolationThreadAdapter {
                 ManageThreads: true,
                 ManageChannels: true,
             }, { reason: auditReason(input.operationKey) });
+            await channel.permissionOverwrites.edit(input.accessRoleId, {
+                ViewChannel: true,
+                ReadMessageHistory: true,
+                SendMessages: false,
+                SendMessagesInThreads: true,
+            }, { reason: auditReason(input.operationKey) });
             for (const roleId of input.moderatorRoleIds)
                 await channel.permissionOverwrites.edit(roleId, {
                     ViewChannel: true,
@@ -252,6 +299,12 @@ export class DiscordViolationThreadAdapter {
                     SendMessagesInThreads: true,
                     ManageThreads: true,
                 }, { reason: auditReason(input.operationKey) });
+            if (!(await configureViolationNotificationUsers(channel, notificationUsers.members, () => input.revalidate(), auditReason(input.operationKey))))
+                return {
+                    outcome: "ambiguous",
+                    safeCode: "configuration_partially_applied",
+                };
+            await channel.permissionOverwrites.edit(guild.roles.everyone, { ViewChannel: false }, { reason: auditReason(input.operationKey) });
         }
         catch (error) {
             return isDiscordStatus(error, 403)
@@ -296,6 +349,7 @@ export class DiscordViolationThreadAdapter {
             };
         const operationIdentity = `${input.guildId}:${input.parentChannelId}:${input.operationKey}`;
         const marker = operationMarker(operationIdentity);
+        const caseSuffix = /-\d{3,16}$/u.exec(input.name.trim())?.[0];
         const knownThreadId = this.#operationResources.get(operationIdentity);
         if (knownThreadId) {
             const known = await guild.channels.fetch(knownThreadId).catch(() => null);
@@ -303,7 +357,7 @@ export class DiscordViolationThreadAdapter {
                 return { outcome: "already_exists", threadId: known.id };
             this.#operationResources.delete(operationIdentity);
         }
-        const existing = await findPrivateThreadByMarker(parent, marker);
+        const existing = await findPrivateThreadByMarker(parent, marker, caseSuffix, this.client.user?.id);
         if (existing === UNKNOWN_THREAD)
             return { outcome: "ambiguous", safeCode: "idempotency_lookup_failed" };
         if (existing) {
@@ -314,7 +368,7 @@ export class DiscordViolationThreadAdapter {
             return { outcome: "no_longer_required" };
         try {
             const thread = await parent.threads.create({
-                name: markedName(input.name, marker),
+                name: caseSuffix ? input.name.trim() : markedName(input.name, marker),
                 type: ChannelType.PrivateThread,
                 invitable: false,
                 reason: auditReason(input.operationKey),
@@ -342,10 +396,12 @@ export class DiscordViolationThreadAdapter {
         if (!thread)
             return { outcome: "thread_missing" };
         try {
-            const message = await thread.send(toReplyOptions({
-                ...input.response,
-                ephemeral: false,
-            }));
+            const message = await thread.send(input.presentation
+                ? violationLayoutOpening(input.response, input.presentation)
+                : toReplyOptions({
+                    ...input.response,
+                    ephemeral: false,
+                }));
             this.#remember(this.#operationMessages, operationIdentity, message.id);
             return { outcome: "sent", messageId: message.id };
         }
@@ -355,6 +411,8 @@ export class DiscordViolationThreadAdapter {
     }
     async close(input) {
         validateThreadInput(input);
+        if (input.deleteThread)
+            return this.#closeAndDelete(input);
         const thread = await this.#privateThread(input.guildId, input.threadId);
         if (!thread)
             return { outcome: "thread_missing" };
@@ -374,6 +432,42 @@ export class DiscordViolationThreadAdapter {
             return threadMutationFailure(error);
         }
     }
+    async #closeAndDelete(input) {
+        if (!input.parentChannelId)
+            return {
+                outcome: "missing_permission",
+                safeCode: "thread_binding_missing",
+            };
+        validateSnowflake(input.parentChannelId);
+        try {
+            return await closeAndDeleteViolationThread(this.client, input, auditReason(input.operationKey), () => safelyRevalidate(() => input.revalidate()));
+        }
+        catch (error) {
+            return threadMutationFailure(error);
+        }
+    }
+    async editControls(input) {
+        validateThreadInput(input);
+        validateSnowflake(input.messageId);
+        const thread = await this.#privateThread(input.guildId, input.threadId);
+        if (!thread)
+            return { outcome: "failed", safeCode: "thread_missing" };
+        try {
+            const message = await thread.messages.fetch(input.messageId);
+            if (message.author.id !== this.client.user?.id)
+                return { outcome: "failed", safeCode: "control_owner_mismatch" };
+            if (!(await safelyRevalidate(() => input.revalidate())))
+                return { outcome: "failed", safeCode: "control_access_changed" };
+            await message.edit({
+                allowedMentions: { parse: [] },
+                components: violationLayoutControls(message.components.map((component) => component.toJSON()), input.buttons),
+            });
+            return { outcome: "updated" };
+        }
+        catch {
+            return { outcome: "failed", safeCode: "control_edit_failed" };
+        }
+    }
     async reconcile(input) {
         validateSnowflake(input.guildId);
         validateSnowflake(input.parentChannelId);
@@ -387,8 +481,12 @@ export class DiscordViolationThreadAdapter {
         try {
             const channel = await guild.channels.fetch(input.threadId);
             if (!isOwnedPrivateThread(channel, input.guildId) ||
-                channel.parentId !== input.parentChannelId)
-                return { outcome: "absent" };
+                channel.parentId !== input.parentChannelId ||
+                (input.requireBotOwner &&
+                    (!this.client.user?.id || channel.ownerId !== this.client.user.id)))
+                return channel
+                    ? { outcome: "unknown", safeCode: "thread_binding_mismatch" }
+                    : { outcome: "absent" };
             return {
                 outcome: "exists",
                 threadId: channel.id,
@@ -409,23 +507,37 @@ export class DiscordViolationThreadAdapter {
         const thread = await this.#privateThread(input.guildId, input.threadId);
         if (!guild || !thread)
             return { outcome: "thread_missing" };
-        const member = await guild.members
-            .fetch(input.memberUserId)
-            .catch(() => null);
-        if (!member)
-            return { outcome: "member_missing" };
+        let member;
+        try {
+            // Singular role grants return a clone; without GuildMembers updates the
+            // cached member can still lack the just-granted violation access role.
+            member = await guild.members.fetch({
+                user: input.memberUserId,
+                force: true,
+            });
+        }
+        catch (error) {
+            return isDiscordStatus(error, 404)
+                ? { outcome: "member_missing" }
+                : threadMutationFailure(error);
+        }
         const parent = thread.parent;
         const memberPermissions = parent?.permissionsFor(member);
-        if (!memberPermissions?.has(PermissionFlagsBits.ViewChannel) ||
-            !memberPermissions.has(PermissionFlagsBits.SendMessagesInThreads))
+        if (operation === "add" &&
+            (!memberPermissions?.has(PermissionFlagsBits.ViewChannel) ||
+                !memberPermissions.has(PermissionFlagsBits.SendMessagesInThreads)))
             return {
                 outcome: "missing_permission",
                 safeCode: "member_parent_access",
             };
         try {
             const present = await thread.members
-                .fetch(input.memberUserId)
-                .catch(() => null);
+                .fetch({ member: input.memberUserId, force: true, withMember: false })
+                .catch((error) => {
+                if (isDiscordStatus(error, 404))
+                    return null;
+                throw error;
+            });
             if ((operation === "add" && present) ||
                 (operation === "remove" && !present))
                 return { outcome: "already_exists", threadId: thread.id };
@@ -468,6 +580,8 @@ export class DiscordViolationEvidenceDeliveryAdapter {
     }
     async deliverEvidence(input) {
         validateThreadInput(input);
+        if (input.openingMessageId)
+            validateSnowflake(input.openingMessageId);
         const operationIdentity = `${input.guildId}:${input.threadId}:evidence:${input.operationKey}`;
         const known = this.#operationMessages.get(operationIdentity);
         if (known)
@@ -488,11 +602,25 @@ export class DiscordViolationEvidenceDeliveryAdapter {
                     : "evidence_unavailable",
             };
         try {
-            const message = await channel.send({
-                content: evidence.content,
-                allowedMentions: { parse: [] },
-                flags: MessageFlags.SuppressEmbeds,
-            });
+            if (input.openingMessageId) {
+                const opening = await channel.messages.fetch(input.openingMessageId);
+                if (opening.author.id !== this.client.user?.id)
+                    return { outcome: "evidence_mismatch" };
+                const components = violationLayoutEvidence(opening.components.map((component) => component.toJSON()), input.evidenceReference, evidence.content, input.context);
+                if (components) {
+                    await opening.edit({ components, allowedMentions: { parse: [] } });
+                    rememberOperation(this.#operationMessages, operationIdentity, opening.id);
+                    this.evidence.discard(input.evidenceReference);
+                    return { outcome: "sent", messageId: opening.id };
+                }
+                const summary = violationLayoutEvidence(opening.components.map((component) => component.toJSON()), input.evidenceReference, evidence.content, input.context, true);
+                if (summary)
+                    await opening.edit({
+                        components: summary,
+                        allowedMentions: { parse: [] },
+                    });
+            }
+            const message = await channel.send(violationEvidenceMessage(input.evidenceReference, evidence.content, input.context));
             rememberOperation(this.#operationMessages, operationIdentity, message.id);
             this.evidence.discard(input.evidenceReference);
             return { outcome: "sent", messageId: message.id };
@@ -573,9 +701,10 @@ function requiredConfigurationChanges(channel, guild, accessRole, moderatorRoles
     if (!overwriteDenies(channel, guild.roles.everyone.id, PermissionFlagsBits.ViewChannel))
         changes.push("deny_everyone_view_channel");
     for (const [name, permission] of Object.entries(ACCESS_PERMISSION_FLAGS))
-        if (!overwriteAllows(channel, accessRole.id, permission))
+        if (!accessRole || !overwriteAllows(channel, accessRole.id, permission))
             changes.push(`allow_access_role_${name.toLowerCase()}`);
-    if (!overwriteDenies(channel, accessRole.id, PermissionFlagsBits.SendMessages))
+    if (!accessRole ||
+        !overwriteDenies(channel, accessRole.id, PermissionFlagsBits.SendMessages))
         changes.push("deny_access_role_parent_messages");
     const botMemberId = guild.members.me.id;
     for (const name of [
@@ -613,7 +742,7 @@ function rememberOperation(cache, key, value) {
         cache.delete(oldest);
     }
 }
-function configurationRevision(channel, role, moderatorRoleIds) {
+function configurationRevision(channel, role, moderatorRoleIds, moderatorUserIds = []) {
     const overwrites = [...channel.permissionOverwrites.cache.values()]
         .map((overwrite) => ({
         id: overwrite.id,
@@ -634,6 +763,7 @@ function configurationRevision(channel, role, moderatorRoleIds) {
             }
             : null,
         moderatorRoleIds: [...moderatorRoleIds].sort(),
+        moderatorUserIds: [...moderatorUserIds].sort(),
         overwrites,
     }))
         .digest("hex");
@@ -699,14 +829,22 @@ function isOwnedPrivateThread(channel, guildId, parentChannelId) {
         channel.guild.id === guildId &&
         (!parentChannelId || channel.parentId === parentChannelId));
 }
-async function findPrivateThreadByMarker(parent, marker) {
-    const matches = (name) => name?.endsWith(`[${marker}]`) ?? false;
-    const cached = parent.threads.cache.find((thread) => thread.type === ChannelType.PrivateThread && matches(thread.name));
+async function findPrivateThreadByMarker(parent, marker, caseSuffix, botUserId) {
+    // Guild case numbers never repeat. The fixed, padded numeric suffix survives
+    // prefix changes without exposing the operation hash in the thread name.
+    // Restrict the new-name recovery path to private threads created by this bot.
+    // Legacy operation markers remain readable for deliveries created before this change.
+    const matches = (thread) => thread.name.endsWith(`[${marker}]`) ||
+        Boolean(caseSuffix &&
+            botUserId &&
+            thread.ownerId === botUserId &&
+            thread.name.endsWith(caseSuffix));
+    const cached = parent.threads.cache.find((thread) => thread.type === ChannelType.PrivateThread && matches(thread));
     if (cached)
         return cached.id;
     try {
         const active = await parent.threads.fetchActive();
-        const activeMatch = active.threads.find((thread) => thread.type === ChannelType.PrivateThread && matches(thread.name));
+        const activeMatch = active.threads.find((thread) => thread.type === ChannelType.PrivateThread && matches(thread));
         if (activeMatch)
             return activeMatch.id;
         let before;
@@ -716,7 +854,7 @@ async function findPrivateThreadByMarker(parent, marker) {
                 limit: 100,
                 ...(before ? { before } : {}),
             });
-            const match = archived.threads.find((thread) => matches(thread.name));
+            const match = archived.threads.find((thread) => thread.type === ChannelType.PrivateThread && matches(thread));
             if (match)
                 return match.id;
             if (!archived.hasMore)

package/dist/events.js

@@ -7,6 +7,7 @@ import { classifyGuildMessage, unavailableGuildMessageClassification, } from "./
 import { canAccessModule } from "./premium-access.js";
 import { fromDiscordAction, toRuleSnapshot, } from "./discord-auto-moderation-service.js";
 import { PrivilegedMessageMetadataCache } from "./privileged-message-metadata-cache.js";
+import { DiscordAutoModerationExecutionIds } from "./discord-automod-execution-ids.js";
 export function availabilityAwareInstallations(services, modulesById) {
     const installations = services.get(HELYX_SERVICE_NAMES.installations);
     const candidate = typeof services.has === "function" &&
@@ -65,6 +66,7 @@ function privilegedSource(message) {
 }
 export function installModuleEvents(client, modules, logger, services, options) {
     const runtimeProfile = options?.runtimeProfile ?? "hosted";
+    const autoModerationExecutionIds = new DiscordAutoModerationExecutionIds();
     const modulesById = new Map(modules.map((module) => [module.manifest.id, module]));
     const privilegedMessageContributions = modules.flatMap((module) => (module.events?.privilegedMessageCreate ?? [])
         .filter((contribution) => !contribution.featureId || runtimeProfile === "self-hosted")
@@ -342,7 +344,11 @@ export function installModuleEvents(client, modules, logger, services, options)
     }
     if (autoModerationActionContributions.length > 0) {
         client.on(Events.AutoModerationActionExecution, (execution) => {
-            queue.enqueue(execution.guild.id, () => handleAutoModerationAction(execution));
+            // Correlate at Gateway receipt, not after earlier actions/thread setup
+            // have held the per-guild queue longer than the correlation window.
+            const executionId = autoModerationExecutionIds.identify(execution);
+            const occurredAt = new Date();
+            queue.enqueue(execution.guild.id, () => handleAutoModerationAction(execution, executionId, occurredAt));
         });
     }
     if (messageDeleteContributions.length > 0) {
@@ -542,18 +548,9 @@ export function installModuleEvents(client, modules, logger, services, options)
             }
         }
     }
-    async function handleAutoModerationAction(execution) {
+    async function handleAutoModerationAction(execution, executionId, occurredAt) {
         const installations = availabilityAwareInstallations(services, modulesById);
         const action = fromDiscordAction(execution.action);
-        const executionId = createHash("sha256")
-            .update(JSON.stringify([
-            execution.guild.id,
-            execution.ruleId,
-            execution.userId,
-            execution.channelId,
-            execution.messageId,
-        ]))
-            .digest("hex");
         const evidenceReference = options?.evidenceStore && execution.channelId && execution.content
             ? options.evidenceStore.capture({
                 source: "discord_auto_moderation",
@@ -580,7 +577,7 @@ export function installModuleEvents(client, modules, logger, services, options)
                         action,
                         executionId,
                         evidenceReference,
-                        occurredAt: new Date(),
+                        occurredAt,
                         services,
                     });
                 }
@@ -1685,7 +1682,10 @@ export class DiscordMemberRoleService {
         const guild = await this.client.guilds.fetch(input.guildId);
         if (guild.id !== input.guildId)
             throw new Error("Discord guild validation failed");
-        const member = await guild.members.fetch(input.memberUserId);
+        const member = await guild.members.fetch({
+            user: input.memberUserId,
+            force: true,
+        });
         if (member.id !== input.memberUserId || member.guild.id !== guild.id)
             throw new Error("Discord member validation failed");
         return { guild, member };

package/dist/management-module.js

@@ -1,6 +1,7 @@
 import { isCustomerSelectableModule, } from "@helyx/module-manifest";
 import { defineModule, HELYX_SERVICE_NAMES, ModuleStateValidationError, } from "@helyx/sdk";
 import { INTERNAL_MODULE_MANIFEST_FIELDS } from "./internal-module-manifest.js";
+import { validateDiscordUserSettingSelections } from "./dashboard-discord-settings.js";
 const MODULE_SELECT_ID = "helyx.management.module";
 const SETTING_SELECT_ID = "helyx.management.setting";
 const VALUE_SELECT_ID = "helyx.management.value";
@@ -129,7 +130,9 @@ export function createManagementModule(configurableModules, resources) {
                         const setting = selectedSetting(module, context.selectedValues[0]);
                         const state = { ...session.state, selectedSettingKey: setting.key };
                         await updateSession(context, session, state);
-                        if (setting.type === "string" || setting.type === "integer") {
+                        if (setting.type === "string" ||
+                            setting.type === "integer" ||
+                            setting.type === "discord-user") {
                             const now = Date.now();
                             for (const [key, prepared] of preparedValueModals) {
                                 if (prepared.expiresAt <= now)
@@ -222,6 +225,7 @@ export function createManagementModule(configurableModules, resources) {
                             return;
                         }
                         try {
+                            await validateDiscordUserSettingSelections(context.services, context.serverId, module.manifest.dashboard?.settings ?? [], value);
                             const validated = module.configuration?.validate(value);
                             if (validated && module.configuration?.validateUpdate) {
                                 await module.configuration.validateUpdate({
@@ -353,6 +357,15 @@ export function createManagementModule(configurableModules, resources) {
                             return;
                         const module = selectedModule(session.state, byId);
                         const setting = selectedSetting(module, stringState(session.state, "selectedSettingKey"));
+                        if (setting.type === "discord-user") {
+                            const userIds = [...context.getSelectedUserIds(VALUE_FIELD_ID)];
+                            const updated = await updateSession(context, session, {
+                                ...session.state,
+                                draft: { ...draft(session.state), [setting.key]: userIds },
+                            });
+                            await respond(context, configurationResponse(module, updated.state));
+                            return;
+                        }
                         if (setting.type !== "string" && setting.type !== "integer") {
                             throw new Error("Selected setting does not use text input");
                         }
@@ -593,7 +606,7 @@ function textSettingResponse(setting) {
             text: [{ content: `## ${setting.label}\n${setting.description}` }],
         },
         buttons: [
-            button(OPEN_VALUE_MODAL_ID, "Enter value", "primary"),
+            button(OPEN_VALUE_MODAL_ID, setting.type === "discord-user" ? "Choose users" : "Enter value", "primary"),
             button(CONFIGURE_ID, "Back to settings", "secondary"),
             button(CANCEL_ID, "Cancel", "secondary"),
         ],
@@ -680,6 +693,25 @@ function preparedModalKey(serverId, userId) {
 }
 function settingModal(setting, values) {
     const current = values[setting.key];
+    if (setting.type === "discord-user")
+        return {
+            customId: VALUE_MODAL_ID,
+            title: truncate(setting.label, 45),
+            text: [{ content: setting.description, markdown: false }],
+            fields: [
+                {
+                    type: "discord-user",
+                    customId: VALUE_FIELD_ID,
+                    label: setting.label,
+                    required: setting.required,
+                    minValues: Math.max(setting.required ? 1 : 0, setting.minItems ?? 0),
+                    maxValues: setting.maxItems ?? 25,
+                    defaultValues: Array.isArray(current)
+                        ? current.filter((id) => typeof id === "string")
+                        : [],
+                },
+            ],
+        };
     return {
         customId: VALUE_MODAL_ID,
         title: truncate(setting.label, 45),
@@ -724,6 +756,8 @@ function initialDraft(module, existing) {
     return result;
 }
 function emptyValue(setting) {
+    if (setting.type === "discord-user")
+        return [];
     if (setting.type === "discord-channel" && setting.multiple)
         return [];
     if (setting.type === "discord-role" && setting.multiple)