jsdecryptor 4.0.3

package/davexcore/group/kickall.js

@@ -0,0 +1,63 @@
+const isAdmin = require('../../davelib/isAdmin');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+async function kickAllCommand(sock, chatId, message, senderId) {
+    const fkontak = createFakeContact(message);
+    
+    try {
+        const isGroup = chatId.endsWith('@g.us');
+        if (!isGroup) {
+            await sock.sendMessage(chatId, { text: 'Group command only.' }, { quoted: fkontak });
+            return;
+        }
+
+        const adminStatus = await isAdmin(sock, chatId, senderId);
+        const isSenderAdmin = adminStatus.isSenderAdmin;
+        const isBotAdmin = adminStatus.isBotAdmin;
+
+        if (!isBotAdmin) {
+            await sock.sendMessage(chatId, { text: 'Bot needs admin.' }, { quoted: fkontak });
+            return;
+        }
+
+        if (!isSenderAdmin) {
+            await sock.sendMessage(chatId, { text: 'Admin only command.' }, { quoted: fkontak });
+            return;
+        }
+
+        const metadata = await sock.groupMetadata(chatId);
+        const participants = metadata.participants || [];
+
+        const botId = sock.user.id;
+        const targets = participants
+            .map(p => p.id)
+            .filter(id => id !== botId && id !== senderId);
+
+        if (targets.length === 0) {
+            await sock.sendMessage(chatId, { text: 'No members.' }, { quoted: fkontak });
+            return;
+        }
+
+        let kickedCount = 0;
+        for (const target of targets) {
+            try {
+                await sock.groupParticipantsUpdate(chatId, [target], 'remove');
+                kickedCount++;
+                await new Promise(r => setTimeout(r, 500));
+            } catch (err) {
+                console.error(`Kick failed ${target}:`, err);
+            }
+        }
+
+        if (kickedCount > 0) {
+            await sock.sendMessage(chatId, { text: `Removed ${kickedCount} member(s).` }, { quoted: fkontak });
+        } else {
+            await sock.sendMessage(chatId, { text: 'No members removed.' }, { quoted: fkontak });
+        }
+
+    } catch (err) {
+        console.error('KickAll error:', err);
+        await sock.sendMessage(chatId, { text: 'Command failed.' }, { quoted: fkontak });
+    }
+}
+
+module.exports = kickAllCommand;

package/davexcore/group/leave.js

@@ -0,0 +1,38 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function leaveGroupCommand(sock, chatId, message) {
+    const fkontak = createFakeContact(message);
+    
+    try {
+        const isOwner = message.key.fromMe;
+        if (!isOwner) {
+            await sock.sendMessage(chatId, { 
+                text: 'Owner only.'
+            }, { quoted: fkontak });
+            return;
+        }
+
+        const chat = await sock.groupMetadata(chatId).catch(() => null);
+        if (!chat) {
+            await sock.sendMessage(chatId, { 
+                text: 'Group only.'
+            }, { quoted: fkontak });
+            return;
+        }
+
+        const groupName = chat.subject || 'group';
+        
+        await sock.sendMessage(chatId, { 
+            text: `Leaving ${groupName}.`
+        }, { quoted: fkontak });
+        
+        await sock.groupLeave(chatId);
+
+        console.log(`Left group: ${groupName}`);
+
+    } catch (error) {
+        console.error('Leave error:', error);
+    }
+}
+
+module.exports = leaveGroupCommand;

package/davexcore/group/linkgroup.js

@@ -0,0 +1,63 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function linkgroupCommand(sock, chatId, message) {
+    const fkontak = createFakeContact(message);
+
+    // Check if it's a group
+    if (!chatId.endsWith('@g.us')) {
+        await sock.sendMessage(chatId, { 
+            text: 'This command only works in groups.'
+        }, { quoted: fkontak });
+        return;
+    }
+
+    try {
+        // Get sender ID from message
+        const senderId = message.key.participant || message.key.remoteJid;
+        
+        // Check if user is owner
+        const isOwner = message.key.fromMe;
+        
+        if (!isOwner) {
+            const { isSenderAdmin, isBotAdmin } = await isAdmin(sock, chatId, senderId);
+
+            if (!isBotAdmin) {
+                await sock.sendMessage(chatId, { 
+                    text: 'Bot needs admin permissions to get group link.'
+                }, { quoted: fkontak });
+                return;
+            }
+
+            if (!isSenderAdmin) {
+                await sock.sendMessage(chatId, { 
+                    text: 'This command requires admin privileges.'
+                }, { quoted: fkontak });
+                return;
+            }
+        }
+
+        // Get invite code and group metadata
+        const code = await sock.groupInviteCode(chatId);
+        const metadata = await sock.groupMetadata(chatId);
+
+        // Send the link
+        await sock.sendMessage(chatId, { 
+            text: `*Group Invite Link*\n\nhttps://chat.whatsapp.com/${code}\n\nGroup: ${metadata.subject}\nMembers: ${metadata.participants.length}\n\n- DAVE X`
+        }, { quoted: fkontak });
+
+    } catch (error) {
+        console.error('Error in linkgroup command:', error);
+        
+        let errorMsg = 'Failed to get group link.';
+        
+        if (error.message?.includes('not-authorized') || error.message?.includes('forbidden')) {
+            errorMsg = 'Bot needs admin permissions to get group link.';
+        }
+        
+        await sock.sendMessage(chatId, { 
+            text: errorMsg
+        }, { quoted: fkontak });
+    }
+}
+
+module.exports = linkgroupCommand;

package/davexcore/group/mute.js

@@ -0,0 +1,57 @@
+const isAdmin = require('../../davelib/isAdmin');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function muteCommand(sock, chatId, senderId, message, duration) {
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+    const { isSenderAdmin, isBotAdmin } = await isAdmin(sock, chatId, senderId);
+
+    if (!isBotAdmin) {
+        return sock.sendMessage(chatId, { text: `*${botName}*\nBot needs admin!` }, { quoted: fake });
+    }
+
+    if (!isSenderAdmin && !message?.key?.fromMe && !db.isSudo(senderId)) {
+        return sock.sendMessage(chatId, { text: `*${botName}*\nAdmin only command!` }, { quoted: fake });
+    }
+
+    try {
+        let groupName = "Group";
+        try {
+            const metadata = await sock.groupMetadata(chatId);
+            groupName = metadata.subject || "Group";
+        } catch (e) {
+            console.error('Metadata error:', e.message);
+        }
+
+        await sock.groupSettingUpdate(chatId, 'announcement');
+
+        if (duration && duration > 0) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\n\n${groupName} muted for ${duration} minutes.` 
+            }, { quoted: fake });
+
+            setTimeout(async () => {
+                try {
+                    await sock.groupSettingUpdate(chatId, 'not_announcement');
+                    await sock.sendMessage(chatId, { 
+                        text: `*${botName}*\n\n${groupName} auto-unmuted.`
+                    }, { quoted: fake });
+                } catch (e) {
+                    console.error('Auto-unmute error:', e.message, 'Line:', e.stack?.split('\n')[1]);
+                }
+            }, duration * 60 * 1000);
+        } else {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\n\n${groupName} has been muted.` 
+            }, { quoted: fake });
+        }
+    } catch (err) {
+        console.error('Mute error:', err.message, 'Line:', err.stack?.split('\n')[1]);
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nFailed to mute group.` 
+        }, { quoted: fake });
+    }
+}
+
+module.exports = muteCommand;

package/davexcore/group/online.js

@@ -0,0 +1,117 @@
+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 onlineCommand(sock, chatId, senderId, message) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+
+    try {
+        await sock.sendMessage(chatId, { text: 'Checking online members... Please wait...' }, { quoted: fake });
+
+        const groupMeta = await sock.groupMetadata(chatId);
+        const participants = groupMeta.participants;
+
+        const presenceData = new Map();
+
+        const presenceHandler = (update) => {
+            if (update.presences) {
+                for (const [jid, presence] of Object.entries(update.presences)) {
+                    presenceData.set(jid, presence);
+                    const numOnly = jid.split('@')[0];
+                    presenceData.set(numOnly, presence);
+                }
+            }
+        };
+
+        sock.ev.on('presence.update', presenceHandler);
+
+        try {
+            const batchSize = 5;
+            for (let i = 0; i < participants.length; i += batchSize) {
+                const batch = participants.slice(i, i + batchSize);
+                await Promise.all(
+                    batch.map(async (p) => {
+                        try {
+                            await sock.presenceSubscribe(p.id);
+                        } catch (e) {}
+                    })
+                );
+                await new Promise(r => setTimeout(r, 500));
+            }
+
+            await new Promise(r => setTimeout(r, 2000));
+
+            const onlineMembers = [];
+
+            for (const p of participants) {
+                const participantId = p.id;
+                const numOnly = participantId.split('@')[0];
+
+                let presence = presenceData.get(participantId) || presenceData.get(numOnly);
+
+                if (presence?.lastKnownPresence === 'available' ||
+                    presence?.lastKnownPresence === 'composing' ||
+                    presence?.lastKnownPresence === 'recording') {
+                    const number = await resolveToPhone(sock, participantId);
+                    onlineMembers.push({ jid: participantId, number });
+                }
+            }
+
+            sock.ev.off('presence.update', presenceHandler);
+
+            if (onlineMembers.length === 0) {
+                await sock.sendMessage(chatId, {
+                    text: `*${botName}*\nNo members detected as currently online.\n\n_Note: This only detects members with "online" visibility enabled._`
+                }, { quoted: fake });
+                return;
+            }
+
+            const mentions = onlineMembers.map(m => m.jid);
+            const memberList = onlineMembers
+                .map((m, i) => `${i + 1}. @${m.number}`)
+                .join('\n');
+
+            await sock.sendMessage(chatId, {
+                text: `*${botName} ONLINE MEMBERS*\n\n*${onlineMembers.length}* of *${participants.length}* members online\n\n${memberList}`,
+                mentions: mentions
+            }, { quoted: fake });
+
+        } catch (innerErr) {
+            sock.ev.off('presence.update', presenceHandler);
+            throw innerErr;
+        }
+    } catch (error) {
+        console.error('Online command error:', error);
+        await sock.sendMessage(chatId, { text: `Failed to check online members: ${error.message}` });
+    }
+}
+
+module.exports = onlineCommand;

package/davexcore/group/pmblocker.js

@@ -0,0 +1,65 @@
+const { getOwnerConfig, setOwnerConfig } = require('../../Database/settingsStore');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+const DEFAULT_MESSAGE = '⚠️ Direct messages are blocked!\nYou cannot DM this bot. Please contact the owner in group chats only.';
+
+function readState() {
+    try {
+        const config = getOwnerConfig('pmblocker');
+        if (!config || typeof config !== 'object') {
+            return { enabled: false, message: DEFAULT_MESSAGE };
+        }
+        return {
+            enabled: !!config.enabled,
+            message: typeof config.message === 'string' && config.message.trim() ? config.message : DEFAULT_MESSAGE
+        };
+    } catch {
+        return { enabled: false, message: DEFAULT_MESSAGE };
+    }
+}
+
+function writeState(enabled, message) {
+    try {
+        const current = readState();
+        const payload = {
+            enabled: !!enabled,
+            message: typeof message === 'string' && message.trim() ? message : current.message
+        };
+        setOwnerConfig('pmblocker', payload);
+    } catch {}
+}
+
+async function pmblockerCommand(sock, chatId, message, args) {
+    const argStr = (args || '').trim();
+    const [sub, ...rest] = argStr.split(' ');
+    const state = readState();
+
+    if (!sub || !['on', 'off', 'status', 'setmsg'].includes(sub.toLowerCase())) {
+        await sock.sendMessage(chatId, { text: '*☣️ AUTO-BLOCK ☣️*\n\n 🔸.pmblocker on - Enable PM auto-block\n 🔸.pmblocker off - Disable PM blocker\n 🔸 .pmblocker status - Show current status\n 🔸 .pmblocker setmsg <text> - Set warning message' }, { quoted: fakeContact });
+        return;
+    }
+
+    if (sub.toLowerCase() === 'status') {
+        await sock.sendMessage(chatId, { text: `PM Blocker is currently *${state.enabled ? 'ON' : 'OFF'}*\nMessage: ${state.message}` }, { quoted: fakeContact });
+        return;
+    }
+
+    if (sub.toLowerCase() === 'setmsg') {
+        const newMsg = rest.join(' ').trim();
+        if (!newMsg) {
+            await sock.sendMessage(chatId, { text: 'Usage: .pmblocker setmsg <message>' }, { quoted: fakeContact });
+            return;
+        }
+        writeState(state.enabled, newMsg);
+        await sock.sendMessage(chatId, { text: 'PM Blocker message updated.' }, { quoted: fakeContact });
+        return;
+    }
+
+    const enable = sub.toLowerCase() === 'on';
+    writeState(enable);
+    await sock.sendMessage(chatId, { text: `PM Blocker is now *${enable ? 'ENABLED' : 'DISABLED'}*.` }, { quoted: fakeContact });
+}
+
+module.exports = { pmblockerCommand, readState };
+
+

package/davexcore/group/promote.js

@@ -0,0 +1,93 @@
+const isAdmin = require('../../davelib/isAdmin');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function promoteCommand(sock, chatId, mentionedJids, message) {
+    const senderId = message.key.participant || message.key.remoteJid;
+    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 adminStatus = await isAdmin(sock, chatId, senderId);
+
+    if (!adminStatus.isBotAdmin) {
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nBot needs admin!`
+        }, { quoted: fake });
+        return;
+    }
+
+    if (!adminStatus.isSenderAdmin && !message.key.fromMe && !db.isSudo(senderId)) {
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nAdmin only command!`
+        }, { quoted: fake });
+        return;
+    }
+    
+    let userToPromote = [];
+
+    if (mentionedJids?.length > 0) {
+        userToPromote = mentionedJids;
+    } else if (message.message?.extendedTextMessage?.contextInfo?.participant) {
+        userToPromote = [message.message.extendedTextMessage.contextInfo.participant];
+    }
+
+    if (userToPromote.length === 0) {
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nMention or reply to promote.`
+        }, { quoted: fake });
+        return;
+    }
+
+    try {
+        await sock.groupParticipantsUpdate(chatId, userToPromote, "promote");
+
+        const promotedUsers = userToPromote.map(jid => `@${jid.split('@')[0]}`).join(', ');
+
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\n\nPromoted: ${promotedUsers}`,
+            mentions: userToPromote
+        }, { quoted: fake });
+    } catch (error) {
+        console.error('Promote error:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nFailed to promote.`
+        }, { quoted: fake });
+    }
+}
+
+async function handlePromotionEvent(sock, groupId, participants, author) {
+    try {
+        if (!Array.isArray(participants) || participants.length === 0) return;
+
+        const botJid = sock.user?.id;
+        const authorJid = typeof author === 'string' ? author : (author?.id || '');
+
+        if (authorJid !== botJid) return;
+
+        const botName = getBotName();
+        const promotedUsers = participants.map(jid => {
+            const jidString = typeof jid === 'string' ? jid : (jid.id || '');
+            return `@${jidString.split('@')[0]}`;
+        }).join(', ');
+
+        const mentionList = participants.map(jid => 
+            typeof jid === 'string' ? jid : (jid.id || '')
+        );
+
+        await sock.sendMessage(groupId, {
+            text: `*${botName}*\n\nPromoted: ${promotedUsers}`,
+            mentions: mentionList
+        });
+    } catch (error) {
+        console.error('Promotion event error:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+module.exports = { promoteCommand, handlePromotionEvent };

package/davexcore/group/resetlink.js

@@ -0,0 +1,57 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function resetlinkCommand(sock, chatId, senderId, message) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    
+    try {
+        const groupMetadata = await sock.groupMetadata(chatId);
+
+        const isAdmin = groupMetadata.participants.some(p => 
+            p.id === senderId && p.admin
+        );
+
+        const botUser = sock.user || sock.state?.legacy?.user;
+        let botId;
+
+        if (botUser && botUser.id) {
+            const rawId = botUser.id.includes(':') ? botUser.id.split(':')[0] : botUser.id;
+            botId = `${rawId}@s.whatsapp.net`;
+        } else {
+            const phoneNumber = sock.authState?.creds?.me?.id || '1234567890';
+            botId = `${phoneNumber.split(':')[0]}@s.whatsapp.net`;
+        }
+
+        const isBotAdmin = groupMetadata.participants.some(p => 
+            p.id === botId && p.admin
+        );
+
+        if (!isAdmin) {
+            await sock.sendMessage(chatId, { 
+                text: `✦ *${botName}*\nAdmins only command` 
+            }, { quoted: fake });
+            return;
+        }
+
+        if (!isBotAdmin) {
+            await sock.sendMessage(chatId, { 
+                text: `✦ *${botName}*\nBot needs admin rights` 
+            }, { quoted: fake });
+            return;
+        }
+
+        const newCode = await sock.groupRevokeInvite(chatId);
+
+        await sock.sendMessage(chatId, { 
+            text: `✦ *${botName}*\n\nGroup link reset\n\nhttps://chat.whatsapp.com/${newCode}`
+        }, { quoted: fake });
+
+    } catch (error) {
+        console.error('Resetlink Error:', error);
+        await sock.sendMessage(chatId, { 
+            text: `✦ *${botName}*\nFailed to reset link`
+        }, { quoted: fake });
+    }
+}
+
+module.exports = resetlinkCommand;

package/davexcore/group/staff.js

@@ -0,0 +1,99 @@
+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 staffCommand(sock, chatId, msg) {
+    try {
+        const groupMetadata = await sock.groupMetadata(chatId);
+        
+        let pp;
+        try {
+            pp = await sock.profilePictureUrl(chatId, 'image');
+        } catch {
+            pp = 'https://i.imgur.com/2wzGhpF.jpeg';
+        }
+
+        const participants = groupMetadata.participants;
+        const groupAdmins = participants.filter(p => p.admin);
+
+        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.join('\n🔵 ');
+        
+        const owner = groupMetadata.owner || groupAdmins.find(p => p.admin === 'superadmin')?.id || chatId.split('-')[0] + '@s.whatsapp.net';
+        
+        const ownerParticipant = participants.find(p => p.id === owner);
+        const ownerName = ownerParticipant?.name || ownerParticipant?.notify || owner.split('@')[0];
+
+        const groupCreation = new Date(groupMetadata.creation * 1000).toLocaleDateString();
+        const groupDesc = groupMetadata.desc || 'No description available';
+        const totalParticipants = participants.length;
+        const adminCount = groupAdmins.length;
+
+        const resolvedOwner = await resolveToPhone(sock, owner);
+
+        const text = `
+ℹ️ *GROUP STAFF INFORMATION*
+
+📛 *Group Name:* ${groupMetadata.subject}
+👑 *Group Owner:* @${resolvedOwner}
+🆔 *Group JID:* ${chatId}
+📅 *Created:* ${groupCreation}
+👥 *Total Members:* ${totalParticipants}
+🛡️ *Admin Count:* ${adminCount}
+
+📝 *Group Description:*
+${groupDesc}
+
+┌───────── ADMIN LIST ────────
+🔵 ${listAdmin}
+
+
+💡 *Note:* Mentioning all admins for easy contact.
+`.trim();
+
+        await sock.sendMessage(chatId, {
+            image: { url: pp },
+            caption: text,
+            mentions: [...groupAdmins.map(v => v.id), owner]
+        });
+
+    } catch (error) {
+        console.error('Error in staff command:', error);
+        await sock.sendMessage(chatId, { 
+            text: 'Failed to get admin list! Error: ' + error.message 
+        });
+    }
+}
+
+module.exports = staffCommand;