jsdecryptor 4.0.3

package/davexcore/anti/antidemote.js

@@ -0,0 +1,352 @@
+const { getGroupConfig, setGroupConfig } = require('../../Database/settingsStore');
+const db = require('../../Database/database');
+const isAdmin = require('../../davelib/isAdmin');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+const { getPrefix } = require('../owner/setprefix');
+
+function normalizeJid(jid) {
+    if (!jid) return '';
+    const str = typeof jid === 'string' ? jid : (jid.id || jid.toString());
+    const num = str.split('@')[0].split(':')[0];
+    return num + '@s.whatsapp.net';
+}
+
+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 handleAntidemote(sock, groupId, participants, author) {
+    try {
+        const config = getGroupConfig(groupId, 'antidemote');
+        if (!config || !config.enabled) return false;
+
+        const botName = getBotName();
+        const fake = createFakeContact();
+        const botJid = normalizeJid(sock.user?.id);
+
+        let groupMetadata;
+        try {
+            groupMetadata = await sock.groupMetadata(groupId);
+        } catch (metaErr) {
+            console.error('Antidemote: Failed to fetch group metadata:', metaErr.message);
+            return false;
+        }
+
+        const ownerJid = normalizeJid(groupMetadata.owner);
+        const normalizedAuthor = normalizeJid(author);
+        const isAuthorOwner = normalizedAuthor === ownerJid ||
+                             (author && groupMetadata.owner && author === groupMetadata.owner);
+
+        const isAuthorSudo = db.isSudo(author) || db.isSudo(normalizedAuthor);
+
+        if (isAuthorOwner || isAuthorSudo) {
+            return false;
+        }
+
+        // Bot's own actions should not trigger antidemote
+        const authorNum = author?.split('@')[0]?.split(':')[0];
+        const botNum = sock.user?.id?.split(':')[0]?.split('@')[0];
+        const botLidNum = sock.user?.lid?.split(':')[0]?.split('@')[0];
+        if (authorNum === botNum || (botLidNum && authorNum === botLidNum)) {
+            return false;
+        }
+
+        const participantJids = participants.map(p => typeof p === 'string' ? p : (p.id || String(p)));
+        const mode = config.mode || 'revert';
+
+        const botLid = sock.user?.lid;
+        const botLidNorm = botLid ? normalizeJid(botLid) : null;
+        const isBotDemoted = participantJids.some(p => {
+            const norm = normalizeJid(p);
+            if (norm === botJid) return true;
+            if (botLidNorm && norm === botLidNorm) return true;
+            const pNum = p.split('@')[0].split(':')[0];
+            if (pNum === botNum) return true;
+            if (botLidNum && pNum === botLidNum) return true;
+            return false;
+        });
+
+        const botParticipant = groupMetadata.participants.find(p => {
+            if (normalizeJid(p.id) === botJid || p.id === botJid) return true;
+            if (botLidNorm && (normalizeJid(p.id) === botLidNorm || p.id === botLid)) return true;
+            const pNum = (p.id || '').split('@')[0].split(':')[0];
+            if (pNum === botNum) return true;
+            if (botLidNum && pNum === botLidNum) return true;
+            return false;
+        });
+        // Fallback: if bot not found in participant list, assume it's still admin
+        const isBotAdmin = !botParticipant || botParticipant.admin === 'admin' || botParticipant.admin === 'superadmin';
+
+        // If the BOT itself was demoted, alert owner immediately regardless of current admin state
+        if (isBotDemoted) {
+            const authorNumber = await resolveToPhone(sock, author);
+            let groupName = '';
+            try { groupName = groupMetadata.subject || groupId; } catch {}
+            const ownerNumber = sock.user.id.split(':')[0] + '@s.whatsapp.net';
+            // Alert owner in DM
+            try {
+                await sock.sendMessage(ownerNumber, {
+                    text: `⚠️ *${botName} - BOT DEMOTED*\n\n*Group:* ${groupName}\n*Demoted by:* @${authorNumber}\n\nAntidemote cannot protect the group until you re-promote me!\nRe-add me as admin to restore protection.`,
+                    mentions: [author]
+                });
+            } catch {}
+            // Warn in the group
+            await sock.sendMessage(groupId, {
+                text: `┌─ *${botName}* ─┐\n│\n│ ⚠️ I was demoted by @${authorNumber}!\n│ I can no longer protect this group.\n│ Owner has been notified.\n│\n└─────────────┘`,
+                mentions: [author]
+            }, { quoted: fake });
+            return false;
+        }
+
+        if (!isBotAdmin) {
+            await sock.sendMessage(groupId, {
+                text: `┌─ *${botName}* ─┐\n│\n│ Cannot reverse demotion - bot needs admin!\n│\n└─────────────┘`
+            }, { quoted: fake });
+            return false;
+        }
+
+        const authorNumber = await resolveToPhone(sock, author);
+        const targetNumber = await resolveToPhone(sock, participantJids[0]);
+
+        try {
+            await sock.groupParticipantsUpdate(groupId, participantJids, "promote");
+            console.log(`[ANTIDEMOTE] Reverted demotion of ${targetNumber} in ${groupId}`);
+        } catch (promoteErr) {
+            console.log('[ANTIDEMOTE] Promote call returned:', promoteErr.message, '(action may still have succeeded)');
+        }
+
+        if (mode === 'kick') {
+            try {
+                await sock.groupParticipantsUpdate(groupId, [author], "remove");
+            } catch (e) {}
+            await sock.sendMessage(groupId, {
+                text: `┌─ *${botName}* ─┐
+│
+│ @${authorNumber} tried to demote @${targetNumber}
+│ Demotion reverted & offender kicked!
+│
+└─────────────┘`,
+                mentions: [author, ...participantJids]
+            }, { quoted: fake });
+        } else if (mode === 'warn') {
+            const maxWarnings = config.maxWarnings || 3;
+            const warningCount = db.incrementWarning(groupId, author);
+            if (warningCount >= maxWarnings) {
+                try {
+                    await sock.groupParticipantsUpdate(groupId, [author], "remove");
+                } catch (e) {}
+                db.resetWarning(groupId, author);
+                await sock.sendMessage(groupId, {
+                    text: `┌─ *${botName}* ─┐
+│
+│ @${authorNumber} tried to demote @${targetNumber}
+│ Demotion reverted & kicked after ${maxWarnings} warnings!
+│
+└─────────────┘`,
+                    mentions: [author, ...participantJids]
+                }, { quoted: fake });
+            } else {
+                await sock.sendMessage(groupId, {
+                    text: `┌─ *${botName}* ─┐
+│
+│ @${authorNumber} tried to demote @${targetNumber}
+│ Demotion reverted! Warning ${warningCount}/${maxWarnings}
+│
+└─────────────┘`,
+                    mentions: [author, ...participantJids]
+                }, { quoted: fake });
+            }
+        } else {
+            try {
+                await sock.groupParticipantsUpdate(groupId, [author], "demote");
+            } catch (e) {}
+            await sock.sendMessage(groupId, {
+                text: `┌─ *${botName}* ─┐
+│
+│ @${authorNumber} tried to demote @${targetNumber}
+│ Demotion reverted & offender demoted!
+│
+└─────────────┘`,
+                mentions: [author, ...participantJids]
+            }, { quoted: fake });
+        }
+
+        return true;
+    } catch (error) {
+        console.error('Error in handleAntidemote:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        return false;
+    }
+}
+
+async function antidemoteCommand(sock, chatId, message, senderId) {
+    try {
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+        const prefix = getPrefix();
+
+        const userMessage = message.message?.conversation || 
+                          message.message?.extendedTextMessage?.text || '';
+        const args = userMessage.split(' ');
+        const subCmd = args[1]?.toLowerCase();
+
+        if (!chatId.endsWith('@g.us')) {
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐\n│\n│ Group command only!\n│\n└─────────────┘`
+            }, { quoted: fake });
+            return;
+        }
+
+        const adminStatus = await isAdmin(sock, chatId, senderId);
+        const isSenderAdmin = adminStatus.isSenderAdmin;
+        const isBotAdmin = adminStatus.isBotAdmin;
+
+        if (!isBotAdmin) {
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐\n│\n│ Bot needs to be admin!\n│\n└─────────────┘`
+            }, { quoted: fake });
+            return;
+        }
+
+        if (!isSenderAdmin && !message.key.fromMe && !db.isSudo(senderId)) {
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐\n│\n│ Admin only command!\n│\n└─────────────┘`
+            }, { quoted: fake });
+            return;
+        }
+
+        const config = getGroupConfig(chatId, 'antidemote') || { enabled: false, mode: 'revert' };
+
+        if (!subCmd || subCmd === 'help') {
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐
+│
+│ Status: ${config.enabled ? 'ON' : 'OFF'}
+│ Mode: ${(config.mode || 'revert').toUpperCase()}
+│
+│ Commands:
+│ ${prefix}antidemote on
+│ ${prefix}antidemote off
+│ ${prefix}antidemote revert
+│ ${prefix}antidemote warn
+│ ${prefix}antidemote kick
+│ ${prefix}antidemote setwarn <num>
+│ ${prefix}antidemote status
+│
+│ Modes:
+│ REVERT - Undo demotion
+│ WARN - Revert + warn
+│ KICK - Revert + kick
+│
+└─────────────┘`
+            }, { quoted: fake });
+            return;
+        }
+
+        if (subCmd === 'status') {
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐
+│
+│ Antidemote: ${config.enabled ? 'ACTIVE' : 'INACTIVE'}
+│ Mode: ${(config.mode || 'revert').toUpperCase()}
+│
+└─────────────┘`
+            }, { quoted: fake });
+            return;
+        }
+
+        if (subCmd === 'setwarn') {
+            const num = parseInt(args[2]);
+            if (num > 0 && num <= 10) {
+                setGroupConfig(chatId, 'antidemote', { ...config, maxWarnings: num });
+                await sock.sendMessage(chatId, {
+                    text: `┌─ *${botName}* ─┐
+│
+│ Max warnings set to: ${num}
+│
+└─────────────┘`
+                }, { quoted: fake });
+            } else {
+                await sock.sendMessage(chatId, {
+                    text: `┌─ *${botName}* ─┐
+│
+│ Invalid number! Use 1-10
+│
+└─────────────┘`
+                }, { quoted: fake });
+            }
+            return;
+        }
+
+        if (subCmd === 'on') {
+            setGroupConfig(chatId, 'antidemote', { ...config, enabled: true });
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐
+│
+│ Antidemote ENABLED
+│ Mode: ${(config.mode || 'revert').toUpperCase()}
+│
+└─────────────┘`
+            }, { quoted: fake });
+        } else if (subCmd === 'off') {
+            setGroupConfig(chatId, 'antidemote', { ...config, enabled: false });
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐
+│
+│ Antidemote DISABLED
+│
+└─────────────┘`
+            }, { quoted: fake });
+        } else if (['revert', 'kick', 'warn'].includes(subCmd)) {
+            setGroupConfig(chatId, 'antidemote', { ...config, enabled: true, mode: subCmd });
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐
+│
+│ Mode set to: ${subCmd.toUpperCase()}
+│ Antidemote ENABLED
+│
+└─────────────┘`
+            }, { quoted: fake });
+        } else {
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐
+│
+│ Invalid option!
+│ Use: on, off, revert, kick, warn, status
+│
+└─────────────┘`
+            }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Error in antidemoteCommand:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+module.exports = {
+    handleAntidemote,
+    antidemoteCommand
+};

package/davexcore/anti/antidocument.js

@@ -0,0 +1,105 @@
+const { getGroupConfig, setGroupConfig, deleteGroupToggle } = require('../../Database/settingsStore');
+const isAdmin = require('../../davelib/isAdmin');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function antidocumentCommand(sock, chatId, userMessage, senderId, isSenderAdmin, message) {
+    try {
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+
+        if (!isSenderAdmin && !message?.key?.fromMe && !db.isSudo(senderId)) {
+            await sock.sendMessage(chatId, { text: `*${botName}*\nAdmin only command!` }, { quoted: fake });
+            return;
+        }
+
+        const args = userMessage.slice(13).toLowerCase().trim().split(' ');
+        const action = args[0];
+
+        if (!action) {
+            const config = getGroupConfig(chatId, 'antidocument') || { enabled: false };
+            const currentMode = config.enabled ? (config.action || 'delete') : 'off';
+
+            const usage = `*${botName} ANTI-DOCUMENT*\n\nCurrent Mode: ${currentMode.toUpperCase()}\n\n*Commands:*\n.antidocument off - Disable\n.antidocument delete - Delete document\n.antidocument warn - Delete + warn\n.antidocument kick - Delete + kick`;
+
+            await sock.sendMessage(chatId, { text: usage }, { quoted: fake });
+            return;
+        }
+
+        const validModes = ["off", "delete", "warn", "kick"];
+
+        if (!validModes.includes(action)) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nInvalid mode! Use: off, delete, warn, kick` 
+            }, { quoted: fake });
+            return;
+        }
+
+        if (action === 'off') {
+            deleteGroupToggle(chatId, 'antidocument');
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nAnti-Document DISABLED` 
+            }, { quoted: fake });
+        } else {
+            setGroupConfig(chatId, 'antidocument', { enabled: true, action: action });
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nAnti-Document: ${action.toUpperCase()}` 
+            }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Error in antidocument command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+async function handleDocumentDetection(sock, chatId, message, senderId) {
+    try {
+        const isDocument = message.type === 'documentMessage' || 
+                          (message.message && message.message.documentMessage);
+
+        if (!isDocument) return;
+        if (!chatId.endsWith('@g.us')) return;
+
+        const config = getGroupConfig(chatId, 'antidocument');
+        if (!config || !config.enabled) return;
+
+        const { isSenderAdmin, isBotAdmin } = await isAdmin(sock, chatId, senderId);
+        if (!isBotAdmin || isSenderAdmin || db.isSudo(senderId)) return;
+
+        const botName = getBotName();
+        const userTag = `@${senderId.split("@")[0]}`;
+
+        try {
+            await sock.sendMessage(chatId, {
+                delete: {
+                    remoteJid: chatId,
+                    fromMe: false,
+                    id: message.key.id,
+                    participant: senderId
+                }
+            });
+        } catch (e) {
+            console.error("[ANTI-DOCUMENT] Delete failed:", e.message);
+            return;
+        }
+
+        if (config.action === 'kick') {
+            await sock.sendMessage(chatId, {
+                text: `*${botName}*\n\n${userTag} kicked for sending document.`,
+                mentions: [senderId]
+            });
+            await sock.groupParticipantsUpdate(chatId, [senderId], 'remove');
+        } else if (config.action === 'warn') {
+            await sock.sendMessage(chatId, {
+                text: `*${botName}*\n\n${userTag}, documents are not allowed!`,
+                mentions: [senderId]
+            });
+        }
+    } catch (error) {
+        console.error('Error in handleDocumentDetection:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+module.exports = {
+    antidocumentCommand,
+    handleDocumentDetection
+};