adb-plugin-moderation 1.0.0

package/index.js

@@ -0,0 +1,56 @@
+"use strict";
+
+const CaseSchema = require("./models/case");
+const NoteSchema = require("./models/note");
+const TicketSchema = require("./models/ticket");
+
+const commands = [
+  require("./commands/ban"),
+  require("./commands/unban"),
+  require("./commands/kick"),
+  require("./commands/timeout"),
+  require("./commands/untimeout"),
+  require("./commands/warn"),
+  require("./commands/warnings"),
+  require("./commands/clearwarnings"),
+  require("./commands/note"),
+  require("./commands/purge"),
+  require("./commands/slowmode"),
+  require("./commands/lock"),
+  require("./commands/unlock"),
+  require("./commands/case"),
+  require("./commands/history"),
+  require("./commands/modstats"),
+  require("./commands/ticket"),
+];
+
+/**
+ * Plugin entry point called by the ADB plugin loader.
+ * @param {object} ctx — plugin context
+ */
+async function load(ctx) {
+  // Define mongoose models (namespaced internally by ADB)
+  const CaseModel = ctx.defineModel("Case", CaseSchema);
+  const NoteModel = ctx.defineModel("Note", NoteSchema);
+  const TicketModel = ctx.defineModel("Ticket", TicketSchema);
+
+  // Attach models to ctx so commands can access them via ctx.models
+  ctx.models = { Case: CaseModel, Note: NoteModel, Ticket: TicketModel };
+
+  // Register all slash commands
+  for (const cmd of commands) {
+    ctx.registerCommand({
+      data: cmd.data,
+      execute: (interaction) => cmd.execute(interaction, ctx),
+    });
+  }
+
+  // Cleanup hook
+  ctx.hooks.on("onPluginUnload", () => {
+    ctx.logger.info("[moderation] Plugin unloaded.");
+  });
+
+  ctx.logger.info("[moderation] Moderation plugin loaded — registered " + commands.length + " commands.");
+}
+
+module.exports = { load };

package/lib/checkThresholds.js

@@ -0,0 +1,80 @@
+"use strict";
+
+const { parseDuration } = require("./parseDuration");
+const { dmActionUser } = require("./dmUser");
+const { createCase, postCaseLog } = require("./logCase");
+
+/**
+ * Apply an automatic action if the warning count hits a configured threshold.
+ *
+ * @param {object} ctx
+ * @param {import("discord.js").ChatInputCommandInteraction} interaction
+ * @param {import("mongoose").Model} CaseModel
+ * @param {string} userId
+ * @param {string} guildId
+ * @param {number} warningCount
+ * @param {object} thresholds — map of "N": { action, duration? }
+ */
+async function checkWarnThresholds(ctx, interaction, CaseModel, userId, guildId, warningCount, thresholds) {
+  if (!thresholds) return;
+
+  const threshold = thresholds[String(warningCount)];
+  if (!threshold) return;
+
+  const { action, duration: durationStr } = threshold;
+  const guild = interaction.guild;
+  const configData = (await ctx.db.getPluginConfig(guildId, "adb-plugin-moderation"))?.data || {};
+
+  let member;
+  try {
+    member = await guild.members.fetch(userId);
+  } catch {
+    return; // Member may have left
+  }
+
+  const reason = `Auto-action: ${warningCount} warnings reached`;
+
+  try {
+    if (action === "ban") {
+      await dmActionUser(ctx.client, userId, { action: "banned", guildName: guild.name, reason });
+      await member.ban({ reason });
+      const caseDoc = await createCase(CaseModel, {
+        guildId,
+        type: "ban",
+        targetId: userId,
+        moderatorId: ctx.client.user.id,
+        reason,
+      });
+      await postCaseLog(ctx, configData, caseDoc, await ctx.client.users.fetch(userId).catch(() => null), ctx.client.user);
+    } else if (action === "kick") {
+      await dmActionUser(ctx.client, userId, { action: "kicked", guildName: guild.name, reason });
+      await member.kick(reason);
+      const caseDoc = await createCase(CaseModel, {
+        guildId,
+        type: "kick",
+        targetId: userId,
+        moderatorId: ctx.client.user.id,
+        reason,
+      });
+      await postCaseLog(ctx, configData, caseDoc, await ctx.client.users.fetch(userId).catch(() => null), ctx.client.user);
+    } else if (action === "timeout") {
+      const ms = durationStr ? parseDuration(durationStr) : 3600000;
+      if (!ms) return;
+      await member.timeout(ms, reason);
+      await dmActionUser(ctx.client, userId, { action: "timed out", guildName: guild.name, reason, duration: durationStr });
+      const caseDoc = await createCase(CaseModel, {
+        guildId,
+        type: "timeout",
+        targetId: userId,
+        moderatorId: ctx.client.user.id,
+        reason,
+        duration: durationStr,
+      });
+      await postCaseLog(ctx, configData, caseDoc, await ctx.client.users.fetch(userId).catch(() => null), ctx.client.user);
+    }
+  } catch (err) {
+    ctx.logger.warn(`[moderation] Auto-threshold action failed: ${err.message}`);
+  }
+}
+
+module.exports = { checkWarnThresholds };

package/lib/dmUser.js

@@ -0,0 +1,31 @@
+"use strict";
+
+const { EmbedBuilder } = require("discord.js");
+
+/**
+ * DM a user about a moderation action. Silently swallows failures.
+ * @param {import("discord.js").Client} client
+ * @param {string} userId
+ * @param {{ action: string, guildName: string, reason?: string, duration?: string }} opts
+ */
+async function dmActionUser(client, userId, { action, guildName, reason, duration }) {
+  try {
+    const user = await client.users.fetch(userId);
+    const desc = duration
+      ? `You have been **${action}** from **${guildName}** for **${duration}**.`
+      : `You have been **${action}** from **${guildName}**.`;
+
+    const embed = new EmbedBuilder()
+      .setColor(0xe67e22)
+      .setTitle(`Moderation Action — ${action.charAt(0).toUpperCase() + action.slice(1)}`)
+      .setDescription(desc)
+      .addFields({ name: "Reason", value: reason || "No reason provided" })
+      .setTimestamp();
+
+    await user.send({ embeds: [embed] });
+  } catch {
+    // Silently ignore — user may have DMs closed or bot cannot reach them
+  }
+}
+
+module.exports = { dmActionUser };

package/lib/logCase.js

@@ -0,0 +1,82 @@
+"use strict";
+
+const { EmbedBuilder } = require("discord.js");
+
+const TYPE_COLORS = {
+  ban: 0xe74c3c,
+  unban: 0x2ecc71,
+  kick: 0xe67e22,
+  timeout: 0xf39c12,
+  untimeout: 0x3498db,
+  warn: 0xf1c40f,
+  note: 0x95a5a6,
+};
+
+/**
+ * Create a new moderation case document and save it.
+ * Case numbers are per-guild, starting from 1.
+ *
+ * @param {import("mongoose").Model} CaseModel
+ * @param {{ guildId: string, type: string, targetId: string, moderatorId: string, reason?: string, duration?: string }} opts
+ * @returns {Promise<object>} Saved case document
+ */
+async function createCase(CaseModel, { guildId, type, targetId, moderatorId, reason, duration }) {
+  const last = await CaseModel.findOne({ guildId }).sort({ caseNumber: -1 }).select("caseNumber").lean();
+  const caseNumber = last ? last.caseNumber + 1 : 1;
+
+  const doc = new CaseModel({
+    guildId,
+    caseNumber,
+    type,
+    targetUserId: targetId,
+    moderatorId,
+    reason: reason || "No reason provided",
+    duration: duration || null,
+  });
+
+  await doc.save();
+  return doc;
+}
+
+/**
+ * Post a case embed to the configured log channel.
+ *
+ * @param {object} ctx — plugin context
+ * @param {object} configData — guild plugin config data
+ * @param {object} caseDoc — saved case document
+ * @param {import("discord.js").User|null} targetUser
+ * @param {import("discord.js").User|null} moderator
+ */
+async function postCaseLog(ctx, configData, caseDoc, targetUser, moderator) {
+  const logChannelId = configData && configData.log_channel_id;
+  if (!logChannelId) return;
+
+  try {
+    const channel = await ctx.client.channels.fetch(logChannelId);
+    if (!channel || !channel.isTextBased()) return;
+
+    const color = TYPE_COLORS[caseDoc.type] || 0x99aab5;
+    const targetName = targetUser ? `${targetUser.tag} (${targetUser.id})` : caseDoc.targetUserId;
+    const modName = moderator ? `${moderator.tag} (${moderator.id})` : caseDoc.moderatorId;
+
+    const embed = new EmbedBuilder()
+      .setColor(color)
+      .setTitle(`Case #${caseDoc.caseNumber} — ${caseDoc.type.toUpperCase()}`)
+      .addFields(
+        { name: "Target", value: targetName, inline: true },
+        { name: "Moderator", value: modName, inline: true },
+        { name: "Reason", value: caseDoc.reason || "No reason provided" }
+      )
+      .setTimestamp(caseDoc.createdAt);
+
+    if (caseDoc.duration) {
+      embed.addFields({ name: "Duration", value: caseDoc.duration, inline: true });
+    }
+
+    await channel.send({ embeds: [embed] });
+  } catch (err) {
+    ctx.logger.warn(`[moderation] Failed to post case log: ${err.message}`);
+  }
+}
+
+module.exports = { createCase, postCaseLog };

package/lib/parseDuration.js

@@ -0,0 +1,31 @@
+"use strict";
+
+const MAX_MS = 2419200000; // 28 days
+
+const UNITS = {
+  s: 1000,
+  m: 60 * 1000,
+  h: 60 * 60 * 1000,
+  d: 24 * 60 * 60 * 1000,
+};
+
+/**
+ * Parse a human-readable duration string to milliseconds.
+ * Accepts: 30s, 1m, 30m, 1h, 12h, 1d, 7d, 28d
+ * Returns null if invalid or exceeds 28 days.
+ * @param {string} str
+ * @returns {number|null}
+ */
+function parseDuration(str) {
+  if (typeof str !== "string") return null;
+  const match = str.trim().match(/^(\d+)([smhd])$/i);
+  if (!match) return null;
+  const amount = parseInt(match[1], 10);
+  const unit = match[2].toLowerCase();
+  if (!UNITS[unit]) return null;
+  const ms = amount * UNITS[unit];
+  if (ms <= 0 || ms > MAX_MS) return null;
+  return ms;
+}
+
+module.exports = { parseDuration };

package/lib/permissions.js

@@ -0,0 +1,33 @@
+"use strict";
+
+const { PermissionFlagsBits, EmbedBuilder } = require("discord.js");
+
+/**
+ * Check that interaction.member has all listed permissions.
+ * Replies with an ephemeral error embed if not. Returns true/false.
+ * @param {import("discord.js").ChatInputCommandInteraction} interaction
+ * @param {...bigint} perms — PermissionFlagsBits values
+ * @returns {boolean}
+ */
+function requirePerms(interaction, ...perms) {
+  const member = interaction.member;
+  const missing = perms.filter((p) => !member.permissions.has(p));
+  if (missing.length === 0) return true;
+
+  const names = missing
+    .map((p) => {
+      const entry = Object.entries(PermissionFlagsBits).find(([, v]) => v === p);
+      return entry ? entry[0] : String(p);
+    })
+    .join(", ");
+
+  const embed = new EmbedBuilder()
+    .setColor(0xe74c3c)
+    .setTitle("Missing Permissions")
+    .setDescription(`You need the following permissions: **${names}**`);
+
+  interaction.reply({ embeds: [embed], ephemeral: true }).catch(() => {});
+  return false;
+}
+
+module.exports = { requirePerms };

package/models/case.js

@@ -0,0 +1,21 @@
+"use strict";
+
+const { Schema } = require("mongoose");
+
+const CaseSchema = new Schema({
+  guildId: { type: String, required: true, index: true },
+  caseNumber: { type: Number, required: true },
+  type: {
+    type: String,
+    enum: ["ban", "unban", "kick", "timeout", "untimeout", "warn", "note"],
+    required: true,
+  },
+  targetUserId: { type: String, required: true },
+  moderatorId: { type: String, required: true },
+  reason: { type: String, default: "No reason provided" },
+  duration: { type: String, default: null },
+  active: { type: Boolean, default: true },
+  createdAt: { type: Date, default: Date.now },
+});
+
+module.exports = CaseSchema;

package/models/note.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const { Schema } = require("mongoose");
+
+const NoteSchema = new Schema({
+  guildId: { type: String, required: true, index: true },
+  userId: { type: String, required: true },
+  moderatorId: { type: String, required: true },
+  note: { type: String, required: true },
+  createdAt: { type: Date, default: Date.now },
+});
+
+module.exports = NoteSchema;

package/models/ticket.js

@@ -0,0 +1,15 @@
+"use strict";
+
+const { Schema } = require("mongoose");
+
+const TicketSchema = new Schema({
+  guildId: { type: String, required: true, index: true },
+  channelId: { type: String, required: true, unique: true },
+  userId: { type: String, required: true },
+  reason: { type: String, default: "" },
+  status: { type: String, enum: ["open", "closed"], default: "open" },
+  createdAt: { type: Date, default: Date.now },
+  closedAt: { type: Date, default: null },
+});
+
+module.exports = TicketSchema;

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "adb-plugin-moderation",
+  "version": "1.0.0",
+  "description": "Core moderation commands for Advanced Discord Bot",
+  "main": "index.js",
+  "files": ["index.js", "plugin.json", "commands", "models", "lib", "README.md", "LICENSE"],
+  "scripts": { "test": "node test/local-harness.js" },
+  "keywords": ["adb-plugin", "discord", "moderation"],
+  "author": "dead",
+  "license": "MIT",
+  "peerDependencies": { "discord.js": ">=14.0.0", "mongoose": ">=7.0.0" },
+  "devDependencies": { "mongoose": "^8.0.0" }
+}

package/plugin.json

@@ -0,0 +1,29 @@
+{
+  "name": "adb-plugin-moderation",
+  "displayName": "Basic Moderation",
+  "version": "1.0.0",
+  "description": "Core moderation commands: ban, kick, timeout, warn, purge, tickets, and case logging.",
+  "author": "dead",
+  "main": "index.js",
+  "requiresRestart": true,
+  "permissions": ["db.read", "db.write", "commands.register"],
+  "configSchema": {
+    "type": "object",
+    "properties": {
+      "log_channel_id": { "type": "string", "default": null },
+      "ticket_category_id": { "type": "string", "default": null },
+      "ticket_support_role_id": { "type": "string", "default": null },
+      "ticket_log_channel_id": { "type": "string", "default": null },
+      "warn_thresholds": {
+        "type": "object",
+        "default": {
+          "3": { "action": "timeout", "duration": "1h" },
+          "5": { "action": "timeout", "duration": "24h" },
+          "7": { "action": "kick" },
+          "10": { "action": "ban" }
+        }
+      },
+      "dm_on_action": { "type": "boolean", "default": true }
+    }
+  }
+}