jsdecryptor 4.0.3

package/davexcore/anti/mention.js

@@ -0,0 +1,242 @@
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+const { downloadContentFromMessage } = require('@whiskeysockets/baileys');
+const { getOwnerConfig, setOwnerConfig, parseToggleCommand } = require('../../Database/settingsStore');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function isAuthorized(sock, message) {
+    try {
+        const senderId = message.key.participant || message.key.remoteJid;
+        if (message.key.fromMe) return true;
+        return db.isSudo(senderId);
+    } catch {
+        return message.key.fromMe;
+    }
+}
+
+function loadState() {
+    try {
+        const config = getOwnerConfig('mention');
+        return config || { enabled: false, assetPath: 'assets/mention_default.webp', type: 'sticker' };
+    } catch {
+        return { enabled: false, assetPath: 'assets/mention_default.webp', type: 'sticker' };
+    }
+}
+
+function saveState(state) {
+    setOwnerConfig('mention', state);
+}
+
+async function ensureDefaultSticker(state) {
+    try {
+        const assetPath = path.join(__dirname, '..', state.assetPath);
+        if (state.assetPath.endsWith('mention_default.webp') && !fs.existsSync(assetPath)) {
+            const url = 'https://o.uguu.se/KHSyEtdc.webp';
+            const res = await axios.get(url, { responseType: 'arraybuffer' });
+            const assetsDir = path.join(__dirname, '..', 'assets');
+            if (!fs.existsSync(assetsDir)) {
+                fs.mkdirSync(assetsDir, { recursive: true });
+            }
+            fs.writeFileSync(assetPath, Buffer.from(res.data));
+        }
+    } catch (e) {
+        // Silently ignore - sticker download may fail on external hosts
+    }
+}
+
+async function handleMentionDetection(sock, chatId, message) {
+    try {
+        if (message.key?.fromMe) return;
+
+        const state = loadState();
+        await ensureDefaultSticker(state);
+        if (!state.enabled) return;
+
+        const rawId = sock.user?.id || sock.user?.jid || '';
+        if (!rawId) return;
+        const botNum = rawId.split('@')[0].split(':')[0];
+        const botJids = [
+            `${botNum}@s.whatsapp.net`,
+            `${botNum}@whatsapp.net`,
+            rawId
+        ];
+
+        const msg = message.message || {};
+        const contexts = [
+            msg.extendedTextMessage?.contextInfo,
+            msg.imageMessage?.contextInfo,
+            msg.videoMessage?.contextInfo,
+            msg.documentMessage?.contextInfo,
+            msg.stickerMessage?.contextInfo,
+            msg.buttonsResponseMessage?.contextInfo,
+            msg.listResponseMessage?.contextInfo
+        ].filter(Boolean);
+
+        let mentioned = [];
+        for (const c of contexts) {
+            if (Array.isArray(c.mentionedJid)) {
+                mentioned = mentioned.concat(c.mentionedJid);
+            }
+        }
+
+        if (!mentioned.length) return;
+        const isBotMentioned = mentioned.some(j => botJids.includes(j));
+        if (!isBotMentioned) return;
+
+        const assetPath = path.join(__dirname, '..', state.assetPath);
+        if (state.type === 'sticker' && fs.existsSync(assetPath)) {
+            await sock.sendMessage(chatId, { sticker: fs.readFileSync(assetPath) }, { quoted: fakeContact });
+            return;
+        }
+        if (fs.existsSync(assetPath)) {
+            const payload = {};
+            if (state.type === 'image') {
+                payload.image = fs.readFileSync(assetPath);
+            } else if (state.type === 'video') {
+                payload.video = fs.readFileSync(assetPath);
+            } else if (state.type === 'audio') {
+                payload.audio = fs.readFileSync(assetPath);
+                payload.ptt = true;
+            }
+            if (Object.keys(payload).length) {
+                await sock.sendMessage(chatId, payload, { quoted: fakeContact });
+            }
+        }
+    } catch (error) {
+        console.error('Mention detection error:', error?.message, 'Line:', error?.stack?.split('\n')[1]);
+    }
+}
+
+async function mentionToggleCommand(sock, chatId, message) {
+    try {
+        const senderId = message.key.participant || message.key.remoteJid;
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+
+        if (!await isAuthorized(sock, message)) {
+            await sock.sendMessage(chatId, { text: `*${botName}*\nOwner only command!` }, { quoted: fake });
+            return;
+        }
+
+        const text = message.message?.conversation || message.message?.extendedTextMessage?.text || '';
+        const args = text.trim().split(' ').slice(1);
+        const action = args[0]?.toLowerCase();
+
+        const state = loadState();
+
+        if (!action) {
+            const helpText = `*${botName} MENTION REPLY*\n\n` +
+                `Status: ${state.enabled ? 'ON' : 'OFF'}\n` +
+                `Type: ${state.type}\n\n` +
+                `*Commands:*\n` +
+                `.mention on - Enable\n` +
+                `.mention off - Disable\n` +
+                `.setmention - Set custom sticker/image`;
+            await sock.sendMessage(chatId, { text: helpText }, { quoted: fake });
+            return;
+        }
+
+        const toggle = parseToggleCommand(action);
+        if (toggle === 'on') {
+            state.enabled = true;
+            saveState(state);
+            await sock.sendMessage(chatId, { text: `*${botName}*\nMention reply ENABLED` }, { quoted: fake });
+        } else if (toggle === 'off') {
+            state.enabled = false;
+            saveState(state);
+            await sock.sendMessage(chatId, { text: `*${botName}*\nMention reply DISABLED` }, { quoted: fake });
+        } else {
+            await sock.sendMessage(chatId, { text: `*${botName}*\nUse: on or off` }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Error in mention toggle:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+async function setMentionCommand(sock, chatId, message) {
+    try {
+        const senderId = message.key.participant || message.key.remoteJid;
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+
+        if (!await isAuthorized(sock, message)) {
+            await sock.sendMessage(chatId, { text: `*${botName}*\nOwner only command!` }, { quoted: fake });
+            return;
+        }
+
+        const quoted = message.message?.extendedTextMessage?.contextInfo?.quotedMessage;
+
+        if (!quoted) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nReply to a sticker, image, video, or audio to set it as mention reply.`
+            }, { quoted: fake });
+            return;
+        }
+
+        const state = loadState();
+        let mediaType = null;
+        let mediaMessage = null;
+
+        if (quoted.stickerMessage) {
+            mediaType = 'sticker';
+            mediaMessage = quoted.stickerMessage;
+        } else if (quoted.imageMessage) {
+            mediaType = 'image';
+            mediaMessage = quoted.imageMessage;
+        } else if (quoted.videoMessage) {
+            mediaType = 'video';
+            mediaMessage = quoted.videoMessage;
+        } else if (quoted.audioMessage) {
+            mediaType = 'audio';
+            mediaMessage = quoted.audioMessage;
+        }
+
+        if (!mediaType || !mediaMessage) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nUnsupported media type. Use sticker, image, video, or audio.`
+            }, { quoted: fake });
+            return;
+        }
+
+        try {
+            const stream = await downloadContentFromMessage(mediaMessage, mediaType === 'sticker' ? 'sticker' : mediaType);
+            let buffer = Buffer.from([]);
+            for await (const chunk of stream) {
+                buffer = Buffer.concat([buffer, chunk]);
+            }
+
+            const assetsDir = path.join(__dirname, '..', 'assets');
+            if (!fs.existsSync(assetsDir)) {
+                fs.mkdirSync(assetsDir, { recursive: true });
+            }
+
+            const ext = mediaType === 'sticker' ? 'webp' : (mediaType === 'image' ? 'jpg' : (mediaType === 'video' ? 'mp4' : 'mp3'));
+            const filename = `mention_custom.${ext}`;
+            const filePath = path.join(assetsDir, filename);
+            fs.writeFileSync(filePath, buffer);
+
+            state.assetPath = `assets/${filename}`;
+            state.type = mediaType;
+            state.enabled = true;
+            saveState(state);
+
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nMention reply set to ${mediaType}!`
+            }, { quoted: fake });
+        } catch (downloadError) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nFailed to download media: ${downloadError.message}`
+            }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Error in setmention:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+module.exports = {
+    handleMentionDetection,
+    mentionToggleCommand,
+    setMentionCommand
+};

package/davexcore/automation/alwaysonline.js

@@ -0,0 +1,226 @@
+const { getOwnerConfig, setOwnerConfig, parseToggleCommand } = require('../../Database/settingsStore');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+let presenceInterval = null;
+
+async function isAuthorized(sock, message) {
+    try {
+        const senderId = message.key.participant || message.key.remoteJid;
+        if (message.key.fromMe) return true;
+        return db.isSudo(senderId);
+    } catch {
+        return message.key.fromMe;
+    }
+}
+
+async function alwaysonlineCommand(sock, chatId, message) {
+    try {
+        const senderId = message.key.participant || message.key.remoteJid;
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+
+        if (!await isAuthorized(sock, message)) {
+            return sock.sendMessage(chatId, { 
+                text: `┌─ *${botName}* ─┐\n│\n│ Owner only command!\n│\n└─────────────┘` 
+            }, { quoted: fake });
+        }
+
+        const text = message.message?.conversation || message.message?.extendedTextMessage?.text || '';
+        const args = text.trim().split(/\s+/).slice(1);
+        const action = args[0]?.toLowerCase();
+
+        const config = getOwnerConfig('alwaysonline') || { enabled: false };
+
+        if (!action) {
+            const newState = !config.enabled;
+            if (newState) {
+                setOwnerConfig('alwaysonline', { enabled: true });
+                setOwnerConfig('alwaysoffline', { enabled: false });
+                startPresenceLoop(sock, 'available');
+                await sock.sendMessage(chatId, { 
+                    text: `┌─ *${botName}* ─┐
+│
+│ Always Online ENABLED
+│ Bot will appear online
+│
+└─────────────┘` 
+                }, { quoted: fake });
+            } else {
+                setOwnerConfig('alwaysonline', { enabled: false });
+                stopPresenceLoop();
+                await sock.sendMessage(chatId, { 
+                    text: `┌─ *${botName}* ─┐
+│
+│ Always Online DISABLED
+│
+└─────────────┘` 
+                }, { quoted: fake });
+            }
+            return;
+        }
+
+        const toggle = parseToggleCommand(action);
+        if (toggle === 'on') {
+            setOwnerConfig('alwaysonline', { enabled: true });
+            setOwnerConfig('alwaysoffline', { enabled: false });
+            startPresenceLoop(sock, 'available');
+            await sock.sendMessage(chatId, { 
+                text: `┌─ *${botName}* ─┐
+│
+│ Always Online ENABLED
+│ Bot will appear online
+│
+└─────────────┘` 
+            }, { quoted: fake });
+        } else if (toggle === 'off') {
+            setOwnerConfig('alwaysonline', { enabled: false });
+            stopPresenceLoop();
+            await sock.sendMessage(chatId, { 
+                text: `┌─ *${botName}* ─┐
+│
+│ Always Online DISABLED
+│
+└─────────────┘` 
+            }, { quoted: fake });
+        } else {
+            await sock.sendMessage(chatId, { 
+                text: `┌─ *${botName}* ─┐
+│
+│ Status: ${config.enabled ? 'ON' : 'OFF'}
+│
+│ Commands:
+│ .alwaysonline - Toggle
+│ .alwaysonline on
+│ .alwaysonline off
+│
+└─────────────┘` 
+            }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Error in alwaysonline:', error.message);
+    }
+}
+
+async function alwaysofflineCommand(sock, chatId, message) {
+    try {
+        const senderId = message.key.participant || message.key.remoteJid;
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+
+        if (!await isAuthorized(sock, message)) {
+            return sock.sendMessage(chatId, { 
+                text: `┌─ *${botName}* ─┐\n│\n│ Owner only command!\n│\n└─────────────┘` 
+            }, { quoted: fake });
+        }
+
+        const text = message.message?.conversation || message.message?.extendedTextMessage?.text || '';
+        const args = text.trim().split(/\s+/).slice(1);
+        const action = args[0]?.toLowerCase();
+
+        const config = getOwnerConfig('alwaysoffline') || { enabled: false };
+
+        if (!action) {
+            const newState = !config.enabled;
+            if (newState) {
+                setOwnerConfig('alwaysoffline', { enabled: true });
+                setOwnerConfig('alwaysonline', { enabled: false });
+                startPresenceLoop(sock, 'unavailable');
+                await sock.sendMessage(chatId, { 
+                    text: `┌─ *${botName}* ─┐
+│
+│ Always Offline ENABLED
+│ Bot will appear offline
+│
+└─────────────┘` 
+                }, { quoted: fake });
+            } else {
+                setOwnerConfig('alwaysoffline', { enabled: false });
+                stopPresenceLoop();
+                await sock.sendMessage(chatId, { 
+                    text: `┌─ *${botName}* ─┐
+│
+│ Always Offline DISABLED
+│
+└─────────────┘` 
+                }, { quoted: fake });
+            }
+            return;
+        }
+
+        const toggle = parseToggleCommand(action);
+        if (toggle === 'on') {
+            setOwnerConfig('alwaysoffline', { enabled: true });
+            setOwnerConfig('alwaysonline', { enabled: false });
+            startPresenceLoop(sock, 'unavailable');
+            await sock.sendMessage(chatId, { 
+                text: `┌─ *${botName}* ─┐
+│
+│ Always Offline ENABLED
+│ Bot will appear offline
+│
+└─────────────┘` 
+            }, { quoted: fake });
+        } else if (toggle === 'off') {
+            setOwnerConfig('alwaysoffline', { enabled: false });
+            stopPresenceLoop();
+            await sock.sendMessage(chatId, { 
+                text: `┌─ *${botName}* ─┐
+│
+│ Always Offline DISABLED
+│
+└─────────────┘` 
+            }, { quoted: fake });
+        } else {
+            await sock.sendMessage(chatId, { 
+                text: `┌─ *${botName}* ─┐
+│
+│ Status: ${config.enabled ? 'ON' : 'OFF'}
+│
+│ Commands:
+│ .alwaysoffline - Toggle
+│ .alwaysoffline on
+│ .alwaysoffline off
+│
+└─────────────┘` 
+            }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Error in alwaysoffline:', error.message);
+    }
+}
+
+function startPresenceLoop(sock, presenceType) {
+    stopPresenceLoop();
+    try { sock.sendPresenceUpdate(presenceType); } catch(e) {}
+    presenceInterval = setInterval(async () => {
+        try {
+            await sock.sendPresenceUpdate(presenceType);
+        } catch (e) {}
+    }, 10000);
+}
+
+function stopPresenceLoop() {
+    if (presenceInterval) {
+        clearInterval(presenceInterval);
+        presenceInterval = null;
+    }
+}
+
+function initPresenceOnConnect(sock) {
+    const onlineConfig = getOwnerConfig('alwaysonline') || { enabled: false };
+    const offlineConfig = getOwnerConfig('alwaysoffline') || { enabled: false };
+    if (onlineConfig.enabled) {
+        startPresenceLoop(sock, 'available');
+    } else if (offlineConfig.enabled) {
+        startPresenceLoop(sock, 'unavailable');
+    }
+}
+
+module.exports = {
+    alwaysonlineCommand,
+    alwaysofflineCommand,
+    initPresenceOnConnect,
+    startPresenceLoop,
+    stopPresenceLoop
+};

package/davexcore/automation/autoReadReciepts.js

@@ -0,0 +1,96 @@
+const { getOwnerConfig, setOwnerConfig, parseToggleCommand } = require('../../Database/settingsStore');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+const DEFAULT_CONFIG = {
+    enabled: false,
+    readReceipts: 'all'
+};
+
+async function isAuthorized(sock, message) {
+    try {
+        const senderId = message.key.participant || message.key.remoteJid;
+        if (message.key.fromMe) return true;
+        return db.isSudo(senderId);
+    } catch {
+        return message.key.fromMe;
+    }
+}
+
+function loadConfig() {
+    try {
+        return getOwnerConfig('autoreadreceipts') || { ...DEFAULT_CONFIG };
+    } catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}
+
+function saveConfig(config) {
+    setOwnerConfig('autoreadreceipts', config);
+}
+
+async function autoreadReceiptsCommand(sock, chatId, message) {
+    try {
+        const senderId = message.key.participant || message.key.remoteJid;
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+
+        if (!await isAuthorized(sock, message)) {
+            return sock.sendMessage(chatId, { text: `*${botName}*\nOwner only command!` }, { quoted: fake });
+        }
+
+        const text = message.message?.conversation || message.message?.extendedTextMessage?.text || '';
+        const args = text.trim().split(' ').slice(1);
+
+        if (!args.length) {
+            const config = loadConfig();
+            const status = `*${botName} AUTOREAD RECEIPTS*\n\n` +
+                `Status: ${config.enabled ? 'ON' : 'OFF'}\n` +
+                `Mode: ${config.readReceipts}\n\n` +
+                `*Commands:*\n` +
+                `.autoreadreceipts on - Enable\n` +
+                `.autoreadreceipts off - Disable\n` +
+                `.autoreadreceipts all - Read all\n` +
+                `.autoreadreceipts none - Read none`;
+            return sock.sendMessage(chatId, { text: status }, { quoted: fake });
+        }
+
+        const action = args[0].toLowerCase();
+        const config = loadConfig();
+
+        const toggle = parseToggleCommand(action);
+        if (toggle === 'on') {
+            config.enabled = true;
+            saveConfig(config);
+            return sock.sendMessage(chatId, { text: `*${botName}*\nAutoread receipts ENABLED` }, { quoted: fake });
+        } else if (toggle === 'off') {
+            config.enabled = false;
+            saveConfig(config);
+            return sock.sendMessage(chatId, { text: `*${botName}*\nAutoread receipts DISABLED` }, { quoted: fake });
+        } else if (action === 'all' || action === 'none') {
+            config.readReceipts = action;
+            saveConfig(config);
+            return sock.sendMessage(chatId, { text: `*${botName}*\nRead receipts mode: ${action.toUpperCase()}` }, { quoted: fake });
+        } else {
+            return sock.sendMessage(chatId, { text: `*${botName}*\nInvalid option! Use: on, off, all, none` }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Error in autoreadreceipts command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+function isAutoreadReceiptsEnabled() {
+    const config = loadConfig();
+    return config?.enabled || false;
+}
+
+function getReadReceiptsMode() {
+    const config = loadConfig();
+    return config?.readReceipts || 'all';
+}
+
+module.exports = {
+    autoreadReceiptsCommand,
+    isAutoreadReceiptsEnabled,
+    getReadReceiptsMode
+};

package/davexcore/automation/autoread.js

@@ -0,0 +1,104 @@
+const { getOwnerConfig, setOwnerConfig, parseToggleCommand } = require('../../Database/settingsStore');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function isAuthorized(sock, message) {
+    try {
+        const senderId = message.key.participant || message.key.remoteJid;
+        if (message.key.fromMe) return true;
+        return db.isSudo(senderId);
+    } catch {
+        return message.key.fromMe;
+    }
+}
+
+async function autoreadCommand(sock, chatId, message) {
+    try {
+        const senderId = message.key.participant || message.key.remoteJid;
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+
+        if (!await isAuthorized(sock, message)) {
+            await sock.sendMessage(chatId, {
+                text: `✦ Owner only command`
+            }, { quoted: fake });
+            return;
+        }
+
+        const args = message.message?.conversation?.trim().split(' ').slice(1) || 
+                    message.message?.extendedTextMessage?.text?.trim().split(' ').slice(1) || 
+                    [];
+
+        const config = getOwnerConfig('autoread') || { mode: 'off' };
+
+        if (args.length === 0) {
+            const usageText = `✦ *AUTOREAD*
+    
+  Current Mode: ${config.mode}
+
+✦ *Commands:*
+  › on - Read all
+  › pm - PMs only
+  › group - Groups only
+  › off - Disable
+  › status - Show status`;
+
+            await sock.sendMessage(chatId, { text: usageText }, { quoted: fake });
+            return;
+        }
+
+        const action = args[0].toLowerCase();
+        let responseText = '';
+
+        if (action === 'status') {
+            responseText = `✦ Autoread mode: ${config.mode}`;
+        } else if (action === 'on' || action === 'all') {
+            setOwnerConfig('autoread', { mode: 'all' });
+            responseText = `✦ Autoread ENABLED for all messages`;
+        } else if (action === 'off') {
+            setOwnerConfig('autoread', { mode: 'off' });
+            responseText = `✦ Autoread DISABLED`;
+        } else if (action === 'pm') {
+            setOwnerConfig('autoread', { mode: 'pm' });
+            responseText = `✦ Autoread enabled for PMs only`;
+        } else if (action === 'group' || action === 'groups') {
+            setOwnerConfig('autoread', { mode: 'group' });
+            responseText = `✦ Autoread enabled for groups only`;
+        } else {
+            responseText = `✦ Invalid mode! Use: on, off, pm, group`;
+        }
+
+        await sock.sendMessage(chatId, { text: responseText }, { quoted: fake });
+    } catch (error) {
+        console.error('Error in autoread command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+function isAutoreadEnabled() {
+    const config = getOwnerConfig('autoread');
+    return config?.mode && config.mode !== 'off';
+}
+
+async function handleAutoread(sock, message) {
+    try {
+        const config = getOwnerConfig('autoread');
+        if (!config || config.mode === 'off') return;
+
+        const chatId = message.key.remoteJid;
+        const isGroup = chatId.endsWith('@g.us');
+
+        if (config.mode === 'all' || 
+            (config.mode === 'pm' && !isGroup) || 
+            (config.mode === 'group' && isGroup)) {
+            await sock.readMessages([message.key]);
+        }
+    } catch (error) {
+        console.error('Autoread error:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+module.exports = {
+    autoreadCommand,
+    isAutoreadEnabled,
+    handleAutoread
+};