adb-plugin-moderation 1.0.0

package/commands/ticket.js

@@ -0,0 +1,276 @@
+"use strict";
+
+const { EmbedBuilder, PermissionFlagsBits, ChannelType } = require("discord.js");
+const { requirePerms } = require("../lib/permissions");
+
+module.exports = {
+  data: {
+    name: "ticket",
+    description: "Ticket system management",
+    options: [
+      {
+        type: 1, // SUB_COMMAND
+        name: "setup",
+        description: "Configure the ticket system",
+        options: [
+          { type: 7, name: "category", description: "Category for ticket channels", required: true },
+          { type: 8, name: "support_role", description: "Role pinged when a ticket opens", required: true },
+          { type: 7, name: "log_channel", description: "Channel for ticket transcripts", required: false },
+        ],
+      },
+      {
+        type: 1, // SUB_COMMAND
+        name: "open",
+        description: "Open a support ticket",
+        options: [
+          { type: 3, name: "reason", description: "Reason for opening a ticket", required: false },
+        ],
+      },
+      {
+        type: 1, // SUB_COMMAND
+        name: "close",
+        description: "Close the current ticket",
+        options: [],
+      },
+      {
+        type: 1, // SUB_COMMAND
+        name: "add",
+        description: "Add a user to this ticket",
+        options: [
+          { type: 6, name: "user", description: "User to add", required: true },
+        ],
+      },
+      {
+        type: 1, // SUB_COMMAND
+        name: "remove",
+        description: "Remove a user from this ticket",
+        options: [
+          { type: 6, name: "user", description: "User to remove", required: true },
+        ],
+      },
+    ],
+  },
+
+  async execute(interaction, ctx) {
+    const sub = interaction.options.getSubcommand();
+    const guildId = interaction.guild.id;
+    const TicketModel = ctx.models.Ticket;
+
+    if (sub === "setup") {
+      if (!requirePerms(interaction, PermissionFlagsBits.ManageGuild)) return;
+
+      const category = interaction.options.getChannel("category");
+      const supportRole = interaction.options.getRole ? interaction.options.getRole("support_role") : null;
+      const logChannel = interaction.options.getChannel("log_channel");
+
+      // For raw option access when getRole isn't available (mock environment)
+      const supportRoleId = supportRole
+        ? supportRole.id
+        : interaction.options.get("support_role")?.value || null;
+
+      await ctx.db.updatePluginConfig(guildId, "adb-plugin-moderation", {
+        ticket_category_id: category.id,
+        ticket_support_role_id: supportRoleId,
+        ticket_log_channel_id: logChannel ? logChannel.id : null,
+      });
+
+      const embed = new EmbedBuilder()
+        .setColor(0x2ecc71)
+        .setTitle("Ticket System Configured")
+        .addFields(
+          { name: "Category", value: `${category}`, inline: true },
+          { name: "Support Role", value: supportRoleId ? `<@&${supportRoleId}>` : "None", inline: true },
+          { name: "Log Channel", value: logChannel ? `${logChannel}` : "None", inline: true }
+        )
+        .setTimestamp();
+
+      return interaction.reply({ embeds: [embed], ephemeral: true });
+    }
+
+    if (sub === "open") {
+      const reason = interaction.options.getString("reason") || "";
+      const configData = (await ctx.db.getPluginConfig(guildId, "adb-plugin-moderation"))?.data || {};
+
+      if (!configData.ticket_category_id) {
+        const embed = new EmbedBuilder()
+          .setColor(0xe74c3c)
+          .setDescription("Ticket system is not configured. Ask an admin to run `/ticket setup` first.");
+        return interaction.reply({ embeds: [embed], ephemeral: true });
+      }
+
+      // Check if user already has an open ticket
+      const existing = await TicketModel.findOne({
+        guildId,
+        userId: interaction.user.id,
+        status: "open",
+      }).lean();
+
+      if (existing) {
+        const embed = new EmbedBuilder()
+          .setColor(0xe74c3c)
+          .setDescription(`You already have an open ticket: <#${existing.channelId}>`);
+        return interaction.reply({ embeds: [embed], ephemeral: true });
+      }
+
+      let ticketChannel;
+      try {
+        ticketChannel = await interaction.guild.channels.create({
+          name: `ticket-${interaction.user.username}`,
+          type: ChannelType.GuildText,
+          parent: configData.ticket_category_id,
+          permissionOverwrites: [
+            {
+              id: interaction.guild.roles.everyone.id,
+              deny: [PermissionFlagsBits.ViewChannel],
+            },
+            {
+              id: interaction.user.id,
+              allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages],
+            },
+            ...(configData.ticket_support_role_id
+              ? [
+                  {
+                    id: configData.ticket_support_role_id,
+                    allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages],
+                  },
+                ]
+              : []),
+          ],
+        });
+      } catch (err) {
+        const embed = new EmbedBuilder().setColor(0xe74c3c).setDescription(`Failed to create ticket channel: ${err.message}`);
+        return interaction.reply({ embeds: [embed], ephemeral: true });
+      }
+
+      const ticketDoc = new TicketModel({
+        guildId,
+        channelId: ticketChannel.id,
+        userId: interaction.user.id,
+        reason,
+        status: "open",
+      });
+      await ticketDoc.save();
+
+      const openEmbed = new EmbedBuilder()
+        .setColor(0x3498db)
+        .setTitle("Support Ticket Opened")
+        .setDescription(`Hello ${interaction.user}, a staff member will be with you shortly.`)
+        .addFields(reason ? [{ name: "Reason", value: reason }] : [])
+        .setTimestamp();
+
+      const pingContent = configData.ticket_support_role_id
+        ? `<@&${configData.ticket_support_role_id}>`
+        : null;
+
+      await ticketChannel.send({
+        content: pingContent,
+        embeds: [openEmbed],
+      });
+
+      const confirmEmbed = new EmbedBuilder()
+        .setColor(0x2ecc71)
+        .setDescription(`Your ticket has been opened: ${ticketChannel}`);
+
+      return interaction.reply({ embeds: [confirmEmbed], ephemeral: true });
+    }
+
+    if (sub === "close") {
+      if (!requirePerms(interaction, PermissionFlagsBits.ManageChannels)) return;
+
+      const ticketDoc = await TicketModel.findOne({
+        guildId,
+        channelId: interaction.channel.id,
+        status: "open",
+      });
+
+      if (!ticketDoc) {
+        const embed = new EmbedBuilder()
+          .setColor(0xe74c3c)
+          .setDescription("This channel is not an open ticket.");
+        return interaction.reply({ embeds: [embed], ephemeral: true });
+      }
+
+      const configData = (await ctx.db.getPluginConfig(guildId, "adb-plugin-moderation"))?.data || {};
+
+      // Post transcript to log channel
+      if (configData.ticket_log_channel_id) {
+        try {
+          const logChannel = await ctx.client.channels.fetch(configData.ticket_log_channel_id);
+          if (logChannel && logChannel.isTextBased()) {
+            const messages = await interaction.channel.messages.fetch({ limit: 100 });
+            const transcript = [...messages.values()]
+              .reverse()
+              .map((m) => `[${new Date(m.createdTimestamp).toISOString()}] ${m.author.tag}: ${m.content}`)
+              .join("\n");
+
+            const logEmbed = new EmbedBuilder()
+              .setColor(0x95a5a6)
+              .setTitle("Ticket Closed")
+              .addFields(
+                { name: "Opened by", value: `<@${ticketDoc.userId}>`, inline: true },
+                { name: "Closed by", value: `${interaction.user.tag}`, inline: true },
+                { name: "Reason", value: ticketDoc.reason || "No reason" }
+              )
+              .setTimestamp();
+
+            await logChannel.send({ embeds: [logEmbed] });
+
+            if (transcript.length > 0) {
+              const truncated = transcript.length > 1900 ? transcript.slice(-1900) + "\n..." : transcript;
+              await logChannel.send({ content: `\`\`\`\n${truncated}\n\`\`\`` });
+            }
+          }
+        } catch (err) {
+          ctx.logger.warn(`[moderation] Failed to log ticket transcript: ${err.message}`);
+        }
+      }
+
+      ticketDoc.status = "closed";
+      ticketDoc.closedAt = new Date();
+      await ticketDoc.save();
+
+      await interaction.reply({ content: "Ticket closed. Deleting channel in 5 seconds...", ephemeral: false });
+
+      setTimeout(() => {
+        interaction.channel.delete("Ticket closed").catch(() => {});
+      }, 5000);
+    }
+
+    if (sub === "add") {
+      if (!requirePerms(interaction, PermissionFlagsBits.ManageChannels)) return;
+
+      const user = interaction.options.getUser("user");
+      try {
+        await interaction.channel.permissionOverwrites.edit(user.id, {
+          ViewChannel: true,
+          SendMessages: true,
+        });
+      } catch (err) {
+        const embed = new EmbedBuilder().setColor(0xe74c3c).setDescription(`Failed to add user: ${err.message}`);
+        return interaction.reply({ embeds: [embed], ephemeral: true });
+      }
+
+      const embed = new EmbedBuilder()
+        .setColor(0x2ecc71)
+        .setDescription(`Added ${user} to this ticket.`);
+      return interaction.reply({ embeds: [embed], ephemeral: true });
+    }
+
+    if (sub === "remove") {
+      if (!requirePerms(interaction, PermissionFlagsBits.ManageChannels)) return;
+
+      const user = interaction.options.getUser("user");
+      try {
+        await interaction.channel.permissionOverwrites.delete(user.id);
+      } catch (err) {
+        const embed = new EmbedBuilder().setColor(0xe74c3c).setDescription(`Failed to remove user: ${err.message}`);
+        return interaction.reply({ embeds: [embed], ephemeral: true });
+      }
+
+      const embed = new EmbedBuilder()
+        .setColor(0xe67e22)
+        .setDescription(`Removed ${user} from this ticket.`);
+      return interaction.reply({ embeds: [embed], ephemeral: true });
+    }
+  },
+};

package/commands/timeout.js

@@ -0,0 +1,93 @@
+"use strict";
+
+const { EmbedBuilder, PermissionFlagsBits } = require("discord.js");
+const { requirePerms } = require("../lib/permissions");
+const { parseDuration } = require("../lib/parseDuration");
+const { dmActionUser } = require("../lib/dmUser");
+const { createCase, postCaseLog } = require("../lib/logCase");
+
+module.exports = {
+  data: {
+    name: "timeout",
+    description: "Timeout a member (e.g. 1h, 30m, 7d)",
+    options: [
+      { type: 6, name: "user", description: "The member to timeout", required: true },
+      { type: 3, name: "duration", description: "Duration (e.g. 30m, 1h, 7d — max 28d)", required: true },
+      { type: 3, name: "reason", description: "Reason for the timeout", required: false },
+    ],
+  },
+
+  async execute(interaction, ctx) {
+    if (!requirePerms(interaction, PermissionFlagsBits.ModerateMembers)) return;
+
+    const targetUser = interaction.options.getUser("user");
+    const durationStr = interaction.options.getString("duration");
+    const reason = interaction.options.getString("reason") || "No reason provided";
+    const guildId = interaction.guild.id;
+
+    const ms = parseDuration(durationStr);
+    if (!ms) {
+      const embed = new EmbedBuilder()
+        .setColor(0xe74c3c)
+        .setDescription("Invalid duration. Use formats like `30m`, `1h`, `7d`. Maximum is 28 days.");
+      return interaction.reply({ embeds: [embed], ephemeral: true });
+    }
+
+    const CaseModel = ctx.models.Case;
+    const configData = (await ctx.db.getPluginConfig(guildId, "adb-plugin-moderation"))?.data || {};
+
+    let member;
+    try {
+      member = await interaction.guild.members.fetch(targetUser.id);
+    } catch {
+      const embed = new EmbedBuilder().setColor(0xe74c3c).setDescription("That user is not in this server.");
+      return interaction.reply({ embeds: [embed], ephemeral: true });
+    }
+
+    if (!member.moderatable) {
+      const embed = new EmbedBuilder()
+        .setColor(0xe74c3c)
+        .setDescription("I cannot timeout that member (insufficient role hierarchy).");
+      return interaction.reply({ embeds: [embed], ephemeral: true });
+    }
+
+    if (configData.dm_on_action !== false) {
+      await dmActionUser(ctx.client, targetUser.id, {
+        action: "timed out",
+        guildName: interaction.guild.name,
+        reason,
+        duration: durationStr,
+      });
+    }
+
+    try {
+      await member.timeout(ms, reason);
+    } catch (err) {
+      const embed = new EmbedBuilder().setColor(0xe74c3c).setDescription(`Failed to timeout: ${err.message}`);
+      return interaction.reply({ embeds: [embed], ephemeral: true });
+    }
+
+    const caseDoc = await createCase(CaseModel, {
+      guildId,
+      type: "timeout",
+      targetId: targetUser.id,
+      moderatorId: interaction.user.id,
+      reason,
+      duration: durationStr,
+    });
+
+    await postCaseLog(ctx, configData, caseDoc, targetUser, interaction.user);
+
+    const embed = new EmbedBuilder()
+      .setColor(0xf39c12)
+      .setTitle(`Timed Out — Case #${caseDoc.caseNumber}`)
+      .addFields(
+        { name: "User", value: `${targetUser.tag} (${targetUser.id})`, inline: true },
+        { name: "Duration", value: durationStr, inline: true },
+        { name: "Reason", value: reason }
+      )
+      .setTimestamp();
+
+    await interaction.reply({ embeds: [embed], ephemeral: true });
+  },
+};

package/commands/unban.js

@@ -0,0 +1,62 @@
+"use strict";
+
+const { EmbedBuilder, PermissionFlagsBits } = require("discord.js");
+const { requirePerms } = require("../lib/permissions");
+const { createCase, postCaseLog } = require("../lib/logCase");
+
+module.exports = {
+  data: {
+    name: "unban",
+    description: "Unban a user by ID",
+    options: [
+      { type: 3, name: "user_id", description: "The user ID to unban", required: true },
+      { type: 3, name: "reason", description: "Reason for the unban", required: false },
+    ],
+  },
+
+  async execute(interaction, ctx) {
+    if (!requirePerms(interaction, PermissionFlagsBits.BanMembers)) return;
+
+    const userId = interaction.options.getString("user_id");
+    const reason = interaction.options.getString("reason") || "No reason provided";
+    const guildId = interaction.guild.id;
+
+    const CaseModel = ctx.models.Case;
+    const configData = (await ctx.db.getPluginConfig(guildId, "adb-plugin-moderation"))?.data || {};
+
+    let targetUser = null;
+    try {
+      targetUser = await ctx.client.users.fetch(userId);
+    } catch {
+      // May not be resolvable — continue
+    }
+
+    try {
+      await interaction.guild.bans.remove(userId, reason);
+    } catch (err) {
+      const embed = new EmbedBuilder().setColor(0xe74c3c).setDescription(`Failed to unban: ${err.message}`);
+      return interaction.reply({ embeds: [embed], ephemeral: true });
+    }
+
+    const caseDoc = await createCase(CaseModel, {
+      guildId,
+      type: "unban",
+      targetId: userId,
+      moderatorId: interaction.user.id,
+      reason,
+    });
+
+    await postCaseLog(ctx, configData, caseDoc, targetUser, interaction.user);
+
+    const embed = new EmbedBuilder()
+      .setColor(0x2ecc71)
+      .setTitle(`Unbanned — Case #${caseDoc.caseNumber}`)
+      .addFields(
+        { name: "User", value: targetUser ? `${targetUser.tag} (${userId})` : userId, inline: true },
+        { name: "Reason", value: reason }
+      )
+      .setTimestamp();
+
+    await interaction.reply({ embeds: [embed], ephemeral: true });
+  },
+};

package/commands/unlock.js

@@ -0,0 +1,36 @@
+"use strict";
+
+const { EmbedBuilder, PermissionFlagsBits } = require("discord.js");
+const { requirePerms } = require("../lib/permissions");
+
+module.exports = {
+  data: {
+    name: "unlock",
+    description: "Unlock a channel (restore @everyone send permission)",
+    options: [
+      { type: 7, name: "channel", description: "Channel to unlock (defaults to current)", required: false },
+    ],
+  },
+
+  async execute(interaction, ctx) {
+    if (!requirePerms(interaction, PermissionFlagsBits.ManageChannels)) return;
+
+    const target = interaction.options.getChannel("channel") || interaction.channel;
+
+    try {
+      await target.permissionOverwrites.edit(interaction.guild.roles.everyone, {
+        SendMessages: null, // Reset to role default
+      });
+    } catch (err) {
+      const embed = new EmbedBuilder().setColor(0xe74c3c).setDescription(`Failed to unlock channel: ${err.message}`);
+      return interaction.reply({ embeds: [embed], ephemeral: true });
+    }
+
+    const embed = new EmbedBuilder()
+      .setColor(0x2ecc71)
+      .setDescription(`${target} has been **unlocked**. Members can send messages again.`)
+      .setTimestamp();
+
+    await interaction.reply({ embeds: [embed], ephemeral: true });
+  },
+};

package/commands/untimeout.js

@@ -0,0 +1,63 @@
+"use strict";
+
+const { EmbedBuilder, PermissionFlagsBits } = require("discord.js");
+const { requirePerms } = require("../lib/permissions");
+const { createCase, postCaseLog } = require("../lib/logCase");
+
+module.exports = {
+  data: {
+    name: "untimeout",
+    description: "Remove a timeout from a member",
+    options: [
+      { type: 6, name: "user", description: "The member to untimeout", required: true },
+      { type: 3, name: "reason", description: "Reason", required: false },
+    ],
+  },
+
+  async execute(interaction, ctx) {
+    if (!requirePerms(interaction, PermissionFlagsBits.ModerateMembers)) return;
+
+    const targetUser = interaction.options.getUser("user");
+    const reason = interaction.options.getString("reason") || "No reason provided";
+    const guildId = interaction.guild.id;
+
+    const CaseModel = ctx.models.Case;
+    const configData = (await ctx.db.getPluginConfig(guildId, "adb-plugin-moderation"))?.data || {};
+
+    let member;
+    try {
+      member = await interaction.guild.members.fetch(targetUser.id);
+    } catch {
+      const embed = new EmbedBuilder().setColor(0xe74c3c).setDescription("That user is not in this server.");
+      return interaction.reply({ embeds: [embed], ephemeral: true });
+    }
+
+    try {
+      await member.timeout(null, reason);
+    } catch (err) {
+      const embed = new EmbedBuilder().setColor(0xe74c3c).setDescription(`Failed to remove timeout: ${err.message}`);
+      return interaction.reply({ embeds: [embed], ephemeral: true });
+    }
+
+    const caseDoc = await createCase(CaseModel, {
+      guildId,
+      type: "untimeout",
+      targetId: targetUser.id,
+      moderatorId: interaction.user.id,
+      reason,
+    });
+
+    await postCaseLog(ctx, configData, caseDoc, targetUser, interaction.user);
+
+    const embed = new EmbedBuilder()
+      .setColor(0x3498db)
+      .setTitle(`Timeout Removed — Case #${caseDoc.caseNumber}`)
+      .addFields(
+        { name: "User", value: `${targetUser.tag} (${targetUser.id})`, inline: true },
+        { name: "Reason", value: reason }
+      )
+      .setTimestamp();
+
+    await interaction.reply({ embeds: [embed], ephemeral: true });
+  },
+};

package/commands/warn.js

@@ -0,0 +1,75 @@
+"use strict";
+
+const { EmbedBuilder, PermissionFlagsBits } = require("discord.js");
+const { requirePerms } = require("../lib/permissions");
+const { dmActionUser } = require("../lib/dmUser");
+const { createCase, postCaseLog } = require("../lib/logCase");
+const { checkWarnThresholds } = require("../lib/checkThresholds");
+
+module.exports = {
+  data: {
+    name: "warn",
+    description: "Warn a member",
+    options: [
+      { type: 6, name: "user", description: "The member to warn", required: true },
+      { type: 3, name: "reason", description: "Reason for the warning", required: true },
+    ],
+  },
+
+  async execute(interaction, ctx) {
+    if (!requirePerms(interaction, PermissionFlagsBits.ManageMessages)) return;
+
+    const targetUser = interaction.options.getUser("user");
+    const reason = interaction.options.getString("reason");
+    const guildId = interaction.guild.id;
+
+    const CaseModel = ctx.models.Case;
+    const configData = (await ctx.db.getPluginConfig(guildId, "adb-plugin-moderation"))?.data || {};
+
+    const caseDoc = await createCase(CaseModel, {
+      guildId,
+      type: "warn",
+      targetId: targetUser.id,
+      moderatorId: interaction.user.id,
+      reason,
+    });
+
+    // Increment warning counter in user profile
+    const profile = await ctx.db.getUserProfile(targetUser.id, guildId);
+    const newWarnings = (profile.warnings || 0) + 1;
+    await ctx.db.updateUserProfile(targetUser.id, guildId, { warnings: newWarnings });
+
+    if (configData.dm_on_action !== false) {
+      await dmActionUser(ctx.client, targetUser.id, {
+        action: "warned",
+        guildName: interaction.guild.name,
+        reason,
+      });
+    }
+
+    await postCaseLog(ctx, configData, caseDoc, targetUser, interaction.user);
+
+    const embed = new EmbedBuilder()
+      .setColor(0xf1c40f)
+      .setTitle(`Warned — Case #${caseDoc.caseNumber}`)
+      .addFields(
+        { name: "User", value: `${targetUser.tag} (${targetUser.id})`, inline: true },
+        { name: "Total Warnings", value: String(newWarnings), inline: true },
+        { name: "Reason", value: reason }
+      )
+      .setTimestamp();
+
+    await interaction.reply({ embeds: [embed], ephemeral: true });
+
+    // Check thresholds AFTER replying so auto-actions don't block the response
+    await checkWarnThresholds(
+      ctx,
+      interaction,
+      CaseModel,
+      targetUser.id,
+      guildId,
+      newWarnings,
+      configData.warn_thresholds
+    );
+  },
+};

package/commands/warnings.js

@@ -0,0 +1,45 @@
+"use strict";
+
+const { EmbedBuilder, PermissionFlagsBits } = require("discord.js");
+const { requirePerms } = require("../lib/permissions");
+
+module.exports = {
+  data: {
+    name: "warnings",
+    description: "View warnings for a member",
+    options: [
+      { type: 6, name: "user", description: "The member to check", required: true },
+    ],
+  },
+
+  async execute(interaction, ctx) {
+    if (!requirePerms(interaction, PermissionFlagsBits.ManageMessages)) return;
+
+    const targetUser = interaction.options.getUser("user");
+    const guildId = interaction.guild.id;
+    const CaseModel = ctx.models.Case;
+
+    const warns = await CaseModel.find({ guildId, targetUserId: targetUser.id, type: "warn" })
+      .sort({ createdAt: -1 })
+      .limit(25)
+      .lean();
+
+    const embed = new EmbedBuilder()
+      .setColor(0xf1c40f)
+      .setTitle(`Warnings for ${targetUser.tag}`)
+      .setDescription(
+        warns.length === 0
+          ? "No warnings on record."
+          : warns
+              .map(
+                (w) =>
+                  `**Case #${w.caseNumber}** — <t:${Math.floor(new Date(w.createdAt).getTime() / 1000)}:R>\n${w.reason}`
+              )
+              .join("\n\n")
+      )
+      .setFooter({ text: `Total: ${warns.length} warning(s)` })
+      .setTimestamp();
+
+    await interaction.reply({ embeds: [embed], ephemeral: true });
+  },
+};