jsdecryptor 4.0.3

package/davexcore/group/groupinfo.js

@@ -0,0 +1,167 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+async function groupInfoCommand(sock, chatId, msg) {
+    try {
+        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;
+        }
+
+        const fake = createFakeContact(msg);
+        
+        if (!chatId.endsWith('@g.us')) {
+            await sock.sendMessage(chatId, { 
+                text: 'This command can only be used in groups!' 
+            }, { quoted: fake });
+            return;
+        }
+
+        const groupMetadata = await Promise.race([
+            sock.groupMetadata(chatId),
+            new Promise((_, reject) => 
+                setTimeout(() => reject(new Error('Timeout fetching group metadata')), 10000)
+            )
+        ]);
+
+        if (!groupMetadata) {
+            throw new Error('Failed to retrieve group metadata');
+        }
+
+        let pp;
+        let ppError = false;
+        try {
+            pp = await sock.profilePictureUrl(chatId, 'image');
+            if (!pp || typeof pp !== 'string') {
+                throw new Error('Invalid profile picture URL');
+            }
+        } catch (error) {
+            console.log('Profile picture error:', error.message);
+            pp = 'https://i.imgur.com/2wzGhpF.jpeg';
+            ppError = true;
+        }
+
+        const participants = groupMetadata.participants || [];
+        const totalMembers = participants.length;
+        
+        const groupAdmins = participants.filter(p => 
+            p.admin && (p.admin === 'admin' || p.admin === 'superadmin')
+        );
+        
+        const owner = groupMetadata.owner || 
+                     groupAdmins.find(p => p.admin === 'superadmin')?.id ||
+                     participants.find(p => p.admin === 'superadmin')?.id ||
+                     'Unknown';
+
+        const adminLines = [];
+        for (let i = 0; i < groupAdmins.length; i++) {
+            const resolved = await resolveToPhone(sock, groupAdmins[i].id);
+            adminLines.push(`${i + 1}. @${resolved}`);
+        }
+        const listAdmin = adminLines.length > 0 
+            ? adminLines.join('\n')
+            : 'No admins found';
+
+        const creationDate = groupMetadata.creation ? 
+            new Date(groupMetadata.creation * 1000).toLocaleDateString() : 
+            'Unknown';
+
+        const description = groupMetadata.desc 
+            ? groupMetadata.desc.toString().trim()
+            : 'No description';
+
+        const maxDescLength = 500;
+        const truncatedDesc = description.length > maxDescLength 
+            ? description.substring(0, maxDescLength) + '...' 
+            : description;
+
+        const isAnnounce = groupMetadata.announce === true || groupMetadata.restrict === true;
+        const groupMode = isAnnounce ? 'Restricted (Only admins can send messages)' : 'Everyone can send messages';
+
+        const resolvedOwner = owner !== 'Unknown' ? await resolveToPhone(sock, owner) : 'Unknown';
+
+        const text = `GROUP INFORMATION
+
+Basic Info:
+Name: ${groupMetadata.subject || 'Unnamed Group'}
+ID: ${groupMetadata.id || 'Unknown'}
+Created: ${creationDate}
+Total Members: ${totalMembers}
+Admins: ${groupAdmins.length}
+Group Mode: ${groupMode}
+
+Ownership:
+Owner: @${resolvedOwner}
+
+Administrators:
+${listAdmin}
+
+Description:
+${truncatedDesc}
+
+'You miss 100% of the shots you dont take' - Wayne Gretzky
+
+${ppError ? 'Note: Using default group image' : ''}`.trim();
+
+        const mentions = [];
+        if (owner && owner !== 'Unknown') {
+            mentions.push(owner);
+        }
+        
+        groupAdmins.forEach(admin => {
+            if (admin.id && !mentions.includes(admin.id) && admin.id !== owner) {
+                mentions.push(admin.id);
+            }
+        });
+
+        await sock.sendMessage(chatId, {
+            image: { url: pp },
+            caption: text,
+            mentions: mentions
+        }, { quoted: fake });
+
+        console.log(`Group info command executed successfully for group: ${groupMetadata.subject}`);
+
+    } catch (error) {
+        console.error('Error in groupinfo command:', error);
+        
+        let errorMessage = 'Failed to get group info!';
+        
+        if (error.message.includes('Timeout')) {
+            errorMessage = 'Request timeout. Please try again.';
+        } else if (error.message.includes('not in group')) {
+            errorMessage = 'Bot is not in this group or group not found.';
+        } else if (error.message.includes('401')) {
+            errorMessage = 'Unauthorized access to group information.';
+        }
+
+        const fake = createFakeContact(msg);
+        await sock.sendMessage(chatId, { 
+            text: errorMessage
+        }, { quoted: fake });
+    }
+}
+
+module.exports = groupInfoCommand;

package/davexcore/group/groupmanage.js

@@ -0,0 +1,133 @@
+const fs = require('fs');
+const path = require('path');
+const { downloadContentFromMessage } = require('@whiskeysockets/baileys');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function ensureGroupAndAdmin(sock, chatId, senderId, message) {
+    const isGroup = chatId.endsWith('@g.us');
+    if (!isGroup) {
+        return { ok: false };
+    }
+    const isAdmin = require('../../davelib/isAdmin');
+    const adminStatus = await isAdmin(sock, chatId, senderId);
+    if (!adminStatus.isBotAdmin) {
+        return { ok: false };
+    }
+    if (!adminStatus.isSenderAdmin && !message?.key?.fromMe && !db.isSudo(senderId)) {
+        return { ok: false };
+    }
+    return { ok: true };
+}
+
+async function setGroupDescription(sock, chatId, senderId, text, message) {
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+    const check = await ensureGroupAndAdmin(sock, chatId, senderId, message);
+    if (!check.ok) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\nAdmin only command!` }, { quoted: fake });
+        return;
+    }
+    const desc = (text || '').trim();
+    if (!desc) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\nUsage: .setgdesc <text>` }, { quoted: fake });
+        return;
+    }
+    try {
+        await sock.groupUpdateDescription(chatId, desc);
+        await sock.sendMessage(chatId, { text: `*${botName}*\nGroup description updated!` }, { quoted: fake });
+    } catch (error) {
+        console.error('Set group description error:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        await sock.sendMessage(chatId, { text: `*${botName}*\nFailed to update description` }, { quoted: fake });
+    }
+}
+
+async function setGroupName(sock, chatId, senderId, text, message) {
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+    const check = await ensureGroupAndAdmin(sock, chatId, senderId, message);
+    if (!check.ok) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\nAdmin only command!` }, { quoted: fake });
+        return;
+    }
+    const name = (text || '').trim();
+    if (!name) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\nUsage: .setgname <name>` }, { quoted: fake });
+        return;
+    }
+    try {
+        await sock.groupUpdateSubject(chatId, name);
+        await sock.sendMessage(chatId, { text: `*${botName}*\nGroup name updated!` }, { quoted: fake });
+    } catch (error) {
+        console.error('Set group name error:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        await sock.sendMessage(chatId, { text: `*${botName}*\nFailed to update name` }, { quoted: fake });
+    }
+}
+
+async function setGroupIcon(sock, chatId, senderId, quotedMessage, message) {
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+    const check = await ensureGroupAndAdmin(sock, chatId, senderId, message);
+    if (!check.ok) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\nAdmin only command!` }, { quoted: fake });
+        return;
+    }
+    if (!quotedMessage?.imageMessage) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\nReply to an image to set as group icon` }, { quoted: fake });
+        return;
+    }
+    try {
+        const stream = await downloadContentFromMessage(quotedMessage.imageMessage, 'image');
+        let buffer = Buffer.from([]);
+        for await (const chunk of stream) {
+            buffer = Buffer.concat([buffer, chunk]);
+        }
+        await sock.updateProfilePicture(chatId, buffer);
+        await sock.sendMessage(chatId, { text: `*${botName}*\nGroup icon updated!` }, { quoted: fake });
+    } catch (error) {
+        console.error('Set group icon error:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        await sock.sendMessage(chatId, { text: `*${botName}*\nFailed to update icon` }, { quoted: fake });
+    }
+}
+
+async function groupLink(sock, chatId, senderId, message) {
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+    const check = await ensureGroupAndAdmin(sock, chatId, senderId, message);
+    if (!check.ok) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\nAdmin only command!` }, { quoted: fake });
+        return;
+    }
+    try {
+        const code = await sock.groupInviteCode(chatId);
+        await sock.sendMessage(chatId, { text: `*${botName}*\n\nGroup Link:\nhttps://chat.whatsapp.com/${code}` }, { quoted: fake });
+    } catch (error) {
+        console.error('Group link error:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        await sock.sendMessage(chatId, { text: `*${botName}*\nFailed to get link` }, { quoted: fake });
+    }
+}
+
+async function revokeGroupLink(sock, chatId, senderId, message) {
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+    const check = await ensureGroupAndAdmin(sock, chatId, senderId, message);
+    if (!check.ok) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\nAdmin only command!` }, { quoted: fake });
+        return;
+    }
+    try {
+        await sock.groupRevokeInvite(chatId);
+        await sock.sendMessage(chatId, { text: `*${botName}*\nGroup link revoked!` }, { quoted: fake });
+    } catch (error) {
+        console.error('Revoke link error:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        await sock.sendMessage(chatId, { text: `*${botName}*\nFailed to revoke link` }, { quoted: fake });
+    }
+}
+
+module.exports = {
+    setGroupDescription,
+    setGroupName,
+    setGroupIcon,
+    groupLink,
+    revokeGroupLink
+};

package/davexcore/group/hidetag.js

@@ -0,0 +1,108 @@
+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 hideTagCommand(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)) {
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nAdmin only command!`
+        }, { quoted: fake });
+        return;
+    }
+
+    try {
+        const groupMetadata = await sock.groupMetadata(chatId);
+        const participants = groupMetadata.participants.map(p => p.id);
+
+        if (replyMessage) {
+            const quotedMsg = message.message?.extendedTextMessage?.contextInfo?.quotedMessage;
+
+            if (quotedMsg?.imageMessage) {
+                const filePath = await downloadMediaMessage(quotedMsg.imageMessage, 'image');
+                await sock.sendMessage(chatId, {
+                    image: fs.readFileSync(filePath),
+                    caption: quotedMsg.imageMessage.caption || '',
+                    mentions: participants
+                });
+                fs.unlinkSync(filePath);
+            } else if (quotedMsg?.videoMessage) {
+                const filePath = await downloadMediaMessage(quotedMsg.videoMessage, 'video');
+                await sock.sendMessage(chatId, {
+                    video: fs.readFileSync(filePath),
+                    caption: quotedMsg.videoMessage.caption || '',
+                    mentions: participants
+                });
+                fs.unlinkSync(filePath);
+            } else if (quotedMsg?.stickerMessage) {
+                const filePath = await downloadMediaMessage(quotedMsg.stickerMessage, 'sticker');
+                await sock.sendMessage(chatId, {
+                    sticker: fs.readFileSync(filePath),
+                    mentions: participants
+                });
+                fs.unlinkSync(filePath);
+            } else if (quotedMsg?.audioMessage) {
+                const filePath = await downloadMediaMessage(quotedMsg.audioMessage, 'audio');
+                await sock.sendMessage(chatId, {
+                    audio: fs.readFileSync(filePath),
+                    ptt: quotedMsg.audioMessage.ptt || false,
+                    mentions: participants
+                });
+                fs.unlinkSync(filePath);
+            } else {
+                const quotedText = quotedMsg?.conversation || 
+                                   quotedMsg?.extendedTextMessage?.text || 
+                                   replyMessage;
+                await sock.sendMessage(chatId, {
+                    text: quotedText,
+                    mentions: participants
+                });
+            }
+        } else if (messageText) {
+            await sock.sendMessage(chatId, {
+                text: messageText,
+                mentions: participants
+            });
+        } else {
+            await sock.sendMessage(chatId, {
+                text: `*${botName}*\nUsage: .hidetag <message> or reply to a message`
+            }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Hidetag error:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        await sock.sendMessage(chatId, {
+            text: `*${botName}*\nError: ${error.message}`
+        }, { quoted: fake });
+    }
+}
+
+module.exports = hideTagCommand;

package/davexcore/group/joinrequests.js

@@ -0,0 +1,145 @@
+const { getBotName, createFakeContact } = require('../../davelib/fakeContact');
+
+async function acceptCommand(sock, chatId, senderId, args, message, fake) {
+    const botName = getBotName();
+    try {
+        if (!chatId.endsWith('@g.us')) {
+            return sock.sendMessage(chatId, {
+                text: `✦ *${botName}* | This command only works in groups.`
+            }, { quoted: fake });
+        }
+
+        const pendingRequests = await sock.groupRequestParticipantsList(chatId);
+
+        if (!pendingRequests || pendingRequests.length === 0) {
+            return sock.sendMessage(chatId, {
+                text: `✦ *${botName}* | No pending join requests in this group.`
+            }, { quoted: fake });
+        }
+
+        if (args && args.trim()) {
+            const number = args.replace(/[^0-9]/g, '');
+            const userJid = `${number}@s.whatsapp.net`;
+            const isPending = pendingRequests.some(r => r.jid === userJid || r.jid.startsWith(number));
+            if (!isPending) {
+                return sock.sendMessage(chatId, {
+                    text: `✦ *${botName}* | No pending request found for +${number}.`
+                }, { quoted: fake });
+            }
+            await sock.groupRequestParticipantsUpdate(chatId, [userJid], 'approve');
+            return sock.sendMessage(chatId, {
+                text: `✦ *${botName}* | ✅ Approved @${number}'s join request!`,
+                mentions: [userJid]
+            }, { quoted: fake });
+        }
+
+        const jids = pendingRequests.map(r => r.jid);
+        await sock.groupRequestParticipantsUpdate(chatId, jids, 'approve');
+
+        const names = pendingRequests.slice(0, 10).map(r => `+${r.jid.split('@')[0]}`).join(', ');
+        const extra = jids.length > 10 ? ` and ${jids.length - 10} more` : '';
+
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* | ✅ Approved *${jids.length}* pending request(s)!\n\n${names}${extra}`
+        }, { quoted: fake });
+
+    } catch (error) {
+        console.error('acceptCommand error:', error.message);
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* | ❌ Failed to approve: ${error.message}`
+        }, { quoted: fake });
+    }
+}
+
+async function rejectCommand(sock, chatId, senderId, args, message, fake) {
+    const botName = getBotName();
+    try {
+        if (!chatId.endsWith('@g.us')) {
+            return sock.sendMessage(chatId, {
+                text: `✦ *${botName}* | This command only works in groups.`
+            }, { quoted: fake });
+        }
+
+        const pendingRequests = await sock.groupRequestParticipantsList(chatId);
+
+        if (!pendingRequests || pendingRequests.length === 0) {
+            return sock.sendMessage(chatId, {
+                text: `✦ *${botName}* | No pending join requests in this group.`
+            }, { quoted: fake });
+        }
+
+        if (args && args.trim()) {
+            const number = args.replace(/[^0-9]/g, '');
+            const userJid = `${number}@s.whatsapp.net`;
+            const isPending = pendingRequests.some(r => r.jid === userJid || r.jid.startsWith(number));
+            if (!isPending) {
+                return sock.sendMessage(chatId, {
+                    text: `✦ *${botName}* | No pending request found for +${number}.`
+                }, { quoted: fake });
+            }
+            await sock.groupRequestParticipantsUpdate(chatId, [userJid], 'reject');
+            return sock.sendMessage(chatId, {
+                text: `✦ *${botName}* | ❌ Rejected @${number}'s join request.`,
+                mentions: [userJid]
+            }, { quoted: fake });
+        }
+
+        const jids = pendingRequests.map(r => r.jid);
+        await sock.groupRequestParticipantsUpdate(chatId, jids, 'reject');
+
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* | ❌ Rejected all *${jids.length}* pending request(s).`
+        }, { quoted: fake });
+
+    } catch (error) {
+        console.error('rejectCommand error:', error.message);
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* | ❌ Failed to reject: ${error.message}`
+        }, { quoted: fake });
+    }
+}
+
+async function acceptAllCommand(sock, chatId, senderId, message, fake) {
+    return acceptCommand(sock, chatId, senderId, '', message, fake);
+}
+
+async function rejectAllCommand(sock, chatId, senderId, message, fake) {
+    return rejectCommand(sock, chatId, senderId, '', message, fake);
+}
+
+async function listRequestsCommand(sock, chatId, senderId, message, fake) {
+    const botName = getBotName();
+    try {
+        const pendingRequests = await sock.groupRequestParticipantsList(chatId);
+
+        if (!pendingRequests || pendingRequests.length === 0) {
+            return sock.sendMessage(chatId, {
+                text: `✦ *${botName}* | No pending join requests.`
+            }, { quoted: fake });
+        }
+
+        const requestList = pendingRequests.map((r, i) => {
+            const number = r.jid.split('@')[0];
+            return `${i + 1}. @${number}`;
+        }).join('\n');
+
+        const mentions = pendingRequests.map(r => r.jid);
+
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* | Pending Join Requests\n\nTotal: *${pendingRequests.length}*\n\n${requestList}\n\n_Use .accept or .acceptall to approve all_\n_Use .accept <number> to approve one_`,
+            mentions
+        }, { quoted: fake });
+    } catch (error) {
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* | ❌ Failed to list requests: ${error.message}`
+        }, { quoted: fake });
+    }
+}
+
+module.exports = {
+    acceptCommand,
+    rejectCommand,
+    acceptAllCommand,
+    rejectAllCommand,
+    listRequestsCommand,
+};

package/davexcore/group/kick.js

@@ -0,0 +1,92 @@
+const isAdmin = require('../../davelib/isAdmin');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function kickCommand(sock, chatId, senderId, mentionedJids, message) {
+    try {
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+
+        if (!chatId.endsWith('@g.us')) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nGroup command only!`
+            }, { quoted: fake });
+            return;
+        }
+
+        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)) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nAdmin only command!`
+            }, { quoted: fake });
+            return;
+        }
+
+        let usersToKick = [];
+
+        if (mentionedJids && mentionedJids.length > 0) {
+            usersToKick = mentionedJids;
+        } else if (message.message?.extendedTextMessage?.contextInfo?.participant) {
+            usersToKick = [message.message.extendedTextMessage.contextInfo.participant];
+        }
+
+        if (usersToKick.length === 0) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nMention or reply to user(s) to kick.\n\nUsage: .kick @user`
+            }, { quoted: fake });
+            return;
+        }
+
+        const botId = sock.user?.id?.split(':')[0] + '@s.whatsapp.net';
+
+        if (usersToKick.includes(botId) || usersToKick.includes(sock.user?.id)) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nI cannot kick myself!`
+            }, { quoted: fake });
+            return;
+        }
+
+        for (const user of usersToKick) {
+            const targetAdmin = await isAdmin(sock, chatId, user);
+            if (targetAdmin.isSenderAdmin) {
+                await sock.sendMessage(chatId, { 
+                    text: `*${botName}*\nCannot kick @${user.split('@')[0]} - they are admin!`,
+                    mentions: [user]
+                }, { quoted: fake });
+                usersToKick = usersToKick.filter(u => u !== user);
+            }
+        }
+
+        if (usersToKick.length === 0) {
+            return;
+        }
+
+        try {
+            await sock.groupParticipantsUpdate(chatId, usersToKick, "remove");
+            
+            const userTags = usersToKick.map(jid => `@${jid.split('@')[0]}`).join(', ');
+            
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\n\n${userTags} kicked from the group!`,
+                mentions: usersToKick
+            }, { quoted: fake });
+        } catch (kickError) {
+            console.error('Kick error:', kickError.message, 'Line:', kickError.stack?.split('\n')[1]);
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nFailed to kick user(s): ${kickError.message}`
+            }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Error in kick command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+module.exports = kickCommand;