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, Snowflake, 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;
}

interface SimilarMessageSpamInfo {
    content?: string;
    count: number;
    timeout?: NodeJS.Timeout;
}

export const name = "antispam";

export default class Antispam extends Service {
    protected readonly map: Record<`${Snowflake}_${Snowflake}`, SpamUserInfo | undefined> = {};
    protected readonly similarMessageSpamMap: Record<`${Snowflake}_${Snowflake}`, SimilarMessageSpamInfo | undefined> = {};

    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 checkForSimilarMessages(message: Message, config: GuildConfig) {
        if (
            !config.antispam?.similar_messages?.max ||
            config.antispam?.similar_messages?.max < 0 ||
            message.content.trim() === ""
        ) {
            return false;
        }

        const channels = config.antispam?.similar_messages?.channels;

        if (typeof channels === "boolean" && !channels) {
            return false;
        }

        if (channels !== true && !channels?.includes(message.channelId)) {
            return false;
        }

        const lastMessageInfo = this.similarMessageSpamMap[`${message.guildId!}_${message.author.id}`];

        if (!lastMessageInfo) {
            this.similarMessageSpamMap[`${message.guildId!}_${message.author.id}`] = {
                count: 0,
                content: message.content,
                timeout: setTimeout(() => {
                    const lastMessageInfo = this.similarMessageSpamMap[`${message.guildId!}_${message.author.id}`];
                    const max = config.antispam?.similar_messages?.max;

                    if (lastMessageInfo && max && lastMessageInfo.count >= max) {
                        lastMessageInfo.count = 0;
                        this.takeAction(message).catch(console.error);
                    }

                    this.similarMessageSpamMap[`${message.guildId!}_${message.author.id}`] = undefined;
                }, config.antispam.similar_messages?.timeframe ?? config.antispam.timeframe)
            };

            return false;
        }

        if (message.content === lastMessageInfo.content) {
            log("Similar message found");
            lastMessageInfo.count++;
        } else {
            log("Similar message count reset");
            lastMessageInfo.count = 0;
        }

        this.similarMessageSpamMap[`${message.guildId!}_${message.author.id}`] = lastMessageInfo;
        return false;
    }

    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 ||
            config.antispam.disabled_channels.includes(message.channelId!)
        ) {
            return;
        }

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

        const result = await this.checkForSimilarMessages(message, config);

        if (result) {
            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	/**
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, Snowflake, 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	interface SimilarMessageSpamInfo {
32	content?: string;
33	count: number;
34	timeout?: NodeJS.Timeout;
35	}
36
37	export const name = "antispam";
38
39	export default class Antispam extends Service {
40	protected readonly map: Record<`${Snowflake}_${Snowflake}`, SpamUserInfo \| undefined> = {};
41	protected readonly similarMessageSpamMap: Record<`${Snowflake}_${Snowflake}`, SimilarMessageSpamInfo \| undefined> = {};
42
43	async muteUser(message: Message, antispam: GuildConfig["antispam"]) {
44	this.client.infractionManager
45	.createMemberMute(message.member as GuildMember, {
46	guild: message.guild!,
47	moderator: this.client.user!,
48	bulkDeleteReason: "The system has detected spam messages from this user",
49	duration: antispam?.mute_duration && antispam?.mute_duration > 0 ? antispam?.mute_duration : 1000 * 60 * 60,
50	messageChannel:
51	antispam?.action === "mute_clear" \|\| antispam?.action === "auto"
52	? (message.channel! as TextChannel)
53	: undefined,
54	notifyUser: true,
55	reason: "Spam detected",
56	sendLog: true,
57	autoRemoveQueue: true
58	})
59	.catch(logError);
60	}
61
62	async warnUser(message: Message, antispam: GuildConfig["antispam"]) {
63	this.client.infractionManager
64	.createMemberWarn(message.member as GuildMember, {
65	guild: message.guild!,
66	moderator: this.client.user!,
67	notifyUser: true,
68	reason: `Spam detected.${
69	antispam?.action === "auto" ? " If you continue to send spam messages, you might get muted." : ""
70	}`,
71	sendLog: true
72	})
73	.catch(logError);
74	}
75
76	async verballyWarnUser(message: Message) {
77	await message.channel
78	.send({
79	content: `Hey ${message.author.toString()}, don't spam here!`
80	})
81	.catch(logError);
82	}
83
84	async takeAction(message: Message) {
85	log("Triggered");
86
87	const config = this.client.configManager.config[message.guildId!];
88
89	if (!config) return;
90
91	const { antispam } = config;
92
93	if (antispam?.action === "mute_clear" \|\| antispam?.action === "mute") {
94	await this.muteUser(message, antispam);
95	} else if (antispam?.action === "warn") {
96	await this.warnUser(message, antispam);
97	} else if (antispam?.action === "verbal_warn") {
98	await this.verballyWarnUser(message);
99	} else if (antispam?.action === "auto") {
100	let record = await this.client.prisma.spamRecord.findFirst({
101	where: {
102	guild_id: message.guildId!,
103	user_id: message.author.id
104	}
105	});
106
107	if (!record) {
108	record = await this.client.prisma.spamRecord.create({
109	data: {
110	guild_id: message.guildId!,
111	user_id: message.author.id,
112	level: 1
113	}
114	});
115	} else {
116	await this.client.prisma.spamRecord.update({
117	data: {
118	level: {
119	increment: 1
120	}
121	},
122	where: {
123	id: record.id
124	}
125	});
126	}
127
128	if (record.level === 1) {
129	await this.verballyWarnUser(message);
130	} else if (record.level === 2) {
131	await this.warnUser(message, antispam);
132	} else {
133	await this.muteUser(message, antispam);
134	}
135	}
136	}
137
138	async checkForSimilarMessages(message: Message, config: GuildConfig) {
139	if (
140	!config.antispam?.similar_messages?.max \|\|
141	config.antispam?.similar_messages?.max < 0 \|\|
142	message.content.trim() === ""
143	) {
144	return false;
145	}
146
147	const channels = config.antispam?.similar_messages?.channels;
148
149	if (typeof channels === "boolean" && !channels) {
150	return false;
151	}
152
153	if (channels !== true && !channels?.includes(message.channelId)) {
154	return false;
155	}
156
157	const lastMessageInfo = this.similarMessageSpamMap[`${message.guildId!}_${message.author.id}`];
158
159	if (!lastMessageInfo) {
160	this.similarMessageSpamMap[`${message.guildId!}_${message.author.id}`] = {
161	count: 0,
162	content: message.content,
163	timeout: setTimeout(() => {
164	const lastMessageInfo = this.similarMessageSpamMap[`${message.guildId!}_${message.author.id}`];
165	const max = config.antispam?.similar_messages?.max;
166
167	if (lastMessageInfo && max && lastMessageInfo.count >= max) {
168	lastMessageInfo.count = 0;
169	this.takeAction(message).catch(console.error);
170	}
171
172	this.similarMessageSpamMap[`${message.guildId!}_${message.author.id}`] = undefined;
173	}, config.antispam.similar_messages?.timeframe ?? config.antispam.timeframe)
174	};
175
176	return false;
177	}
178
179	if (message.content === lastMessageInfo.content) {
180	log("Similar message found");
181	lastMessageInfo.count++;
182	} else {
183	log("Similar message count reset");
184	lastMessageInfo.count = 0;
185	}
186
187	this.similarMessageSpamMap[`${message.guildId!}_${message.author.id}`] = lastMessageInfo;
188	return false;
189	}
190
191	async onMessageCreate(message: Message) {
192	if (!isTextableChannel(message.channel)) return;
193
194	const config = this.client.configManager.config[message.guildId!];
195
196	if (
197	!config?.antispam?.enabled \|\|
198	!config?.antispam.limit \|\|
199	!config?.antispam.timeframe \|\|
200	config.antispam.limit < 1 \|\|
201	config.antispam.timeframe < 1 \|\|
202	config.antispam.disabled_channels.includes(message.channelId!)
203	) {
204	return;
205	}
206
207	if (await isImmuneToAutoMod(this.client, message.member!, PermissionFlagsBits.ManageMessages)) {
208	return;
209	}
210
211	const result = await this.checkForSimilarMessages(message, config);
212
213	if (result) {
214	return;
215	}
216
217	const info = this.map[`${message.guildId!}_${message.author.id}`] ?? ({} as SpamUserInfo);
218
219	info.timestamps ??= [];
220	info.timestamps.push(Date.now());
221
222	log("Pushed");
223
224	if (!info.timeout) {
225	log("Timeout set");
226
227	info.timeout = setTimeout(() => {
228	const delayedInfo = this.map[`${message.guildId!}_${message.author.id}`] ?? ({} as SpamUserInfo);
229	const timestamps = delayedInfo.timestamps.filter(
230	timestamp => config.antispam?.timeframe! + timestamp >= Date.now()
231	);
232
233	if (timestamps.length >= config.antispam?.limit!) {
234	this.takeAction(message).catch(console.error);
235	}
236
237	this.map[`${message.guildId!}_${message.author.id}`] = undefined;
238	log("Popped");
239	}, config.antispam.timeframe);
240	}
241
242	this.map[`${message.guildId!}_${message.author.id}`] = info;
243	}
244	}