src/automod/Antispam.ts

/**
 * This file is part of SudoBot.
 *
 * Copyright (C) 2021-2023 OSN Developers.
 *
 * SudoBot is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * SudoBot is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
 */

import { GuildMember, Message, PermissionFlagsBits, TextChannel } from "discord.js";
import Service from "../core/Service";
import { GuildConfig } from "../types/GuildConfigSchema";
import { log, logError } from "../utils/logger";
import { isImmuneToAutoMod, isTextableChannel } from "../utils/utils";

interface SpamUserInfo {
    timestamps: number[];
    timeout?: NodeJS.Timeout;
}

export const name = "antispam";

export default class Antispam extends Service {
    protected readonly map: Record<string, Record<string, SpamUserInfo | undefined>> = {};

    boot() {
        for (const guild in this.client.configManager.config) {
            this.map[guild] = {};
        }
    }

    async muteUser(message: Message, antispam: GuildConfig["antispam"]) {
        this.client.infractionManager
            .createMemberMute(message.member as GuildMember, {
                guild: message.guild!,
                moderator: this.client.user!,
                bulkDeleteReason: "The system has detected spam messages from this user",
                duration: antispam?.mute_duration && antispam?.mute_duration > 0 ? antispam?.mute_duration : 1000 * 60 * 60,
                messageChannel: antispam?.action === "mute_clear" || antispam?.action === "auto" ? (message.channel! as TextChannel) : undefined,
                notifyUser: true,
                reason: "Spam detected",
                sendLog: true,
                autoRemoveQueue: true
            })
            .catch(logError);
    }

    async warnUser(message: Message, antispam: GuildConfig["antispam"]) {
        this.client.infractionManager
            .createMemberWarn(message.member as GuildMember, {
                guild: message.guild!,
                moderator: this.client.user!,
                notifyUser: true,
                reason: `Spam detected.${antispam?.action === "auto" ? " If you continue to send spam messages, you might get muted." : ""}`,
                sendLog: true
            })
            .catch(logError);
    }

    async verballyWarnUser(message: Message) {
        await message.channel
            .send({
                content: `Hey ${message.author.toString()}, don't spam here!`
            })
            .catch(logError);
    }

    async takeAction(message: Message) {
        log("Triggered");

        const config = this.client.configManager.config[message.guildId!];

        if (!config) return;

        const { antispam } = config;

        if (antispam?.action === "mute_clear" || antispam?.action === "mute") {
            await this.muteUser(message, antispam);
        } else if (antispam?.action === "warn") {
            await this.warnUser(message, antispam);
        } else if (antispam?.action === "verbal_warn") {
            await this.verballyWarnUser(message);
        } else if (antispam?.action === "auto") {
            let record = await this.client.prisma.spamRecord.findFirst({
                where: {
                    guild_id: message.guildId!,
                    user_id: message.author.id
                }
            });

            if (!record) {
                record = await this.client.prisma.spamRecord.create({
                    data: {
                        guild_id: message.guildId!,
                        user_id: message.author.id,
                        level: 1
                    }
                });
            } else {
                await this.client.prisma.spamRecord.update({
                    data: {
                        level: {
                            increment: 1
                        }
                    },
                    where: {
                        id: record.id
                    }
                });
            }

            if (record.level === 1) {
                await this.verballyWarnUser(message);
            } else if (record.level === 2) {
                await this.warnUser(message, antispam);
            } else {
                await this.muteUser(message, antispam);
            }
        }
    }

    async onMessageCreate(message: Message) {
        if (!isTextableChannel(message.channel)) return;

        const config = this.client.configManager.config[message.guildId!];

        if (
            !config?.antispam?.enabled ||
            !config?.antispam.limit ||
            !config?.antispam.timeframe ||
            config.antispam.limit < 1 ||
            config.antispam.timeframe < 1
        ) {
            return;
        }

        if (isImmuneToAutoMod(this.client, message.member!, PermissionFlagsBits.ManageMessages)) {
            return;
        }

        const info = this.map[message.guildId!][message.author.id] ?? ({} as SpamUserInfo);

        info.timestamps ??= [];
        info.timestamps.push(Date.now());

        log("Pushed");

        if (!info.timeout) {
            log("Timeout set");

            info.timeout = setTimeout(() => {
                const delayedInfo = this.map[message.guildId!][message.author.id] ?? ({} as SpamUserInfo);
                const timestamps = delayedInfo.timestamps.filter(timestamp => config.antispam?.timeframe! + timestamp >= Date.now());

                if (timestamps.length >= config.antispam?.limit!) {
                    this.takeAction(message).catch(console.error);
                }

                this.map[message.guildId!][message.author.id] = undefined;
                log("Popped");
            }, config.antispam.timeframe);
        }

        this.map[message.guildId!][message.author.id] = info;
    }
}
1	rakinar2	577	/**
2			* This file is part of SudoBot.
3			*
4			* Copyright (C) 2021-2023 OSN Developers.
5			*
6			* SudoBot is free software; you can redistribute it and/or modify it
7			* under the terms of the GNU Affero General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10			*
11			* SudoBot is distributed in the hope that it will be useful, but
12			* WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU Affero General Public License for more details.
15			*
16			* You should have received a copy of the GNU Affero General Public License
17			* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
18			*/
19
20			import { GuildMember, Message, PermissionFlagsBits, TextChannel } from "discord.js";
21			import Service from "../core/Service";
22			import { GuildConfig } from "../types/GuildConfigSchema";
23			import { log, logError } from "../utils/logger";
24			import { isImmuneToAutoMod, isTextableChannel } from "../utils/utils";
25
26			interface SpamUserInfo {
27			timestamps: number[];
28			timeout?: NodeJS.Timeout;
29			}
30
31			export const name = "antispam";
32
33			export default class Antispam extends Service {
34			protected readonly map: Record<string, Record<string, SpamUserInfo \| undefined>> = {};
35
36			boot() {
37			for (const guild in this.client.configManager.config) {
38			this.map[guild] = {};
39			}
40			}
41
42			async muteUser(message: Message, antispam: GuildConfig["antispam"]) {
43			this.client.infractionManager
44			.createMemberMute(message.member as GuildMember, {
45			guild: message.guild!,
46			moderator: this.client.user!,
47			bulkDeleteReason: "The system has detected spam messages from this user",
48			duration: antispam?.mute_duration && antispam?.mute_duration > 0 ? antispam?.mute_duration : 1000 * 60 * 60,
49			messageChannel: antispam?.action === "mute_clear" \|\| antispam?.action === "auto" ? (message.channel! as TextChannel) : undefined,
50			notifyUser: true,
51			reason: "Spam detected",
52			sendLog: true,
53			autoRemoveQueue: true
54			})
55			.catch(logError);
56			}
57
58			async warnUser(message: Message, antispam: GuildConfig["antispam"]) {
59			this.client.infractionManager
60			.createMemberWarn(message.member as GuildMember, {
61			guild: message.guild!,
62			moderator: this.client.user!,
63			notifyUser: true,
64			reason: `Spam detected.${antispam?.action === "auto" ? " If you continue to send spam messages, you might get muted." : ""}`,
65			sendLog: true
66			})
67			.catch(logError);
68			}
69
70			async verballyWarnUser(message: Message) {
71			await message.channel
72			.send({
73			content: `Hey ${message.author.toString()}, don't spam here!`
74			})
75			.catch(logError);
76			}
77
78			async takeAction(message: Message) {
79			log("Triggered");
80
81			const config = this.client.configManager.config[message.guildId!];
82
83			if (!config) return;
84
85			const { antispam } = config;
86
87			if (antispam?.action === "mute_clear" \|\| antispam?.action === "mute") {
88			await this.muteUser(message, antispam);
89			} else if (antispam?.action === "warn") {
90			await this.warnUser(message, antispam);
91			} else if (antispam?.action === "verbal_warn") {
92			await this.verballyWarnUser(message);
93			} else if (antispam?.action === "auto") {
94			let record = await this.client.prisma.spamRecord.findFirst({
95			where: {
96			guild_id: message.guildId!,
97			user_id: message.author.id
98			}
99			});
100
101			if (!record) {
102			record = await this.client.prisma.spamRecord.create({
103			data: {
104			guild_id: message.guildId!,
105			user_id: message.author.id,
106			level: 1
107			}
108			});
109			} else {
110			await this.client.prisma.spamRecord.update({
111			data: {
112			level: {
113			increment: 1
114			}
115			},
116			where: {
117			id: record.id
118			}
119			});
120			}
121
122			if (record.level === 1) {
123			await this.verballyWarnUser(message);
124			} else if (record.level === 2) {
125			await this.warnUser(message, antispam);
126			} else {
127			await this.muteUser(message, antispam);
128			}
129			}
130			}
131
132			async onMessageCreate(message: Message) {
133			if (!isTextableChannel(message.channel)) return;
134
135			const config = this.client.configManager.config[message.guildId!];
136
137			if (
138			!config?.antispam?.enabled \|\|
139			!config?.antispam.limit \|\|
140			!config?.antispam.timeframe \|\|
141			config.antispam.limit < 1 \|\|
142			config.antispam.timeframe < 1
143			) {
144			return;
145			}
146
147			if (isImmuneToAutoMod(this.client, message.member!, PermissionFlagsBits.ManageMessages)) {
148			return;
149			}
150
151			const info = this.map[message.guildId!][message.author.id] ?? ({} as SpamUserInfo);
152
153			info.timestamps ??= [];
154			info.timestamps.push(Date.now());
155
156			log("Pushed");
157
158			if (!info.timeout) {
159			log("Timeout set");
160
161			info.timeout = setTimeout(() => {
162			const delayedInfo = this.map[message.guildId!][message.author.id] ?? ({} as SpamUserInfo);
163			const timestamps = delayedInfo.timestamps.filter(timestamp => config.antispam?.timeframe! + timestamp >= Date.now());
164
165			if (timestamps.length >= config.antispam?.limit!) {
166			this.takeAction(message).catch(console.error);
167			}
168
169			this.map[message.guildId!][message.author.id] = undefined;
170			log("Popped");
171			}, config.antispam.timeframe);
172			}
173
174			this.map[message.guildId!][message.author.id] = info;
175			}
176			}