diff --git a/.eslintignore b/.eslintignore
index fc767ef5..0c08df53 100644
--- a/.eslintignore
+++ b/.eslintignore
@@ -22,7 +22,6 @@ commands/manualVerify.js
 commands/manualVetVerify.js
 commands/memes.js
 commands/modmailBlacklist.js
-commands/mute.js
 commands/parsemembers.js
 commands/permaSuspend.js
 commands/poll.js
@@ -44,7 +43,6 @@ commands/suspendremove.js
 commands/sysinfo.js
 commands/test.js
 commands/unlock.js
-commands/unmute.js
 commands/unverify.js
 commands/unvetverify.js
 commands/updateIP.js
diff --git a/commands/mute.js b/commands/mute.js
index 23084439..18e0008c 100644
--- a/commands/mute.js
+++ b/commands/mute.js
@@ -1,96 +1,268 @@
-const Discord = require('discord.js')
-const ErrorLogger = require('../lib/logError')
-const fs = require('fs')
+const { EmbedBuilder, Colors } = require('discord.js');
+const moment = require('moment');
 const SlashArgType = require('discord-api-types/v10').ApplicationCommandOptionType;
-const { slashArg, slashChoices, slashCommandJSON } = require('../utils.js')
+const { slashArg, slashCommandJSON } = require('../utils.js');
+
+/**
+ * @typedef MuteRow
+ * @property {string} id
+ * @property {string} modid
+ * @property {string} guildid
+ * @property {string} reason
+ * @property {number} appliedOn
+ * @property {number} duration
+ * @property {number?} removedOn
+ * @property {string?} removedBy
+ * @property {string?} removeReason
+ * @property {boolean} overwritten
+ */
+
+/**
+ * @param {MuteRow} row
+ * @param {import('discord.js').GuildMember} member
+ * @param {number?} duration
+ */
+async function attemptOverwrite(db, row, member, reason) {
+    await db.promise().query('UPDATE mutes SET removedOn = unix_timestamp(), removedBy = ?, removeReason = ?, overwritten = true WHERE id = ? AND guildid = ? AND removedOn IS NULL',
+        [member.id, reason, row.id, row.guildid]);
+}
+
+function durationString(duration, when = Date.unix()) {
+    if (!duration) return 'Permanent';
+    duration = parseInt(duration);
+    when = parseInt(when);
+    return `Ending <t:${when + duration}:R>\nAt <t:${when + duration}:f>`;
+}
+
+/**
+ *
+ * @param {string} duration
+ * @param {number} time
+ */
+function processDuration(duration, time) {
+    duration = duration.toLowerCase();
+    if (duration.startsWith('mo')) return time * 2_592_000;
+    switch (duration[0]) {
+        case 's': return time;
+        case 'm': return time * 60;
+        case 'h': return time * 3_600;
+        case 'd': return time * 86_400;
+        case 'w': return time * 604_800;
+        case 'y': return time * 31_536_000;
+        default:
+    }
+}
+
+/**
+ * @param {import('../utils.js').BotCommandInteraction} interaction
+ * @param {MuteRow} row
+ * @returns {{
+ *  overwrite: boolean;
+ *  mute: boolean
+ * }}
+*/
+async function confirmOverwrite(interaction, member, row, duration, reason) {
+    const mod = interaction.guild.members.cache.get(row.modid);
+    const embed = new EmbedBuilder()
+        .setAuthor({ name: member.displayName, iconURL: member.displayAvatarURL() })
+        .setTitle('Confirm Mute Override')
+        .setDescription(`<@${row.id}> currently has an active mute. Do you want to override this mute?`)
+        .setColor(Colors.Blue)
+        .setTimestamp()
+        .addFields({ name: 'Old Moderator', value: mod ? `${mod} \`${mod.displayName}\`` : `<@${row.modid}>`, inline: true },
+            { name: 'Applied On', value: `<t:${row.appliedOn}:f>`, inline: true },
+            { name: 'Old Expires', value: durationString(row.duration, row.appliedOn), inline: true },
+            { name: 'Old Reason', value: row.reason },
+            { name: 'New Moderator', value: `${interaction.member} \`${interaction.member.displayName}\``, inline: true },
+            { name: 'New Expires', value: durationString(duration), inline: true },
+            { name: 'New Reason', value: reason });
+
+    const message = await interaction.editReply({ embeds: [embed], fetchReply: true });
+    return await message.confirmButton(interaction.member.id);
+}
+
+/**
+ * @param {import('../utils.js').BotCommandInteraction} interaction
+ * @param {import('discord.js').GuildMember} member
+ */
+async function confirmUnmanagedMute(interaction, member, duration, reason) {
+    const embed = new EmbedBuilder()
+        .setAuthor({ name: member.displayName, iconURL: member.displayAvatarURL() })
+        .setTitle('Unmanaged Mute')
+        .setDescription(`${member} has a mute currently not managed by ${interaction.client.user}. Would you like to have it managed with the following information?`)
+        .setColor(Colors.Blue)
+        .addFields({ name: 'Member', value: `${member} \`${member.displayName}\``, inline: true },
+            { name: 'Moderator', value: `${interaction.member} \`${interaction.member.displayName}\``, inline: true },
+            { name: 'Expires', value: durationString(duration), inline: true },
+            { name: 'Reason', value: reason });
+
+    const message = await interaction.editReply({ embeds: [embed], fetchReply: true });
+    return await message.confirmButton(interaction.member.id);
+}
 
 module.exports = {
     name: 'mute',
     description: 'Gives user the muted role',
-    args: '<member> <time> <time type s/m/h/d/w/y> <Reason>',
     role: 'security',
-    varargs: true,
-    requiredArgs: 4,
+    slashOnlyArgsProcessing: true,
     args: [
-        slashArg(SlashArgType.User, 'member', {
-            description: "Member in the Server"
+        slashArg(SlashArgType.Subcommand, 'temporary', {
+            description: 'Temporarily mute member',
+            options: [
+                slashArg(SlashArgType.User, 'member', {
+                    description: 'Server member to mute'
+                }),
+                slashArg(SlashArgType.Integer, 'time', {
+                    description: 'The amount of time for the mute'
+                }),
+                slashArg(SlashArgType.String, 'duration', {
+                    description: 'The type of duration for the mute'
+                }),
+                slashArg(SlashArgType.String, 'reason', {
+                    description: 'The reason for the permanent mute'
+                })
+            ]
         }),
-        slashArg(SlashArgType.Integer, 'time', {
-            required: false,
-            description: "Quantity of Time"
-        }),
-        slashArg(SlashArgType.String, 'timetype', {
-            required: false,
-            description: "Time Type[s/m/h/d/w/y]"
-        }),
-        slashArg(SlashArgType.String, 'reason', {
-            required: false,
-            description: "Reason for mute"
+        slashArg(SlashArgType.Subcommand, 'permanent', {
+            description: 'Permanently mute member',
+            options: [
+                slashArg(SlashArgType.User, 'member', {
+                    description: 'Server member to mute'
+                }),
+                slashArg(SlashArgType.String, 'reason', {
+                    description: 'The reason for the permanent mute'
+                })
+            ]
         }),
     ],
     getSlashCommandData(guild) {
-        return slashCommandJSON(this, guild)
+        return slashCommandJSON(this, guild);
     },
-    async execute(message, args, bot, db) {
-        let settings = bot.settings[message.guild.id]
-        const memberSearch = args.shift();
-        let member = message.guild.members.cache.get(memberSearch);
-        if (!member) member = message.guild.members.cache.filter(user => user.nickname != null).find(nick => nick.nickname.replace(/[^a-z|]/gi, '').toLowerCase().split('|').includes(memberSearch.toLowerCase()));
-        if (!member) member = message.guild.members.cache.get(memberSearch.replace(/\D/gi, ''))
-        if (!member) { message.reply('User not found. Please try again'); return; }
-        if (member.roles.highest.position >= message.member.roles.highest.position) return message.reply(`${member} has a role greater than or equal to you and cannot be muted`);
-        let muted = settings.roles.muted
-        if (member.roles.cache.has(muted)) return message.reply(`${member} is already muted`)
-        if (args.length == 1) {
-            await member.roles.add(muted).catch(er => ErrorLogger.log(er, bot, message.guild))
-            await message.reply(`${member} has been muted indefinitely`)
-            return;
+    getNotes() {
+        return { title: 'Chat Command Args', value: '<user> <\'permanent\' | <time> <duration>> <reason>\n\nDuration should be either s(econds), m(inutes), h(ours), d(ays), w(eeks), mo(nths), y(ears)' };
+    },
+    /**
+     * @param {import('../utils.js').BotCommandInteraction?} interaction
+     * @param {import('discord.js').GuildMember} member
+     * @param {number?} duration
+     * @param {string} reason
+     * @param {MuteRow?} row - Row to overwrite
+     */
+    async mute(settings, db, interaction, member, duration, reason, row) {
+        const moderator = interaction?.member || member.client.user;
+        const endTime = Date.now() + duration;
+
+        const embed = new EmbedBuilder()
+            .setAuthor({ name: member.displayName, iconURL: member.displayAvatarURL() })
+            .setTitle('Mute Information')
+            .setDescription(`The mute is ${duration ? 'for ' + moment.duration(duration * 1000).humanize(false) : 'permanent'}`)
+            .setFooter({ text: moderator.displayName, iconURL: moderator.displayAvatarURL() })
+            .setColor(Colors.Green)
+            .setTimestamp(endTime)
+            .addFields({ name: 'Member', value: `${member} \`${member.displayName}\``, inline: true },
+                { name: 'Moderator', value: `${moderator} \`${moderator.displayName}\``, inline: true },
+                { name: 'Expires', value: durationString(duration), inline: true },
+                { name: 'Reason', value: reason });
+
+        if (row) {
+            await attemptOverwrite(db, row, moderator, reason);
+            const mod = member.guild.members.cache.get(row.modid);
+            embed.addFields({ name: 'Overwrote Mute', value: '\u000B' },
+                { name: 'Old Moderator', value: mod ? `${mod} \`${mod.displayName}\`` : `<@${row.modid}>`, inline: true },
+                { name: 'Applied On', value: `<t:${row.appliedOn}:f>`, inline: true },
+                { name: 'Old Expires', value: durationString(row.duration, row.appliedOn), inline: true },
+                { name: 'Old Reason', value: row.reason });
         }
-        let time = parseInt(args.shift())
-        let timeType = args.shift()
-        if (!timeType) return message.channel.send("Please enter a valid time type __**d**__ay, __**m**__inute, __**h**__our, __**s**__econd, __**w**__eek, __**y**__ear");
-        let reason = args.join(' ');
-        switch (timeType.charAt(0).toLowerCase()) {
-            case 's': millisecondTime = time * 1000; timeDuration = 'second(s)'; break;
-            case 'm': millisecondTime = time * 60000; timeDuration = 'minute(s)'; break;
-            case 'h': millisecondTime = time * 3600000; timeDuration = 'hour(s)'; break;
-            case 'd': millisecondTime = time * 86400000; timeDuration = 'day(s)'; break;
-            case 'w': millisecondTime = time * 604800000; timeDuration = 'week(s)'; break;
-            case 'y': millisecondTime = time * 31536000000; timeDuration = 'year(s)'; break;
-            default: return message.channel.send("Please enter a valid time type __**s**__econd, __**m**__inute, __**h**__our, __**d**__ay, __**w**__eek, __**y**__ear");
+        if (reason.length > 1024) reason = reason.substring(0, 1021) + '...';
+        await db.promise().query('INSERT INTO mutes (id, modid, guildid, reason, duration) VALUES (?, ?, ?, ?, ?)', [member.id, moderator.id, member.guild.id, reason, duration || 0])
+            .catch(console.log);
+        member.roles.add(settings.roles.muted);
+
+        if (interaction) {
+            const message = await interaction.fetchReply();
+            if (!message) await interaction.reply({ embeds: [embed] });
+            else await interaction.editReply({ embeds: [embed], components: [] });
         }
-        async function muteProcess(overwrite) {
-            const modlogs = message.guild.channels.cache.get(settings.channels.modlogs);
-            let embed = new Discord.EmbedBuilder()
-                .setColor('#ff0000')
-                .setTitle('Mute Information')
-                .setDescription(`You have been muted in the ${message.guild.name} discord. The mute is for ${time} ${timeDuration} until <t:${(((Date.now() + millisecondTime) / 1000)).toFixed(0)}:f>`)
-                .addFields([{name: `User Information \`${member.nickname}\``, value: `<@!${member.id}> `, inline: true}])
-                .addFields([{name: `Mod Information \`${message.guild.members.cache.get(message.author.id).nickname}\``, value: `<@!${message.author.id}> `, inline: true}])
-                .addFields([{name: `Reason:`, value: reason}])
-                .setFooter({ text: `Unmuting at ` })
-                .setTimestamp(Date.now() + millisecondTime);
-                (member.user.send({ embeds: [embed] }).catch(() => {}));
-            } 
-        async function muteProcesslog(overwrite) {
-            const modlogs = message.guild.channels.cache.get(settings.channels.modlogs);
-            let embed = new Discord.EmbedBuilder()
-                .setColor('#ff0000')
-                .setTitle('Mute Information')
-                .setDescription(`The mute is for ${time} ${timeDuration} until <t:${(((Date.now() + millisecondTime) / 1000)).toFixed(0)}:f>`)
-                .addFields([{name: `User Information \`${member.nickname}\``, value: `<@!${member.id}> `, inline: true}])
-                .addFields([{name: `Mod Information \`${message.guild.members.cache.get(message.author.id).nickname}\``, value: `<@!${message.author.id}> `, inline: true}])
-                .addFields([{name: `Reason:`, value: reason}])
-                .setFooter({ text: `Unmuting at ` })
-                .setTimestamp(Date.now() + millisecondTime);
-            modlogs.send({ embeds: [embed] });
-            }           
-        db.query(`INSERT INTO mutes (id, guildid, muted, reason, modid, uTime) VALUES ('${member.id}', '${message.guild.id}', true, '${reason || 'None Provided'}','${message.author.id}', '${Date.now() + millisecondTime}')`, err => {
-            member.roles.add(muted).catch(er => ErrorLogger.log(er, bot, message.guild))
-            message.reply(`${member} has been muted`);
-            muteProcess();
-            muteProcesslog();
-            
-        })
+        await member.guild.channels.cache.get(settings.channels.modlogs)?.send({ embeds: [embed] });
+
+        embed.setColor(Colors.Red).setDescription(`You have been muted in the ${member.guild.name} discord. The mute is ${duration ? 'for ' + moment.duration(duration * 1000).humanize(false) : 'permanent'}`);
+        const dm = await member.createDM().catch(() => {});
+        await dm?.send({ embeds: [embed] }).catch(() => {});
+    },
+    async processExecute(interaction, settings, db, member, reason, duration) {
+        const embed = new EmbedBuilder()
+            .setAuthor({ name: member.displayName, iconURL: member.displayAvatarURL() })
+            .setColor(Colors.Blue)
+            .setTimestamp()
+            .setFooter({ text: `${interaction.member.displayName}`, iconURL: interaction.member.displayAvatarURL() })
+            .setTitle('Processing Mute')
+            .setDescription('Please wait...');
+
+        await interaction.reply({ embeds: [embed] });
+
+        if (member.roles.highest.position >= interaction.member.roles.highest.position) {
+            embed.setColor(Colors.Red)
+                .setDescription(`${member} has a role greater than or equal to your own and you cannot mute them.`);
+            return await interaction.editReply({ embeds: [embed] });
+        }
+
+        const [rows] = await db.promise().query('SELECT * FROM mutes WHERE id = ? AND guildid = ? AND removedOn IS NULL', [member.id, member.guild.id]);
+
+        if (rows.length && !await confirmOverwrite(interaction, member, rows[0], duration, reason)) {
+            embed.setColor(Colors.Red)
+                .setDescription('Cancelled mute override');
+            return await interaction.editReply({ embeds: [embed], components: [] });
+        }
+
+        if (!rows.length && member.roles.cache.has(settings.roles.muted) && !await confirmUnmanagedMute(interaction, member, duration, reason)) {
+            embed.setColor(Colors.Red)
+                .setDescription('Cancelled converting mute');
+            return await interaction.editReply({ embeds: [embed], components: [] });
+        }
+
+        await this.mute(settings, db, interaction, member, duration, reason, rows[0]);
+    },
+    /**
+     * @param {import('discord.js').ChatInputCommandInteraction} interaction
+     * @param {import('discord.js').Client} bot
+     * @param {import('mysql2').Pool} db
+     */
+    async slashCommandExecute(interaction, bot, db) {
+        const settings = bot.settings[interaction.guild.id];
+        const member = interaction.options.getMember('member');
+        const reason = interaction.options.getString('reason');
+        const type = interaction.options.getSubcommand();
+        const duration = type == 'permanent' ? 0 : processDuration(interaction.options.getString('duration'), interaction.options.getInteger('time'));
+        await this.processExecute(interaction, settings, db, member, reason, duration);
+    },
+
+    /**
+     * @param {import('discord.js').Message} interaction
+     * @param {string[]} args ignored
+     * @param {import('discord.js').Client} bot
+     * @param {import('mysql2').Pool} db
+     */
+    async execute(message, args, bot, db) {
+        const settings = bot.settings[message.guild.id];
+
+        const embed = new EmbedBuilder()
+            .setColor(Colors.Red)
+            .setTimestamp()
+            .setFooter({ text: `${message.member.displayName}`, iconURL: message.member.displayAvatarURL() })
+            .setTitle('Invalid Arguments');
+        const search = args.shift();
+        const member = message.guild.findMember(search);
+        if (!member) return message.reply({ embeds: [embed.setDescription(`Could not find member matching \`${search}\``)] });
+
+        const timeValue = args.shift();
+        if (isNaN(timeValue) && !timeValue.toLowerCase().startsWith('perm')) {
+            return await message.reply({ embeds: [embed.setDescription(`\`${timeValue}\` is not a valid argument for \`time\``)] });
+        }
+
+        const duration = isNaN(timeValue) ? 0 : processDuration(args.shift(), parseInt(timeValue));
+        const reason = args.join(' ') || 'No reason provided';
+
+        await this.processExecute(message, settings, db, member, reason, duration);
     }
-}
+};
+
diff --git a/commands/punishments.js b/commands/punishments.js
index 20ae6fb0..33ac0d86 100644
--- a/commands/punishments.js
+++ b/commands/punishments.js
@@ -1,8 +1,10 @@
+/* eslint-disable no-bitwise */
 /* eslint-disable no-await-in-loop */
 const { EmbedBuilder, Colors, ActionRowBuilder, ButtonBuilder, ButtonStyle, StringSelectMenuBuilder,
     StringSelectMenuOptionBuilder, InteractionCollector, ComponentType } = require('discord.js');
 const SlashArgType = require('discord-api-types/v10').ApplicationCommandOptionType;
 const { slashArg, slashCommandJSON } = require('../utils.js');
+const moment = require('moment');
 
 /** @typedef {{ id: string }} HasID */
 /**
@@ -35,11 +37,13 @@ const { slashArg, slashCommandJSON } = require('../utils.js');
  * @typedef MuteRow
  * @property {string} id
  * @property {string} guildid
- * @property {boolean} muted
- * @property {string} reason
  * @property {string} modid
- * @property {string} uTime
- * @property {boolean} perma
+ * @property {string} reason
+ * @property {number} appliedOn
+ * @property {number} duration
+ * @property {number?} removedOn
+ * @property {string?} removedBy
+ * @property {string?} removeReason
  */
 /**
  * @param {WarnRow[]} rows
@@ -53,16 +57,7 @@ function flattenOnId(rows) {
     }, {});
 }
 
-/**
- * @param {boolean} permanent
- * @param {number} ending unix time
- * @param {number?} ended unix time
- * @returns {string}
- */
-function timeString(permanent, ending, ended) {
-    if (!ended && permanent) return 'Permanently';
-    return `<t:${ended || ending}:R> at <t:${ended || ending}:f>`;
-}
+const timestamp = (time) => `<t:${time}:R> at <t:${time}:f>`;
 
 class PunishmentsUI {
     /** @type {string[]} */
@@ -142,8 +137,11 @@ class PunishmentsUI {
             this.#suspensions = flattenOnId(suspensions);
         }
         if (position >= cache.get(roles[rolePermissions.punishmentsMutes]).position && punishmentsMutes) {
-            const [mutes] = await db.promise().query('SELECT *  FROM mutes WHERE id in (?) AND guildid = ?', [ids, this.#guild.id]);
-            this.#mutes = flattenOnId(mutes);
+            const [mutes] = await db.promise().query('SELECT * FROM mutes WHERE id in (?) AND guildid = ? ORDER BY appliedOn + duration DESC', [ids, this.#guild.id]);
+            const permas = mutes.filter(mute => !mute.removedOn && !mute.duration);
+            const actives = mutes.filter(mute => !permas.includes(mute) && !mute.removedOn);
+            const remaining = mutes.filter(mute => !permas.includes(mute) && !actives.includes(mute));
+            this.#mutes = flattenOnId([...permas, ...actives, ...remaining]); // sort by perma > active > inactive, flattenOnId respects local order
         }
         const joined = [...Object.values(this.#warns), ...Object.values(this.#mutes), ...Object.values(this.#suspensions)].flat();
         if (full !== false && (full || joined.length < 20)) {
@@ -304,8 +302,7 @@ class PunishmentsUI {
         let i = 1;
         for (; i <= rows.length; i++) {
             const row = rows[i - 1];
-            const time = timeString(false, (row.time / 1000).toFixed(0));
-            const text = `\`${(i).toString().padStart(3, ' ')}\`${row.silent ? ' *Silently*' : ''} By <@!${row.modid}> ${time}\`\`\`${row.reason}\`\`\`\n`;
+            const text = `\`${(i).toString().padStart(3, ' ')}\`${row.silent ? ' *Silently*' : ''} By <@!${row.modid}> ${timestamp((row.time / 1000) ^ 0)}\`\`\`${row.reason}\`\`\`\n`;
             if (embed.length + fields.map(f => f.length).reduce((a, c) => a + c, 0) + text.length >= 5600) break;
             if (fields[fields.length - 1].length + text.length >= 800) fields.push('');
             fields[fields.length - 1] += text;
@@ -330,8 +327,7 @@ class PunishmentsUI {
         let i = 1;
         for (; i <= rows.length; i++) {
             const row = rows[i - 1];
-            const time = timeString(row.perma, (parseInt(row.uTime) / 1000).toFixed(0));
-            const text = `\`${(i).toString().padStart(3, ' ')}\`${row.suspended ? ' **Active**' : ''} By <@!${row.modid}> ${time}\`\`\`${row.reason}\`\`\`\n`;
+            const text = `\`${(i).toString().padStart(3, ' ')}\`${row.suspended ? ' **Active**' : ''} By <@!${row.modid}> ${row.perma ? 'Permanently' : timestamp((parseInt(row.uTime) / 1000) ^ 0)}\`\`\`${row.reason}\`\`\`\n`;
             if (embed.length + fields.map(f => f.length).reduce((a, c) => a + c, 0) + text.length >= 5600) break;
             if (fields[fields.length - 1].length + text.length >= 800) fields.push('');
             fields[fields.length - 1] += text;
@@ -356,8 +352,13 @@ class PunishmentsUI {
         let i = 1;
         for (; i <= rows.length; i++) {
             const row = rows[i - 1];
-            const time = timeString(row.perma, (row.uTime / 1000).toFixed(0));
-            const text = `\`${(i).toString().padStart(3, ' ')}\`${row.muted ? ' **Active**' : ''} By <@!${row.modid}> ${time}\`\`\`${row.reason}\`\`\`\n`;
+            let timestr = '';
+            if (!row.duration && !row.removedOn) timestr = 'Permanently';
+            else if (!row.duration) timestr = 'was Permanent';
+            else if (row.duration == -1) timestr = `Unknown duration\nEnded before <t:${row.appliedOn}:f>`;
+            else timestr = `for ${moment.duration(row.duration * 1000).humanize()}\nApplied on <t:${row.appliedOn}:f>`;
+            const reason = row.duration != -1 && row.removedOn ? `\`\`\`\n${row.reason}\`\`\`${row.overwritten ? 'Overwritten' : 'Removed'} <t:${row.removedOn}:R> by <@!${row.removedBy}> \`\`\`\n${row.removeReason}\`\`\`` : `\`\`\`${row.reason}\`\`\``;
+            const text = `\`${(i).toString().padStart(3, ' ')}\`${!row.removedOn ? ' **Active**' : ''} By <@!${row.modid}> ${timestr} ${reason}\n`;
             if (embed.length + fields.map(f => f.length).reduce((a, c) => a + c, 0) + text.length >= 5600) break;
             if (fields[fields.length - 1].length + text.length >= 800) fields.push('');
             fields[fields.length - 1] += text;
diff --git a/commands/test.js b/commands/test.js
index db3535a9..d36575a2 100644
--- a/commands/test.js
+++ b/commands/test.js
@@ -10,7 +10,6 @@ module.exports = {
     guildspecific: true,
     role: 'developer',
     async execute(message, args, bot, db) {
-        const repliedMessage = "Toast!!!!!"
-        await message.reply(repliedMessage)
+        message.reply('This is a test 1 2 3 one two three I II III')
     }
 }
diff --git a/commands/unmute.js b/commands/unmute.js
index 4952feda..a2d2c4a1 100644
--- a/commands/unmute.js
+++ b/commands/unmute.js
@@ -1,71 +1,115 @@
-const Discord = require('discord.js')
-const ErrorLogger = require('../lib/logError')
-const fs = require('fs')
-const SlashArgType = require('discord-api-types/v10').ApplicationCommandOptionType;
-const { slashArg, slashChoices, slashCommandJSON } = require('../utils.js')
+const { EmbedBuilder, Colors } = require('discord.js');
+const ErrorLogger = require('../lib/logError');
+const { ApplicationCommandOptionType } = require('discord-api-types/v10');
+const { slashArg, slashCommandJSON } = require('../utils.js');
+const moment = require('moment');
+
+/**
+ *
+ * @param {number} duration
+ * @returns {string}
+ */
+function durationString(duration, when = Date.unix()) {
+    if (!duration) return 'Permanent';
+    duration = parseInt(duration);
+    when = parseInt(when);
+    return `${moment.duration(duration * 1000).humanize()} ending <t:${when + duration}:R> at <t:${when + duration}:f>`;
+}
 
 module.exports = {
     name: 'unmute',
     description: 'Removes muted role from user',
-    args: '<ign/mention/id>',
-    requiredArgs: 1,
     role: 'security',
+    varargs: true,
     args: [
-        slashArg(SlashArgType.User, 'member', {
-            description: "Member in the Server"
+        slashArg(ApplicationCommandOptionType.User, 'member', {
+            description: 'Member in the Server'
         }),
+        slashArg(ApplicationCommandOptionType.String, 'reason', {
+            description: 'Reason for the unmute',
+            required: false
+        })
     ],
     getSlashCommandData(guild) {
-        return slashCommandJSON(this, guild)
+        return slashCommandJSON(this, guild);
     },
-    async execute(message, args, bot, db) {
-        let settings = bot.settings[message.guild.id]
-        var member = message.mentions.members.first()
-        if (!member) member = message.guild.members.cache.get(args[0]);
-        if (!member) member = message.guild.members.cache.filter(user => user.nickname != null).find(nick => nick.nickname.replace(/[^a-z|]/gi, '').toLowerCase().split('|').includes(args[0].toLowerCase()));
-        if (!member) { message.reply('User not found. Please try again'); return; }
-        if (member.roles.highest.position >= message.member.roles.highest.position) return message.reply(`${member} has a role greater than or equal to you and cannot be unmuted by you`);
-        let muted = settings.roles.muted
-        if (!member.roles.cache.has(muted)) {
-            message.reply(`${member} is not muted`)
-            return;
+
+    /**
+     *
+     * @param {import('../utils.js').BotCommandInteraction} interaction
+     * @param {string[]} args unused
+     * @param {import('discord.js').Client} bot
+     * @param {import('mysql2').Pool} db
+     */
+    async execute(interaction, args, bot, db) {
+        const settings = bot.settings[interaction.guild.id];
+        const member = interaction.options.getMember('member');
+        const reason = [interaction.options.getString('reason'), ...interaction.options.getVarargs()].join(' ') || 'No reason provided';
+
+        const [[row]] = await db.promise().query('SELECT * FROM mutes WHERE id = ? AND guildid = ? AND removedOn IS NULL', [member.id, member.guild.id]);
+        const embed = new EmbedBuilder()
+            .setFooter({ text: `${interaction.member.displayName}`, iconURL: interaction.member.displayAvatarURL() })
+            .setAuthor({ name: member.displayName, iconURL: member.displayAvatarURL() })
+            .setTitle('Unmute')
+            .setTimestamp()
+            .setColor(Colors.Red);
+        if (!row && !member.roles.cache.has(settings.roles.muted)) {
+            embed.setDescription(`${member} does not have the muted role and doesn't have any active mutes with ${interaction.client.user}.`);
+            return await interaction.reply({ embeds: [embed] });
         }
-        db.query(`SELECT * FROM mutes WHERE id = '${member.id}' AND muted = true`, async (err, rows) => {
-            if (err) ErrorLogger.log(err, bot, message.guild)
-            if (!rows || rows.length == 0) {
-                let embed = new Discord.EmbedBuilder()
-                    .setTitle('Confirm Action')
-                    .setColor('#ff0000')
-                    .setDescription(`I don't have any log of ${member} being muted. Are you sure you want to unmute them?`)
-                let confirmMessage = await message.channel.send({ embeds: [embed] })
-                let reactionCollector = new Discord.ReactionCollector(confirmMessage, { filter: (r, u) => !u.bot && u.id == message.author.id && (r.emoji.name === '✅' || r.emoji.name === '❌') })
-                reactionCollector.on('collect', async (r, u) => {
-                    confirmMessage.delete()
-                    if (r.emoji.name !== '✅') return;
-                    member.roles.remove(muted).catch(er => ErrorLogger.log(er, bot, message.guild))
-                    message.channel.send(`${member} has been unmuted`)
-                })
-                await confirmMessage.react('✅')
-                await confirmMessage.react('❌')
-            } else {
-                const reason = rows[0].reason
-                const unmuteUTime = parseInt(rows[0].uTime)
-                let embed = new Discord.EmbedBuilder()
-                    .setTitle('Confirm Action')
-                    .setColor('#ff0000')
-                    .setDescription(`Are you sure you want to unmute ${member}\nReason: ${reason}\nMuted by <@!${rows[0].modid}>\nUnmute: <t:${(unmuteUTime/1000).toFixed(0)}:R> at <t:${(unmuteUTime/1000).toFixed(0)}:f>`)
-                let confirmMessage = await message.channel.send({ embeds: [embed] })
-                let reactionCollector = new Discord.ReactionCollector(confirmMessage, { filter: (r, u) => !u.bot && u.id == message.author.id && (r.emoji.name === '✅' || r.emoji.name === '❌') })
-                await confirmMessage.react('✅')
-                await confirmMessage.react('❌')
-                reactionCollector.on('collect', async (r, u) => {
-                    confirmMessage.delete()
-                    if (r.emoji.name !== '✅') return;
-                    await member.roles.remove(muted).catch(er => ErrorLogger.log(er, bot, message.guild))
-                    message.reply(`${member} has been unmuted`)
-                    db.query(`UPDATE mutes SET muted = false WHERE id = '${member.id}'`)
-                })
+        const rpmrole = member.guild.roles.cache.get(settings.roles[settings.rolePermissions.removePermanentMute]);
+        if (rpmrole && member.roles.highest.position < rpmrole.position) {
+            embed.setDescription(`You must have ${rpmrole} or higher to remove a permanent mute.`);
+            return await interaction.reply({ embeds: [embed] });
+        }
+        await this.unmute(interaction, interaction.guild, interaction.member, member, settings, db, row, reason);
+    },
+
+    /**
+     *
+     * @param {import('../utils.js').BotCommandInteraction?} interaction
+     * @param {import('discord.js').GuildMember} moderator
+     * @param {import('discord.js').GuildMember?} member
+     * @param {*} settings
+     * @param {import('mysql2').Pool} db
+     * @param {import('./mute.js').MuteRow} row
+     * @param {string} reason
+     */
+    async unmute(interaction, guild, moderator, member, settings, db, row, reason) {
+        const embed = new EmbedBuilder()
+            .setColor(Colors.Green)
+            .setAuthor({ name: member.displayName, iconURL: member.displayAvatarURL() })
+            .setTitle('Unmute')
+            .setTimestamp()
+            .setFooter({ text: `${moderator.displayName}`, iconURL: moderator.displayAvatarURL() })
+            .addFields({ name: 'Member', value: member ? `${member}\n\`${member.displayName}\`` : `<@!${row.id}> (not in server)`, inline: true },
+                { name: 'Moderator', value: `${moderator}\n\`${moderator.displayName}\``, inline: true },
+                { name: 'Unmute Time', value: `<t:${Date.unix()}:f>`, inline: true },
+                { name: 'Unmute Reason', value: reason });
+
+        if (row) {
+            await db.promise().query('UPDATE mutes SET removedOn = unix_timestamp(), removedBy = ?, removeReason = ? WHERE id = ? AND guildid = ? AND removedOn IS NULL',
+                [moderator.id, reason, row.id, guild.id]);
+
+            const mod = guild.members.cache.get(row.modid);
+            embed.addFields({ name: 'Muted By', value: mod ? `${mod}\n\`${mod.displayName}\`` : `<@!${row.modid}>`, inline: true },
+                { name: 'Muted On', value: `<t:${row.appliedOn}:R>\n<t:${row.appliedOn}:f>`, inline: true },
+                { name: 'Mute Duration', value: durationString(row.duration, row.appliedOn), inline: true },
+                { name: 'Mute Reason', value: row.reason });
+        } else {
+            embed.addFields({ name: 'Unmanaged', value: `<@!${member.id}> had the <@&${settings.roles.muted}> role but it was not managed by ${guild.client.user}.` });
+        }
+
+        try {
+            if (member) {
+                await member.roles.remove(settings.roles.muted);
+                const dm = await member.createDM().catch(() => {});
+                await dm?.send({ embeds: [embed] }).catch(() => {});
             }
-        })
+            if (interaction) await interaction.reply({ embeds: [embed] });
+            await guild.channels.cache.get(settings.channels.modlogs).send({ embeds: [embed] });
+        } catch (e) {
+            ErrorLogger.log(e, guild.client, guild);
+        }
     }
-}
\ No newline at end of file
+};
diff --git a/dbSetup.js b/dbSetup.js
index 2095710f..2d440646 100644
--- a/dbSetup.js
+++ b/dbSetup.js
@@ -52,7 +52,7 @@ class DbWrap {
                 let error = null;
                 let rv = null;
                 try {
-                    rv = await dbPromise.query(query, params, cb).catch(() => {});
+                    rv = await dbPromise.query(query, params, cb);
                 } catch (e) {
                     error = e;
                 }
diff --git a/jobs/mute.js b/jobs/mute.js
index 66717eef..b13e56de 100644
--- a/jobs/mute.js
+++ b/jobs/mute.js
@@ -1,26 +1,25 @@
 const { RepeatedJob } = require('./RepeatedJob.js');
-const ErrorLogger = require('../lib/logError');
-const { iterServersWithQuery } = require('./util.js');
+const { iterServers } = require('./util.js');
 const { getDB } = require('../dbSetup.js');
-
+const { unmute } = require('../commands/unmute.js');
 class Mute extends RepeatedJob {
     async run(bot) {
-        await iterServersWithQuery(bot, 'SELECT * FROM mutes WHERE muted = true', async (bot, row, g) => {
-            if (Date.now() > parseInt(row.uTime)) {
-                const guildId = row.guildid;
-                const settings = bot.settings[guildId];
-                const guild = bot.guilds.cache.get(guildId);
-                if (guild) {
-                    const db = getDB(g.id);
-                    const member = guild.members.cache.get(row.id);
-                    if (!member) return await db.promise().query('UPDATE mutes SET muted = false WHERE id = ?', [row.id]);
-                    try {
-                        await member.roles.remove(settings.roles.muted);
-                        await db.promise().query('UPDATE mutes SET muted = false WHERE id = ?', [row.id]);
-                    } catch (er) {
-                        ErrorLogger.log(er, bot, g);
-                    }
+        await iterServers(bot, async (bot, guild) => {
+            const ids = [];
+            const settings = bot.settings[guild.id];
+            const db = getDB(guild.id);
+            const botMember = guild.members.cache.get(bot.user.id);
+            const [rows] = await db.promise().query('SELECT * FROM mutes WHERE guildid = ? AND removedOn IS NULL', [guild.id]);
+            for (const row of rows) {
+                const member = guild.members.cache.get(row.id);
+                if (ids.includes(row.id)) continue;
+                if (parseInt(row.appliedOn) + parseInt(row.duration) > Date.unix() || !row.duration) {
+                    if (!member?.roles.cache.has(settings.roles.muted)) member?.roles.add(settings.roles.muted);
+                    continue;
                 }
+                ids.push(row.id); // In case db ends up with multiple rows with removedOn = null
+                // eslint-disable-next-line no-await-in-loop
+                await unmute(null, guild, botMember, member, settings, db, row, 'Mute expired');
             }
         });
     }
diff --git a/lib/extensions.js b/lib/extensions.js
index 7dbee3fc..8ac0872b 100644
--- a/lib/extensions.js
+++ b/lib/extensions.js
@@ -32,6 +32,8 @@ module.exports = {
     createEmbed
 };
 
+Date.unix = function() { return (Date.now() / 1000)^0 };
+
 /* Promise.wait = Promise.wait || function(time) {
     let waiter, rej;
     return { finished: new Promise((resolve, reject) => { rej = reject; waiter = setTimeout(resolve, time) }), cancel: () => { clearTimeout(waiter); rej(new Error('Wait cancelled.')); } };
diff --git a/memberHandler.js b/memberHandler.js
index 8fb4efa6..4d8a3f08 100644
--- a/memberHandler.js
+++ b/memberHandler.js
@@ -50,7 +50,7 @@ module.exports = {
     async checkWasMuted(bot, member) {
         const db = getDB(member.guild.id);
 
-        const [[{ muteCount }]] = await db.promise().query('SELECT COUNT(*) as muteCount FROM mutes WHERE id = ? AND muted = true', [member.id]);
+        const [[{ muteCount }]] = await db.promise().query('SELECT COUNT(*) as muteCount FROM mutes WHERE id = ? AND guildid = ? AND removedOn IS NULL', [member.id, member.guild.id]);
         if (muteCount !== 0) {
             await member.roles.add(bot.settings[member.guild.id].roles.muted);
             const logChannel = modlogChannel(bot, member.guild);
@@ -69,7 +69,7 @@ module.exports = {
         await Promise.all(bot.partneredServers.filter((server) => server.guildId == member.guild.id).map(async (partneredServer) => {
             const partneredSettings = bot.settings[partneredServer.id];
             const otherServer = bot.guilds.cache.find(g => g.id == partneredServer.id);
-            const partneredMember = otherServer.members.cache.get(member.id);
+            const partneredMember = otherServer?.members.cache.get(member.id);
 
             if (!partneredMember) { return; }
 
diff --git a/messageManager.js b/messageManager.js
index 0f76965f..facda3db 100644
--- a/messageManager.js
+++ b/messageManager.js
@@ -12,7 +12,7 @@ const modmail = require('./lib/modmail.js')
 const { argString } = require('./commands/commands.js');
 const { getDB } = require('./dbSetup.js')
 const { LegacyCommandOptions, LegacyParserError } = require('./utils.js')
-
+const { mute } = require('./commands/mute.js');
 class MessageManager {
     #bot;
     #botSettings;
@@ -296,27 +296,9 @@ class MessageManager {
         const settings = this.#bot.settings[message.guild.id]
         if (!settings || !settings.backend.automod) return;
         if (!message.member.roles.highest || message.member.roles.highest.position >= message.guild.roles.cache.get(settings.roles.eventrl).position) return
-        if (message.mentions.roles.size != 0) mute('Pinging Roles', 2);
-
-        function mute(reason, time) {
-            // Time: 1=1 hour, 2=1 day
-            let timeString; let timeValue;
-            if (time == 1) {
-                timeString = '1 Hour';
-                timeValue = 3600000
-            } else if (time == 2) {
-                timeString = '1 Day';
-                timeValue = 86400000
-            }
-
-            message.member.roles.add(settings.roles.muted)
-                .then(() => this.#bot.dbs[message.guild.id].query(`INSERT INTO mutes (id, guildid, muted, reason, modid, uTime) VALUES ('${message.author.id}', '${message.guild.id}', true, '${reason}','${this.#bot.user.id}', '${Date.now() + timeValue}')`))
-                .then(() => message.author.send(`You have been muted in \`${message.guild.name}\` for \`${reason}\`. This will last for \`${timeString}\``))
-                .then(() => {
-                    const modlog = message.guild.channels.cache.get(settings.channels.modlog)
-                    if (!modlog) return ErrorLogger.log(new Error('Mod log not found for automod'), this.#bot, message.guild)
-                    modlog.send(`${message.member} was muted for \`${timeString}\` for \`${reason}\``)
-                })
+        if (message.mentions.roles.size != 0) {
+            const [rows] = await this.#bot.dbs[message.guild.id].promise().query('SELECT * FROM mutes WHERE id = ? AND guildid = ? AND removedOn IS NULL', [message.member.id, message.guild.id]);
+            await mute(settings, this.#bot.dbs[message.guild.id], null, message.member, 86400000, 'Pinging roles', rows[0]);
         }
     }