feat: add repel command and mini mod role support

Author: hmd-ali

.env.example

@@ -40,3 +40,5 @@ ONBOARDING_CHANNEL=
 JOIN_LOG_CHANNEL=
 INTRO_CHANNEL=
 INTRO_ROLE=
+REPEL_ROLE_NAME=MiniMod # The name of the role that is used for MiniMods
+REPEL_DELETE_COUNT=2 # The number of messages to delete when using the repel command

src/env.ts

@@ -42,3 +42,7 @@ export const { ONBOARDING_CHANNEL } = process.env;
 export const { JOIN_LOG_CHANNEL } = process.env;
 export const { INTRO_CHANNEL } = process.env;
 export const { INTRO_ROLE } = process.env;
+
+export const { REPEL_ROLE_NAME } = process.env;
+export const REPEL_DELETE_COUNT =
+  Number.parseInt(process.env.REPEL_DELETE_COUNT) || 2;

src/v2/commands/index.ts

@@ -36,6 +36,7 @@ import { resourceInteraction } from './resource/index.js';
 import { shitpostInteraction } from './shitpost/index.js';
 // import { warn } from './warn/index.js';
 import { whynoInteraction } from './whyno/index.js';
+import { repelInteraction } from './repel';
 
 export const guildCommands = new Map(
   [
@@ -50,8 +51,9 @@ export const guildCommands = new Map(
     whynoInteraction,
     roleCommands,
     setupCommands,
+    repelInteraction,
     // warn // Not used atm
-  ].map(command => [command.name, command])
+  ].map(command => [command.name, command]),
 ); // placeholder for now
 
 export const applicationCommands = new Collection<
@@ -88,7 +90,7 @@ const stripNullish = <T>(obj: T): T => {
   return Object.fromEntries(
     Object.entries(obj)
       .map(([a, b]) => [a, stripNullish(b)])
-      .filter(([, b]) => b != null)
+      .filter(([, b]) => b != null),
   ) as T;
 };
 
@@ -121,7 +123,7 @@ export const registerCommands = async (client: Client): Promise<void> => {
           content: 'Something went wrong when trying to execute the command',
         });
       }
-    })
+    }),
   );
 
   for (const { onAttach } of applicationCommands.values()) {
@@ -152,7 +154,7 @@ export const registerCommands = async (client: Client): Promise<void> => {
   await addCommands(
     discordCommandsById,
     applicationCommands,
-    client.application.commands
+    client.application.commands,
   );
 
   console.log('General Commands All Added');
@@ -170,14 +172,14 @@ async function addCommands(
     ApplicationCommand<{ guild: GuildResolvable }>
   >,
   commandDescriptions: Map<string, CommandDataWithHandler>,
-  commandManager: ApplicationCommandManager | GuildApplicationCommandManager
+  commandManager: ApplicationCommandManager | GuildApplicationCommandManager,
 ) {
   const discordChatInputCommandsById = serverCommands.filter(
-    x => x.type === ApplicationCommandType.ChatInput
+    x => x.type === ApplicationCommandType.ChatInput,
   );
 
   const discordCommands = new Collection(
-    discordChatInputCommandsById.map(value => [value.name, value])
+    discordChatInputCommandsById.map(value => [value.name, value]),
   );
 
   const validCommands = pipe<
@@ -188,22 +190,22 @@ async function addCommands(
       ([key, val]: [string, CommandDataWithHandler]) =>
         'guild' in commandManager && val.guildValidate
           ? val.guildValidate(commandManager.guild)
-          : true
+          : true,
     ),
     map(([key]) => key),
   ]);
 
   const newCommands = difference(
     validCommands(commandDescriptions),
-    discordCommands.keys()
+    discordCommands.keys(),
   );
   const existingCommands = intersection(
     validCommands(commandDescriptions),
-    discordCommands.keys()
+    discordCommands.keys(),
   );
   const deletedCommands = difference<string>(
     discordCommands.keys(),
-    validCommands(commandDescriptions)
+    validCommands(commandDescriptions),
   );
 
   // const new = await client.application.commands.create()
@@ -213,15 +215,15 @@ async function addCommands(
       editExistingCommands(
         commandDescriptions,
         commandManager,
-        discordCommands
+        discordCommands,
       )(existingCommands),
-      deleteRemovedCommands(commandManager, discordCommands)(deletedCommands)
-    )
+      deleteRemovedCommands(commandManager, discordCommands)(deletedCommands),
+    ),
   );
 }
 
 function getDestination(
-  commandManager: ApplicationCommandManager | GuildApplicationCommandManager
+  commandManager: ApplicationCommandManager | GuildApplicationCommandManager,
 ) {
   return 'guild' in commandManager
     ? `Guild: ${commandManager.guild.name}`
@@ -230,7 +232,7 @@ function getDestination(
 
 function createNewCommands(
   cmdDescriptions: Map<string, CommandDataWithHandler>,
-  cmdMgr: ApplicationCommandManager | GuildApplicationCommandManager
+  cmdMgr: ApplicationCommandManager | GuildApplicationCommandManager,
 ) {
   const destination = getDestination(cmdMgr);
   return map(async (name: string) => {
@@ -248,7 +250,7 @@ function createNewCommands(
 function editExistingCommands(
   cmdDescriptions: Map<string, CommandDataWithHandler>,
   cmdMgr: ApplicationCommandManager | GuildApplicationCommandManager,
-  existingCommands: Map<string, ApplicationCommand>
+  existingCommands: Map<string, ApplicationCommand>,
 ) {
   const destination = getDestination(cmdMgr);
   return map((name: string) => {
@@ -260,7 +262,7 @@ function editExistingCommands(
     if (
       !isEqual(
         getRelevantCmdProperties(cmd),
-        getRelevantCmdProperties(existing)
+        getRelevantCmdProperties(existing),
       )
     ) {
       console.info(`Updating ${name} for ${destination}`);
@@ -272,7 +274,7 @@ function editExistingCommands(
 
 function deleteRemovedCommands(
   cmdMgr: ApplicationCommandManager | GuildApplicationCommandManager,
-  existingCommands: Map<string, ApplicationCommand>
+  existingCommands: Map<string, ApplicationCommand>,
 ) {
   const destination = getDestination(cmdMgr);
   return map(async (name: string) => {

src/v2/commands/repel/index.ts

@@ -0,0 +1,209 @@
+import {
+  ApplicationCommandOptionType,
+  ChannelType,
+  PermissionFlagsBits,
+  User,
+  type Client,
+  type CommandInteraction,
+  type GuildMember,
+  type TextChannel,
+} from 'discord.js';
+import type { CommandDataWithHandler } from '../../../types';
+import { REPEL_DELETE_COUNT, REPEL_ROLE_NAME } from '../../env';
+
+const TARGET_KEY = 'target';
+const MESSAGE_LINK_KEY = 'message_link';
+const DAY = 24 * 60 * 60 * 1000;
+const TIMEOUT_DURATION = 6 * 60 * 60 * 1000; // 6 hours in milliseconds
+
+const reply = (
+  interaction: CommandInteraction,
+  content: string,
+  ephemeral = true,
+) => interaction.reply({ content, ephemeral });
+
+const getTargetFromMessage = async (
+  client: Client,
+  guild: any,
+  messageLink: string,
+) => {
+  const match = messageLink.match(/(?:channels|@me)\/(?:(\d+)\/)?(\d+)\/(\d+)/);
+  if (!match) throw new Error('Invalid message link format.');
+  const messageId = match[3];
+  const channelId = match[2];
+
+  const channel = channelId ? await client.channels.fetch(channelId) : null;
+  if (channel?.type !== ChannelType.GuildText)
+    throw new Error('Invalid channel for message link.');
+
+  const message = await (channel as TextChannel).messages.fetch(messageId);
+  return await guild.members.fetch(message.author.id);
+};
+
+export const repelInteraction: CommandDataWithHandler = {
+  name: 'repel',
+  description:
+    'Remove recent messages and timeout a user (requires timeout permissions)',
+  options: [
+    {
+      name: TARGET_KEY,
+      description: 'The user to repel',
+      type: ApplicationCommandOptionType.User,
+      required: false,
+    },
+    {
+      name: MESSAGE_LINK_KEY,
+      description: 'Message link to identify the user to repel',
+      type: ApplicationCommandOptionType.String,
+      required: false,
+    },
+  ],
+
+  handler: async (client: Client, interaction: CommandInteraction) => {
+    if (!interaction.inGuild() || !interaction.guild) {
+      await reply(interaction, 'This command can only be used in a server.');
+    }
+    const repelRole = interaction.guild.roles.cache.find(
+      role => role.name === REPEL_ROLE_NAME,
+    );
+
+    if (!repelRole) {
+      await reply(
+        interaction,
+        `${REPEL_ROLE_NAME || 'Repel'} role not found. Please contact an admin.`,
+      );
+      return;
+    }
+    const member = interaction.member as GuildMember;
+
+    const canUseCommand =
+      member.permissions.has(PermissionFlagsBits.ModerateMembers) ||
+      member.roles.cache.has(repelRole.id) ||
+      member.roles.cache.some(role => role.position >= repelRole.position);
+
+    if (!canUseCommand) {
+      await reply(
+        interaction,
+        `You do not have permission to use this command. You need the ${REPEL_ROLE_NAME} role or moderate members permission.`,
+      );
+      return;
+    }
+
+    const targetUser = interaction.options.get(TARGET_KEY, false)?.user as
+      | User
+      | undefined;
+    const messageLink = interaction.options.get(MESSAGE_LINK_KEY, false)
+      ?.value as string | undefined;
+
+    if (!targetUser && !messageLink) {
+      await reply(
+        interaction,
+        'You must specify either a user or a message link.',
+      );
+    }
+
+    try {
+      let targetMember: GuildMember;
+
+      if (targetUser) {
+        targetMember = await interaction.guild.members.fetch(targetUser.id);
+      } else if (messageLink) {
+        targetMember = await getTargetFromMessage(
+          client,
+          interaction.guild,
+          messageLink!,
+        );
+      }
+
+      if (targetMember.id === member.id) {
+        await reply(interaction, 'You cannot repel yourself.');
+        return;
+      }
+
+      const botMember = await interaction.guild.members.fetch(client.user!.id);
+      const isOwner = interaction.guild.ownerId === member.id;
+
+      if (targetMember.id === interaction.guild.ownerId) {
+        await reply(interaction, 'Cannot moderate the server owner.');
+      }
+
+      if (
+        !isOwner &&
+        targetMember.roles.highest.position >= member.roles.highest.position
+      ) {
+        await reply(
+          interaction,
+          'You cannot moderate this user due to role hierarchy.',
+        );
+      }
+
+      if (
+        targetMember.roles.highest.position >= botMember.roles.highest.position
+      ) {
+        await reply(
+          interaction,
+          'I cannot moderate this user due to role hierarchy.',
+        );
+      }
+
+      await interaction.deferReply({ ephemeral: true });
+
+      let deletedCount = 0;
+      const textChannels = interaction.guild.channels.cache.filter(
+        ch => ch.type === ChannelType.GuildText,
+      );
+
+      for (const [, channel] of textChannels) {
+        if (deletedCount >= REPEL_DELETE_COUNT) break;
+
+        try {
+          const messages = await channel.messages.fetch({
+            limit: 100,
+          });
+          const userMessages = messages
+            .filter(
+              m =>
+                m.author.id === targetMember.id &&
+                Date.now() - m.createdTimestamp < 14 * DAY,
+            )
+            .first(
+              Math.min(REPEL_DELETE_COUNT - deletedCount, REPEL_DELETE_COUNT),
+            );
+          if (userMessages.length > 0) {
+            userMessages.length === 1
+              ? await userMessages[0].delete()
+              : await (channel as TextChannel).bulkDelete(userMessages);
+            deletedCount += userMessages.length;
+          }
+        } catch {}
+      }
+
+      const isUserTimedOut = targetMember.communicationDisabledUntilTimestamp
+        ? targetMember.communicationDisabledUntilTimestamp > Date.now()
+        : false;
+
+      if (!isUserTimedOut) {
+        await targetMember.timeout(
+          TIMEOUT_DURATION,
+          `Repel command used by ${member.user.tag}`,
+        );
+        await interaction.editReply({
+          content: `Successfully repelled ${targetMember.user.tag}. Removed ${deletedCount} messages and timed out for 6 hours.`,
+        });
+      } else {
+        await interaction.editReply({
+          content: `Successfully repelled ${targetMember.user.tag}. Removed ${deletedCount} messages.`,
+        });
+      }
+    } catch (error: any) {
+      const errorMsg =
+        error.message || 'An error occurred while executing this command.';
+
+      if (interaction.deferred) {
+        await interaction.editReply({ content: errorMsg });
+      } else {
+        await reply(interaction, errorMsg + ' Please try again later.');
+      }
+    }
+  },
+};

src/v2/index.ts

@@ -40,7 +40,7 @@ import { stripMarkdownQuote } from './utils/content_format.js';
 const NON_COMMAND_MSG_TYPES = new Set([
   ChannelType.GuildText,
   ChannelType.PrivateThread,
-  ChannelType.PublicThread
+  ChannelType.PublicThread,
 ]);
 
 if (IS_PROD) {
@@ -121,7 +121,7 @@ client.once('ready', async (): Promise<void> => {
 
   try {
     await client.user.setAvatar('./logo.png');
-  } catch { }
+  } catch {}
 });
 
 const detectVarLimited = limitFnByUser(detectVar, {