feat: raid protection

Author: virtual-designer

.vscode/settings.json

@@ -44,6 +44,7 @@
         "espree",
         "estree",
         "kickable",
+        "Lockdown",
         "manageafks",
         "MASSBAN",
         "MASSKICK",

src/main/typescript/automod/RaidProtectionService.ts

@@ -0,0 +1,169 @@
+import { Inject } from "@framework/container/Inject";
+import { GatewayEventListener } from "@framework/events/GatewayEventListener";
+import { Name } from "@framework/services/Name";
+import { Service } from "@framework/services/Service";
+import { HasEventListeners } from "@framework/types/HasEventListeners";
+import { GuildConfig } from "@main/schemas/GuildConfigSchema";
+import { LogEventType } from "@main/schemas/LoggingSchema";
+import type ConfigurationManager from "@main/services/ConfigurationManager";
+import { assertUnreachable } from "@main/utils/utils";
+import { Collection, Guild, GuildMember, Snowflake } from "discord.js";
+
+@Name("raidProtectionService")
+class RaidProtectionService extends Service implements HasEventListeners {
+    @Inject("configManager")
+    private readonly configManager!: ConfigurationManager;
+
+    private readonly cache = new Collection<
+        Snowflake,
+        {
+            count: number;
+            lastUpdate: number;
+            actionTaken: boolean;
+        }
+    >();
+
+    private _timeout?: ReturnType<typeof setTimeout>;
+
+    @GatewayEventListener("guildMemberAdd")
+    public async onGuildMemberAdd(member: GuildMember) {
+        const config = this.configManager.config[member.guild.id]?.raid_protection;
+
+        if (!config?.enabled) {
+            return;
+        }
+
+        const now = Date.now();
+        const entry = this.cache.get(member.guild.id);
+
+        this._timeout ??= setTimeout(() => {
+            for (const [guildId, entry] of this.cache) {
+                const config = this.configManager.config[guildId]?.raid_protection;
+
+                if (!config?.enabled || entry.lastUpdate + config.timeframe < now) {
+                    this.cache.delete(guildId);
+                }
+            }
+
+            this._timeout = undefined;
+        }, 60_000);
+
+        if (!entry) {
+            this.cache.set(member.guild.id, {
+                count: 1,
+                lastUpdate: now,
+                actionTaken: false
+            });
+
+            return;
+        }
+
+        if (entry.actionTaken) {
+            return;
+        }
+
+        if (entry.lastUpdate + config.timeframe < now) {
+            entry.count = 1;
+            entry.lastUpdate = now;
+            return;
+        }
+
+        const { lastUpdate } = entry;
+
+        entry.count++;
+        entry.lastUpdate = now;
+
+        if (entry.count <= config.threshold) {
+            return;
+        }
+
+        await Promise.all([
+            this.takeAction(member.guild, config, entry.count, now - lastUpdate),
+            this.takeMemberAction(member, config)
+        ]);
+
+        entry.actionTaken = true;
+    }
+
+    private async takeAction(
+        guild: Guild,
+        config: RaidProtectionConfig,
+        count: number,
+        duration: number
+    ) {
+        const action =
+            config.action === "auto"
+                ? duration < 60_000 && count >= 15
+                    ? "lock_and_antijoin"
+                    : "lock"
+                : config.action;
+
+        if (!this.configManager.config[guild.id]) {
+            return;
+        }
+
+        switch (action) {
+            case "antijoin":
+                await this.enableAntiJoin(guild);
+                break;
+            case "lock":
+                await this.lockGuild(guild, config);
+                break;
+            case "lock_and_antijoin":
+                await this.lockGuild(guild, config);
+                await this.enableAntiJoin(guild);
+                break;
+            case "none":
+                break;
+            default:
+                assertUnreachable(action);
+        }
+
+        await this.application
+            .service("auditLoggingService")
+            .emitLogEvent(guild.id, LogEventType.RaidAlert, {
+                actions: config.member_actions,
+                duration,
+                guild,
+                membersJoined: count,
+                serverAction: action
+            });
+    }
+
+    private async enableAntiJoin(guild: Guild) {
+        this.configManager.config[guild.id]!.anti_member_join ??= {
+            enabled: true,
+            behavior: "kick",
+            custom_reason: "Automatic: This server is not accepting new members at the moment.",
+            ignore_bots: true
+        };
+
+        await this.configManager.write({ guild: true, system: false });
+    }
+
+    private async lockGuild(guild: Guild, { channel_mode, channels }: RaidProtectionConfig) {
+        const channelsToLock = guild.channels.cache.filter(
+            channel_mode === "exclude"
+                ? channel => !channels.includes(channel.id)
+                : channel => channels.includes(channel.id)
+        );
+
+        return await this.application
+            .service("channelLockManager")
+            .lockAll(guild, channelsToLock.values());
+    }
+
+    private async takeMemberAction(member: GuildMember, config: RaidProtectionConfig) {
+        if (config.member_actions.length === 0) {
+            return;
+        }
+
+        await this.application
+            .service("moderationActionService")
+            .takeActions(member.guild, member, config.member_actions);
+    }
+}
+
+type RaidProtectionConfig = NonNullable<GuildConfig["raid_protection"]>;
+
+export default RaidProtectionService;

src/main/typescript/core/DiscordKernel.ts

@@ -78,6 +78,7 @@ class DiscordKernel extends Kernel {
         "@services/ModerationActionService",
         "@automod/SpamModerationService",
         "@automod/RuleModerationService",
+        "@automod/RaidProtectionService",
         "@services/ChannelLockManager",
         "@services/ReactionRoleService",
         "@services/AFKService",

src/main/typescript/schemas/GuildConfigSchema.ts

@@ -186,7 +186,21 @@ export const GuildConfigSchema = z.object({
                 .optional()
         })
         .optional(),
-    survey_system: SurveySystemConfigSchema.optional()
+    survey_system: SurveySystemConfigSchema.optional(),
+    raid_protection: z
+        .object({
+            enabled: z.boolean().optional().default(false),
+            threshold: z.number().int().default(10),
+            timeframe: z.number().int().default(60_000),
+            action: z
+                .enum(["auto", "lock", "antijoin", "lock_and_antijoin", "none"])
+                .default("auto"),
+            member_actions: z.array(ModerationActionSchema).default([]),
+            send_log: z.boolean().optional().default(true),
+            channels: z.array(zSnowflake).default([]),
+            channel_mode: z.enum(["exclude", "include"]).default("exclude")
+        })
+        .optional()
     /*
     quickmute: z
         .object({

src/main/typescript/schemas/LoggingSchema.ts

@@ -1,6 +1,7 @@
 import type Duration from "@framework/datetime/Duration";
 import type { RuleExecResult } from "@main/contracts/ModerationRuleHandlerContract";
 import type { MessageRuleType } from "@main/schemas/MessageRuleSchema";
+import type { ModerationActionType } from "@main/schemas/ModerationActionSchema";
 import { zSnowflake } from "@main/schemas/SnowflakeSchema";
 import type {
     Collection,
@@ -33,7 +34,8 @@ export enum LogEventType {
     UserNoteAdd = "user_note_add",
     MemberRoleModification = "member_role_modification",
     SystemAutoModRuleModeration = "system_automod_rule_moderation",
-    SystemUserMessageSave = "system_user_message_save"
+    SystemUserMessageSave = "system_user_message_save",
+    RaidAlert = "raid_alert"
 }
 
 const LogEventSchema = z.enum(
@@ -67,6 +69,15 @@ export type LogEventArgs = {
     [LogEventType.UserNoteAdd]: [payload: LogUserNoteAddPayload];
     [LogEventType.MemberRoleModification]: [payload: LogMemberRoleModificationPayload];
     [LogEventType.SystemUserMessageSave]: [message: Message, moderator: User];
+    [LogEventType.RaidAlert]: [payload: LogRaidAlertPayload];
+};
+
+export type LogRaidAlertPayload = {
+    guild: Guild;
+    membersJoined: number;
+    duration: number;
+    actions: ModerationActionType[];
+    serverAction: "none" | "lock" | "lock_and_antijoin" | "antijoin";
 };
 
 type LogModerationActionCommonPayload = {