jsdecryptor 4.0.3

package/davexcore/group/tag.js

@@ -0,0 +1,111 @@
+const isAdmin = require('../../davelib/isAdmin');
+const { downloadContentFromMessage } = require('@whiskeysockets/baileys');
+const fs = require('fs');
+const path = require('path');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function downloadMediaMessage(message, mediaType) {
+    const stream = await downloadContentFromMessage(message, mediaType);
+    let buffer = Buffer.from([]);
+    for await (const chunk of stream) {
+        buffer = Buffer.concat([buffer, chunk]);
+    }
+    const tempDir = path.join(__dirname, '../temp/');
+    if (!fs.existsSync(tempDir)) {
+        fs.mkdirSync(tempDir, { recursive: true });
+    }
+    const filePath = path.join(tempDir, `${Date.now()}.${mediaType}`);
+    fs.writeFileSync(filePath, buffer);
+    return filePath;
+}
+
+async function tagCommand(sock, chatId, senderId, messageText, replyMessage, message) {
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+    
+    const { isSenderAdmin, isBotAdmin } = await isAdmin(sock, chatId, senderId);
+
+    if (!isBotAdmin) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\nBot needs to be admin!` }, { quoted: fake });
+        return;
+    }
+
+    if (!isSenderAdmin && !message?.key?.fromMe && !db.isSudo(senderId)) {
+        const stickerPath = './assets/sticktag.webp';
+        if (fs.existsSync(stickerPath)) {
+            const stickerBuffer = fs.readFileSync(stickerPath);
+            await sock.sendMessage(chatId, { sticker: stickerBuffer });
+        }
+        return;
+    }
+
+    try {
+        const groupMetadata = await sock.groupMetadata(chatId);
+        const participants = groupMetadata.participants;
+        const mentionedJidList = participants.map(p => p.id);
+
+        if (replyMessage) {
+            let messageContent = {};
+
+            if (replyMessage.imageMessage) {
+                const filePath = await downloadMediaMessage(replyMessage.imageMessage, 'image');
+                messageContent = {
+                    image: { url: filePath },
+                    caption: messageText || replyMessage.imageMessage.caption || '',
+                    mentions: mentionedJidList
+                };
+                await sock.sendMessage(chatId, messageContent);
+                fs.unlinkSync(filePath);
+            } else if (replyMessage.videoMessage) {
+                const filePath = await downloadMediaMessage(replyMessage.videoMessage, 'video');
+                messageContent = {
+                    video: { url: filePath },
+                    caption: messageText || replyMessage.videoMessage.caption || '',
+                    mentions: mentionedJidList
+                };
+                await sock.sendMessage(chatId, messageContent);
+                fs.unlinkSync(filePath);
+            } else if (replyMessage.stickerMessage) {
+                const filePath = await downloadMediaMessage(replyMessage.stickerMessage, 'sticker');
+                messageContent = {
+                    sticker: { url: filePath },
+                    mentions: mentionedJidList
+                };
+                await sock.sendMessage(chatId, messageContent);
+                fs.unlinkSync(filePath);
+            } else if (replyMessage.audioMessage) {
+                const filePath = await downloadMediaMessage(replyMessage.audioMessage, 'audio');
+                messageContent = {
+                    audio: { url: filePath },
+                    ptt: replyMessage.audioMessage.ptt || false,
+                    mentions: mentionedJidList
+                };
+                await sock.sendMessage(chatId, messageContent);
+                fs.unlinkSync(filePath);
+            } else {
+                const quotedText = replyMessage.conversation || 
+                                   replyMessage.extendedTextMessage?.text || 
+                                   messageText || '';
+                await sock.sendMessage(chatId, {
+                    text: quotedText,
+                    mentions: mentionedJidList
+                });
+            }
+        } else if (messageText) {
+            await sock.sendMessage(chatId, {
+                text: messageText,
+                mentions: mentionedJidList
+            });
+        } else {
+            await sock.sendMessage(chatId, {
+                text: `*${botName}*\nUsage: .tag <message> or reply to a message`
+            }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Tag error:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        await sock.sendMessage(chatId, { text: `*${botName}*\nError: ${error.message}` }, { quoted: fake });
+    }
+}
+
+module.exports = tagCommand;

package/davexcore/group/tagadmins.js

@@ -0,0 +1,88 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function resolveToPhone(sock, jid) {
+    if (!jid) return 'unknown';
+    const raw = jid.split('@')[0].split(':')[0];
+    if (/^\d{7,15}$/.test(raw)) return raw;
+    try {
+        if (sock?.signalRepository?.lidMapping?.getPNForLID) {
+            const formats = [jid, `${raw}:0@lid`, `${raw}@lid`];
+            for (const fmt of formats) {
+                try {
+                    const pn = await sock.signalRepository.lidMapping.getPNForLID(fmt);
+                    if (pn) {
+                        const num = String(pn).split('@')[0].replace(/[^0-9]/g, '');
+                        if (num.length >= 7 && num.length <= 15 && num !== raw) return num;
+                    }
+                } catch {}
+            }
+        }
+        const groups = await sock.groupFetchAllParticipating();
+        for (const gid of Object.keys(groups)) {
+            for (const p of (groups[gid].participants || [])) {
+                const pid = (p.id || '').split('@')[0].split(':')[0];
+                const pLid = (p.lid || '').split('@')[0].split(':')[0];
+                if ((pLid === raw || pid === raw) && pid && /^\d{7,15}$/.test(pid) && pid !== raw) return pid;
+            }
+        }
+    } catch {}
+    return raw;
+}
+
+async function tagAdminsCommand(sock, chatId, senderId, message, fullArgs) {
+    try {
+        const meta = await sock.groupMetadata(chatId);
+        const participants = meta.participants;
+        const botName = getBotName();
+        const fake = createFakeContact(message);
+
+        const superAdmins = [];
+        const admins = [];
+
+        for (const p of participants) {
+            if (p.admin === 'superadmin') {
+                superAdmins.push(p.id);
+            } else if (p.admin === 'admin') {
+                admins.push(p.id);
+            }
+        }
+
+        const allAdmins = [...superAdmins, ...admins];
+
+        if (allAdmins.length === 0) {
+            await sock.sendMessage(chatId, { text: 'No admins found in this group!' }, { quoted: fake });
+            return;
+        }
+
+        const mentions = [...allAdmins, senderId];
+
+        let text = `*${botName} TAG ADMINS*\n\n`;
+
+        if (fullArgs && fullArgs.trim()) {
+            text += `*Message:* ${fullArgs.trim()}\n\n`;
+        }
+
+        const resolvedSender = await resolveToPhone(sock, senderId);
+        text += `*Tagged By:* @${resolvedSender}\n\n`;
+        text += `*Admins:*\n`;
+
+        for (const id of superAdmins) {
+            const resolved = await resolveToPhone(sock, id);
+            text += `@${resolved}\n`;
+        }
+        for (const id of admins) {
+            const resolved = await resolveToPhone(sock, id);
+            text += `@${resolved}\n`;
+        }
+
+        await sock.sendMessage(chatId, {
+            text: text.trim(),
+            mentions
+        }, { quoted: fake });
+    } catch (error) {
+        console.error('Tagadmins error:', error);
+        await sock.sendMessage(chatId, { text: `Failed to tag admins: ${error.message}` });
+    }
+}
+
+module.exports = tagAdminsCommand;

package/davexcore/group/tagall.js

@@ -0,0 +1,99 @@
+const isAdmin = require('../../davelib/isAdmin');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function resolveToPhone(sock, jid) {
+    if (!jid) return 'unknown';
+    const raw = jid.split('@')[0].split(':')[0];
+    if (/^\d{7,15}$/.test(raw)) return raw;
+    try {
+        if (sock?.signalRepository?.lidMapping?.getPNForLID) {
+            const formats = [jid, `${raw}:0@lid`, `${raw}@lid`];
+            for (const fmt of formats) {
+                try {
+                    const pn = await sock.signalRepository.lidMapping.getPNForLID(fmt);
+                    if (pn) {
+                        const num = String(pn).split('@')[0].replace(/[^0-9]/g, '');
+                        if (num.length >= 7 && num.length <= 15 && num !== raw) return num;
+                    }
+                } catch {}
+            }
+        }
+        const groups = await sock.groupFetchAllParticipating();
+        for (const gid of Object.keys(groups)) {
+            for (const p of (groups[gid].participants || [])) {
+                const pid = (p.id || '').split('@')[0].split(':')[0];
+                const pLid = (p.lid || '').split('@')[0].split(':')[0];
+                if ((pLid === raw || pid === raw) && pid && /^\d{7,15}$/.test(pid) && pid !== raw) return pid;
+            }
+        }
+    } catch {}
+    return raw;
+}
+
+async function tagAllCommand(sock, chatId, senderId, message) {
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+    
+    try {
+        const { isSenderAdmin, isBotAdmin } = await isAdmin(sock, chatId, senderId);
+        
+        if (!isSenderAdmin && !isBotAdmin && !message?.key?.fromMe && !db.isSudo(senderId)) {
+            await sock.sendMessage(chatId, {
+                text: `*${botName}*\nAdmin only command!`
+            }, { quoted: fake });
+            return;
+        }
+
+        const groupMetadata = await sock.groupMetadata(chatId);
+        const participants = groupMetadata.participants;
+
+        if (!participants || participants.length === 0) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nNo participants found!` 
+            }, { quoted: fake });
+            return;
+        }
+
+        let profilePictureUrl = null;
+        try {
+            profilePictureUrl = await sock.profilePictureUrl(chatId, 'image');
+        } catch (error) {}
+
+        let textContent = `╭─❖ *${botName} TAGALL* ❖─╮\n`;
+        textContent += `│ Group   : ${groupMetadata.subject}\n`;
+        textContent += `│ Members : ${participants.length}\n`;
+        textContent += `╰────────────────────────╯\n\n`;
+
+        for (let index = 0; index < participants.length; index++) {
+            const participant = participants[index];
+            const number = (index + 1).toString().padStart(2, '0');
+            const resolved = await resolveToPhone(sock, participant.id);
+            const displayName = participant.name || participant.notify || resolved;
+            textContent += `${number}. @${resolved} (${displayName})\n`;
+        }
+
+        const mentions = participants.map(p => p.id);
+
+        if (profilePictureUrl) {
+            await sock.sendMessage(chatId, {
+                image: { url: profilePictureUrl },
+                caption: textContent,
+                mentions: mentions
+            }, { quoted: fake });
+        } else {
+            await sock.sendMessage(chatId, {
+                text: textContent,
+                mentions: mentions
+            }, { quoted: fake });
+        }
+
+    } catch (error) {
+        console.error('TagAll error:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nFailed to tag members.`
+        }, { quoted: fake });
+    }
+}
+
+module.exports = { tagAllCommand };

package/davexcore/group/tagnotadmin.js

@@ -0,0 +1,92 @@
+const isAdmin = require('../../davelib/isAdmin');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function resolveToPhone(sock, jid) {
+    if (!jid) return 'unknown';
+    const raw = jid.split('@')[0].split(':')[0];
+    if (/^\d{7,15}$/.test(raw)) return raw;
+    try {
+        if (sock?.signalRepository?.lidMapping?.getPNForLID) {
+            const formats = [jid, `${raw}:0@lid`, `${raw}@lid`];
+            for (const fmt of formats) {
+                try {
+                    const pn = await sock.signalRepository.lidMapping.getPNForLID(fmt);
+                    if (pn) {
+                        const num = String(pn).split('@')[0].replace(/[^0-9]/g, '');
+                        if (num.length >= 7 && num.length <= 15 && num !== raw) return num;
+                    }
+                } catch {}
+            }
+        }
+        const groups = await sock.groupFetchAllParticipating();
+        for (const gid of Object.keys(groups)) {
+            for (const p of (groups[gid].participants || [])) {
+                const pid = (p.id || '').split('@')[0].split(':')[0];
+                const pLid = (p.lid || '').split('@')[0].split(':')[0];
+                if ((pLid === raw || pid === raw) && pid && /^\d{7,15}$/.test(pid) && pid !== raw) return pid;
+            }
+        }
+    } catch {}
+    return raw;
+}
+
+async function tagNotAdminCommand(sock, chatId, senderId, message) {
+    try {
+        const { isSenderAdmin, isBotAdmin } = await isAdmin(sock, chatId, senderId);
+        const fake = createFakeContact(senderId);
+
+        if (!isBotAdmin) {
+            await sock.sendMessage(chatId, { text: 'Please make the bot an admin first.' }, { quoted: fake });
+            return;
+        }
+
+        if (!isSenderAdmin) {
+            await sock.sendMessage(chatId, { text: 'Only admins can use the .tagnotadmin command.' }, { quoted: fake });
+            return;
+        }
+
+        const groupMetadata = await sock.groupMetadata(chatId);
+        const participants = groupMetadata.participants || [];
+
+        const nonAdmins = participants.filter(p => !p.admin).map(p => p.id);
+        if (nonAdmins.length === 0) {
+            await sock.sendMessage(chatId, { text: 'No non-admin members to tag.' }, { quoted: fake });
+            return;
+        }
+
+        let profilePicUrl;
+        try {
+            profilePicUrl = await sock.profilePictureUrl(chatId, 'image');
+        } catch (error) {
+            profilePicUrl = null;
+        }
+
+        let text = `🏷️ *Tagging Non-Admins in ${groupMetadata.subject}*\n\n`;
+        text += `📊 *Total Non-Admins:* ${nonAdmins.length}\n\n`;
+        text += '🔊 *Hello Everyone:*\n\n';
+        
+        for (const jid of nonAdmins) {
+            const resolved = await resolveToPhone(sock, jid);
+            text += `@${resolved}\n`;
+        }
+
+        if (profilePicUrl) {
+            await sock.sendMessage(chatId, {
+                image: { url: profilePicUrl },
+                caption: text,
+                mentions: nonAdmins
+            }, { quoted: fake });
+        } else {
+            await sock.sendMessage(chatId, { 
+                text, 
+                mentions: nonAdmins 
+            }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Error in tagnotadmin command:', error);
+        const fake = createFakeContact(senderId);
+        await sock.sendMessage(chatId, { text: 'Failed to tag non-admin members.' }, { quoted: fake });
+    }
+}
+
+module.exports = tagNotAdminCommand;

package/davexcore/group/topmembers.js

@@ -0,0 +1,202 @@
+const {
+    incrementMsgCount,
+    getGroupMsgCounts,
+    resetGroupMsgCounts,
+    getGroupTotalMsgCount
+} = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function resolveToPhone(sock, jid) {
+    if (!jid) return 'unknown';
+    const raw = jid.split('@')[0].split(':')[0];
+    if (/^\d{7,15}$/.test(raw)) return raw;
+    try {
+        if (sock?.signalRepository?.lidMapping?.getPNForLID) {
+            const formats = [jid, `${raw}:0@lid`, `${raw}@lid`];
+            for (const fmt of formats) {
+                try {
+                    const pn = await sock.signalRepository.lidMapping.getPNForLID(fmt);
+                    if (pn) {
+                        const num = String(pn).split('@')[0].replace(/[^0-9]/g, '');
+                        if (num.length >= 7 && num.length <= 15 && num !== raw) return num;
+                    }
+                } catch {}
+            }
+        }
+        const groups = await sock.groupFetchAllParticipating();
+        for (const gid of Object.keys(groups)) {
+            for (const p of (groups[gid].participants || [])) {
+                const pid = (p.id || '').split('@')[0].split(':')[0];
+                const pLid = (p.lid || '').split('@')[0].split(':')[0];
+                if ((pLid === raw || pid === raw) && pid && /^\d{7,15}$/.test(pid) && pid !== raw) return pid;
+            }
+        }
+    } catch {}
+    return raw;
+}
+
+function incrementMessageCount(groupId, userId) {
+    try {
+        incrementMsgCount(groupId, userId);
+    } catch (error) {
+        console.error('Error incrementing message count:', error);
+    }
+}
+
+async function topMembers(sock, chatId, isGroup, message, count = 5) {
+    const fakeContact = createFakeContact(message);
+    const botName = getBotName();
+
+    try {
+        if (!isGroup) {
+            sock.sendMessage(chatId, { text: `*${botName}*\nGroup command only.` }, { quoted: fakeContact });
+            return;
+        }
+
+        const groupCounts = getGroupMsgCounts(chatId);
+        const sortedMembers = Object.entries(groupCounts)
+            .sort(([, a], [, b]) => b - a)
+            .slice(0, count);
+
+        if (sortedMembers.length === 0) {
+            sock.sendMessage(chatId, { text: `*${botName}*\nNo interaction data available.` }, { quoted: fakeContact });
+            return;
+        }
+
+        let textContent = `╭─❖ *TOP ${count} MEMBERS* ❖─╮\n`;
+        const mentions = [];
+
+        for (let index = 0; index < sortedMembers.length; index++) {
+            const [userId, messageCount] = sortedMembers[index];
+            const rank = (index + 1).toString().padStart(2, '0');
+            const username = await resolveToPhone(sock, userId);
+
+            let displayName = username;
+            try {
+                const groupMetadata = await sock.groupMetadata(chatId);
+                const participant = groupMetadata.participants.find(p => p.id === userId);
+                if (participant) {
+                    displayName = participant.name || participant.notify || username;
+                }
+            } catch {}
+
+            textContent += `│ ${rank}. @${username} (${displayName})\n`;
+            textContent += `│    📊 ${messageCount} messages\n`;
+            mentions.push(userId);
+        }
+
+        const totalMessages = getGroupTotalMsgCount(chatId);
+        textContent += `╰────────────────────────╯\n\n`;
+        textContent += `Total: ${totalMessages} messages`;
+
+        await sock.sendMessage(chatId, {
+            text: textContent,
+            mentions: mentions
+        }, { quoted: fakeContact });
+
+    } catch (error) {
+        console.error('Error in topMembers command:', error);
+        sock.sendMessage(chatId, { text: `*${botName}*\nFailed to load leaderboard.` }, { quoted: fakeContact });
+    }
+}
+
+async function getUserRank(sock, chatId, isGroup, userId, message) {
+    const fakeContact = createFakeContact(message);
+    const botName = getBotName();
+
+    try {
+        if (!isGroup) {
+            sock.sendMessage(chatId, { text: `*${botName}*\nGroup command only.` }, { quoted: fakeContact });
+            return;
+        }
+
+        const groupCounts = getGroupMsgCounts(chatId);
+        const username = await resolveToPhone(sock, userId);
+
+        if (!groupCounts[userId]) {
+            sock.sendMessage(chatId, {
+                text: `*${botName}*\n@${username} has no interaction history.`,
+                mentions: [userId]
+            }, { quoted: fakeContact });
+            return;
+        }
+
+        const sortedMembers = Object.entries(groupCounts).sort(([, a], [, b]) => b - a);
+        const userRank = sortedMembers.findIndex(([id]) => id === userId) + 1;
+        const userMessageCount = groupCounts[userId];
+        const totalMembers = sortedMembers.length;
+        const percentile = Math.round(((totalMembers - userRank + 1) / totalMembers) * 100);
+
+        const textContent = `╭─❖ *USER RANK* ❖─╮\n` +
+                           `│ User    : @${username}\n` +
+                           `│ Rank    : ${userRank}/${totalMembers}\n` +
+                           `│ Messages: ${userMessageCount}\n` +
+                           `│ Top     : ${percentile}%\n` +
+                           `╰─────────────────╯`;
+
+        sock.sendMessage(chatId, {
+            text: textContent,
+            mentions: [userId]
+        }, { quoted: fakeContact });
+
+    } catch (error) {
+        console.error('Error in getUserRank command:', error);
+        sock.sendMessage(chatId, {
+            text: `*${botName}*\nFailed to get user rank.`
+        }, { quoted: fakeContact });
+    }
+}
+
+function resetMessageCounts(groupId) {
+    try {
+        resetGroupMsgCounts(groupId);
+        return true;
+    } catch (error) {
+        console.error('Error resetting message counts:', error);
+        return false;
+    }
+}
+
+async function getGroupStats(sock, chatId, isGroup, message) {
+    const fakeContact = createFakeContact(message);
+    const botName = getBotName();
+
+    try {
+        if (!isGroup) {
+            sock.sendMessage(chatId, { text: `*${botName}*\nGroup command only.` }, { quoted: fakeContact });
+            return;
+        }
+
+        const groupCounts = getGroupMsgCounts(chatId);
+        const totalMessages = getGroupTotalMsgCount(chatId);
+        const activeMembers = Object.keys(groupCounts).length;
+        const sortedCounts = Object.values(groupCounts).sort((a, b) => b - a);
+        const averageMessages = activeMembers > 0 ? Math.round(totalMessages / activeMembers) : 0;
+        const medianMessages = sortedCounts.length > 0 ? sortedCounts[Math.floor(sortedCounts.length / 2)] : 0;
+
+        const textContent = `╭─❖ *GROUP STATS* ❖─╮\n` +
+                           `│ Active    : ${activeMembers}\n` +
+                           `│ Total     : ${totalMessages}\n` +
+                           `│ Average   : ${averageMessages}\n` +
+                           `│ Median    : ${medianMessages}\n` +
+                           `│ Top user  : ${sortedCounts[0] || 0}\n` +
+                           `╰────────────────────╯`;
+
+        sock.sendMessage(chatId, { text: textContent }, { quoted: fakeContact });
+
+    } catch (error) {
+        console.error('Error in getGroupStats command:', error);
+        sock.sendMessage(chatId, {
+            text: `*${botName}*\nFailed to load group stats.`
+        }, { quoted: fakeContact });
+    }
+}
+
+module.exports = {
+    incrementMessageCount,
+    topMembers,
+    getUserRank,
+    resetMessageCounts,
+    getGroupStats,
+    createFakeContact
+};

package/davexcore/group/unban.js

@@ -0,0 +1,64 @@
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function unbanCommand(sock, chatId, message) {
+    const senderId = message.key.participant || message.key.remoteJid;
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+    
+    if (!message.key.fromMe && !db.isSudo(senderId)) {
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nOwner only command!`
+        }, { quoted: fake });
+        return;
+    }
+
+    let userToUnban;
+    
+    if (message.message?.extendedTextMessage?.contextInfo?.mentionedJid?.length > 0) {
+        userToUnban = message.message.extendedTextMessage.contextInfo.mentionedJid[0];
+    } else if (message.message?.extendedTextMessage?.contextInfo?.participant) {
+        userToUnban = message.message.extendedTextMessage.contextInfo.participant;
+    } else {
+        const text = message.message?.conversation || message.message?.extendedTextMessage?.text || '';
+        const args = text.split(' ').slice(1);
+        if (args.length > 0) {
+            const possibleJid = args[0];
+            if (possibleJid.includes('@')) {
+                userToUnban = possibleJid;
+            } else {
+                userToUnban = possibleJid.replace(/[^0-9]/g, '') + '@s.whatsapp.net';
+            }
+        }
+    }
+    
+    if (!userToUnban) {
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nMention, reply, or provide number to unban!\n\nExample: .unban @user or .unban 6281234567890`
+        }, { quoted: fake });
+        return;
+    }
+
+    try {
+        if (db.isBanned(userToUnban)) {
+            db.removeBannedUser(userToUnban);
+            
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\n\n@${userToUnban.split('@')[0]} has been unbanned!`,
+                mentions: [userToUnban]
+            }, { quoted: fake });
+        } else {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\n\n@${userToUnban.split('@')[0]} is not banned!`,
+                mentions: [userToUnban]
+            }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Error in unban command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nFailed to unban user!`
+        }, { quoted: fake });
+    }
+}
+
+module.exports = unbanCommand;