jsdecryptor 4.0.3

package/davexcore/automation/autorecording.js

@@ -0,0 +1,197 @@
+const { getOwnerConfig, setOwnerConfig, parseToggleCommand } = require('../../Database/settingsStore');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+const recordingIntervals = new Map();
+
+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 autorecordingCommand(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 text = message.message?.conversation || message.message?.extendedTextMessage?.text || '';
+        const args = text.trim().split(/\s+/).slice(1);
+        const action = args[0]?.toLowerCase();
+        const action2 = args[1]?.toLowerCase();
+
+        const config = getOwnerConfig('autorecording') || { enabled: false, pm: true, group: true };
+
+        if (!action) {
+            const helpText = `✦ *AUTORECORDING*
+    
+  Status: ${config.enabled ? 'ON' : 'OFF'}
+  PM: ${config.pm ? 'ON' : 'OFF'}
+  Group: ${config.group ? 'ON' : 'OFF'}
+
+✦ *Commands:*
+  › on
+  › off
+  › pm
+  › group
+  › both
+  › pm on/off
+  › group on/off
+  › both on/off`;
+            await sock.sendMessage(chatId, { text: helpText }, { quoted: fake });
+            return;
+        }
+
+        let newConfig = { ...config };
+        let responseText = '';
+
+        const toggle = parseToggleCommand(action);
+
+        if (toggle === 'on') {
+            newConfig.enabled = true;
+            newConfig.pm = true;
+            newConfig.group = true;
+            responseText = `✦ Autorecording ENABLED for both PMs & Groups`;
+        } else if (toggle === 'off') {
+            newConfig.enabled = false;
+            stopAllRecordingIntervals();
+            responseText = `✦ Autorecording DISABLED`;
+        } else if (action === 'pm') {
+            const toggle2 = action2 ? parseToggleCommand(action2) : null;
+            if (toggle2 === 'off') {
+                newConfig.pm = false;
+                if (!newConfig.group) newConfig.enabled = false;
+                responseText = `✦ Autorecording PM mode DISABLED\n  Group: ${newConfig.group ? 'ON' : 'OFF'}`;
+            } else {
+                newConfig.pm = true;
+                newConfig.group = false;
+                newConfig.enabled = true;
+                responseText = `✦ Autorecording enabled for PMs only`;
+                if (toggle2 === 'on') {
+                    newConfig.group = config.group;
+                    responseText = `✦ Autorecording PM mode ENABLED\n  Group: ${newConfig.group ? 'ON' : 'OFF'}`;
+                }
+            }
+        } else if (action === 'group') {
+            const toggle2 = action2 ? parseToggleCommand(action2) : null;
+            if (toggle2 === 'off') {
+                newConfig.group = false;
+                if (!newConfig.pm) newConfig.enabled = false;
+                responseText = `✦ Autorecording Group mode DISABLED\n  PM: ${newConfig.pm ? 'ON' : 'OFF'}`;
+            } else {
+                newConfig.group = true;
+                newConfig.pm = false;
+                newConfig.enabled = true;
+                responseText = `✦ Autorecording enabled for Groups only`;
+                if (toggle2 === 'on') {
+                    newConfig.pm = config.pm;
+                    responseText = `✦ Autorecording Group mode ENABLED\n  PM: ${newConfig.pm ? 'ON' : 'OFF'}`;
+                }
+            }
+        } else if (action === 'both') {
+            const toggle2 = action2 ? parseToggleCommand(action2) : null;
+            if (toggle2 === 'off') {
+                newConfig.enabled = false;
+                newConfig.pm = false;
+                newConfig.group = false;
+                stopAllRecordingIntervals();
+                responseText = `✦ Autorecording DISABLED for both PMs & Groups`;
+            } else {
+                newConfig.pm = true;
+                newConfig.group = true;
+                newConfig.enabled = true;
+                responseText = `✦ Autorecording enabled for both PMs & Groups`;
+            }
+        } else {
+            responseText = `✦ Invalid! Use: on, off, pm, group, both\n  Or: pm on/off, group on/off, both on/off`;
+        }
+
+        if (responseText && !responseText.includes('Invalid')) {
+            if (!newConfig.pm && !newConfig.group) {
+                newConfig.enabled = false;
+                stopAllRecordingIntervals();
+            }
+            setOwnerConfig('autorecording', newConfig);
+        }
+
+        await sock.sendMessage(chatId, { text: responseText }, { quoted: fake });
+    } catch (error) {
+        console.error('Error in autorecording command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+function isAutorecordingEnabled() {
+    const config = getOwnerConfig('autorecording');
+    return config?.enabled || false;
+}
+
+function stopAllRecordingIntervals() {
+    for (const [key, interval] of recordingIntervals.entries()) {
+        clearInterval(interval);
+        recordingIntervals.delete(key);
+    }
+}
+
+async function handleAutorecordingForMessage(sock, chatId) {
+    try {
+        const config = getOwnerConfig('autorecording');
+        if (!config?.enabled) return;
+        
+        const isGroup = chatId.endsWith('@g.us');
+        if (isGroup && !config.group) return;
+        if (!isGroup && !config.pm) return;
+        
+        if (recordingIntervals.has(chatId)) {
+            clearInterval(recordingIntervals.get(chatId));
+        }
+
+        await sock.presenceSubscribe(chatId);
+        await sock.sendPresenceUpdate('recording', chatId);
+
+        const interval = setInterval(async () => {
+            try {
+                const currentConfig = getOwnerConfig('autorecording');
+                if (!currentConfig?.enabled) {
+                    clearInterval(interval);
+                    recordingIntervals.delete(chatId);
+                    return;
+                }
+                await sock.sendPresenceUpdate('recording', chatId);
+            } catch (e) {
+                clearInterval(interval);
+                recordingIntervals.delete(chatId);
+            }
+        }, 4000);
+
+        recordingIntervals.set(chatId, interval);
+
+        setTimeout(() => {
+            if (recordingIntervals.has(chatId)) {
+                clearInterval(recordingIntervals.get(chatId));
+                recordingIntervals.delete(chatId);
+                try { sock.sendPresenceUpdate('paused', chatId); } catch(e) {}
+            }
+        }, 30000);
+    } catch (error) {
+        console.error('Autorecording error:', error.message);
+    }
+}
+
+module.exports = {
+    autorecordingCommand,
+    isAutorecordingEnabled,
+    handleAutorecordingForMessage,
+    stopAllRecordingIntervals
+};

package/davexcore/automation/autostatus.js

@@ -0,0 +1,317 @@
+const { getOwnerConfig, setOwnerConfig } = require('../../Database/settingsStore');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+const { isSudo } = require('../../davelib/index');
+
+const emojis = ['❤️', '😂', '😮', '😢', '😡', '👏', '🔥', '⭐', '🎉', '🙏'];
+
+function getRandomEmoji() {
+    return emojis[Math.floor(Math.random() * emojis.length)];
+}
+
+const DEFAULT_AUTOSTATUS_CONFIG = { 
+    enabled: true,
+    reactOn: false,
+    reactionEmoji: '🖤',
+    randomReactions: true 
+};
+
+function readConfig() {
+    try {
+        const config = getOwnerConfig('autostatus');
+        if (!config || typeof config !== 'object') {
+            return { ...DEFAULT_AUTOSTATUS_CONFIG };
+        }
+        return { ...DEFAULT_AUTOSTATUS_CONFIG, ...config };
+    } catch (error) {
+        console.error('Config error:', error);
+        return { ...DEFAULT_AUTOSTATUS_CONFIG };
+    }
+}
+
+function writeConfig(config) {
+    try {
+        setOwnerConfig('autostatus', config);
+        return true;
+    } catch (error) {
+        console.error('Config write error:', error);
+        return false;
+    }
+}
+
+async function autoStatusCommand(sock, chatId, msg, args) {
+    try {
+        const fakeContact = createFakeContact(msg);
+        const senderId = msg.key.participant || msg.key.remoteJid;
+        const senderIsSudo = await isSudo(senderId);
+        const isOwner = msg.key.fromMe || senderIsSudo;
+        
+        if (!isOwner) {
+            await sock.sendMessage(chatId, { text: `✦ Owner only command` }, { quoted: fakeContact });
+            return;
+        }
+
+        let config = readConfig();
+
+        if (!args || args.length === 0) {
+            const text = `✦ *AUTO STATUS*
+    
+✓ Status: ${config.enabled ? 'ON' : 'OFF'}
+✓ Reactions: ${config.reactOn ? 'ON' : 'OFF'}
+✓ Emoji: ${config.reactionEmoji}
+✓ Random: ${config.randomReactions ? 'ON' : 'OFF'}
+
+✦ *Commands:*
+  › on
+  › off
+  › react on/off
+  › emoji <emoji>
+  › random on/off
+  › reset`;
+            
+            await sock.sendMessage(chatId, { text }, { quoted: fakeContact });
+            return;
+        }
+
+        const command = args[0].toLowerCase();
+        
+        if (command === 'on') {
+            config.enabled = true;
+            if (writeConfig(config)) {
+                await sock.sendMessage(chatId, { 
+                    text: `✦ Auto Status ENABLED` 
+                }, { quoted: fakeContact });
+            }
+        } 
+        else if (command === 'off') {
+            config.enabled = false;
+            if (writeConfig(config)) {
+                await sock.sendMessage(chatId, { 
+                    text: `✦ Auto Status DISABLED` 
+                }, { quoted: fakeContact });
+            }
+        } 
+        else if (command === 'react') {
+            if (!args[1]) {
+                await sock.sendMessage(chatId, { 
+                    text: `✦ Use: react on/off` 
+                }, { quoted: fakeContact });
+                return;
+            }
+            
+            const reactCommand = args[1].toLowerCase();
+            if (reactCommand === 'on') {
+                config.reactOn = true;
+                if (writeConfig(config)) {
+                    const reactionType = config.randomReactions ? 'random' : config.reactionEmoji;
+                    await sock.sendMessage(chatId, { 
+                        text: `✦ Auto React ENABLED\n  Type: ${reactionType}` 
+                    }, { quoted: fakeContact });
+                }
+            } else if (reactCommand === 'off') {
+                config.reactOn = false;
+                if (writeConfig(config)) {
+                    await sock.sendMessage(chatId, { 
+                        text: `✦ Auto React DISABLED` 
+                    }, { quoted: fakeContact });
+                }
+            } else {
+                await sock.sendMessage(chatId, { 
+                    text: `✦ Invalid: react on/off` 
+                }, { quoted: fakeContact });
+            }
+        }
+        else if (command === 'emoji') {
+            if (!args[1]) {
+                await sock.sendMessage(chatId, { 
+                    text: `✦ Emoji required` 
+                }, { quoted: fakeContact });
+                return;
+            }
+            
+            const newEmoji = args[1].trim();
+            config.reactionEmoji = newEmoji;
+            if (writeConfig(config)) {
+                await sock.sendMessage(chatId, { 
+                    text: `✦ Emoji set: ${newEmoji}` 
+                }, { quoted: fakeContact });
+            }
+        }
+        else if (command === 'random') {
+            if (!args[1]) {
+                await sock.sendMessage(chatId, { 
+                    text: `✦ Use: random on/off` 
+                }, { quoted: fakeContact });
+                return;
+            }
+            
+            const randomCommand = args[1].toLowerCase();
+            if (randomCommand === 'on') {
+                config.randomReactions = true;
+                if (writeConfig(config)) {
+                    await sock.sendMessage(chatId, { 
+                        text: `✦ Random reactions ENABLED` 
+                    }, { quoted: fakeContact });
+                }
+            } else if (randomCommand === 'off') {
+                config.randomReactions = false;
+                if (writeConfig(config)) {
+                    await sock.sendMessage(chatId, { 
+                        text: `✦ Random reactions DISABLED\n  Using: ${config.reactionEmoji}` 
+                    }, { quoted: fakeContact });
+                }
+            } else {
+                await sock.sendMessage(chatId, { 
+                    text: `✦ Invalid: random on/off` 
+                }, { quoted: fakeContact });
+            }
+        }
+        else if (command === 'reset') {
+            const defaultConfig = { 
+                enabled: true,
+                reactOn: false,
+                reactionEmoji: '🖤',
+                randomReactions: true 
+            };
+            if (writeConfig(defaultConfig)) {
+                await sock.sendMessage(chatId, { 
+                    text: `✦ Settings reset to default` 
+                }, { quoted: fakeContact });
+            }
+        }
+        else {
+            await sock.sendMessage(chatId, { 
+                text: `✦ Invalid command` 
+            }, { quoted: fakeContact });
+        }
+
+    } catch (error) {
+        console.error('AutoStatus error:', error);
+        const fakeContact = createFakeContact(msg);
+        await sock.sendMessage(chatId, { text: `✦ Error` }, { quoted: fakeContact });
+    }
+}
+
+function isAutoStatusEnabled() {
+    try {
+        const config = readConfig();
+        return config.enabled;
+    } catch (error) {
+        console.error('Status check error:', error);
+        return false;
+    }
+}
+
+function isStatusReactionEnabled() {
+    try {
+        const config = readConfig();
+        return config.reactOn;
+    } catch (error) {
+        console.error('Reaction check error:', error);
+        return false;
+    }
+}
+
+function getReactionEmoji() {
+    try {
+        const config = readConfig();
+        
+        if (config.randomReactions) {
+            return getRandomEmoji();
+        }
+        
+        return config.reactionEmoji || '🖤';
+    } catch (error) {
+        console.error('Emoji error:', error);
+        return '🖤';
+    }
+}
+
+function isRandomReactionsEnabled() {
+    try {
+        const config = readConfig();
+        return config.randomReactions !== false;
+    } catch (error) {
+        console.error('Random check error:', error);
+        return true;
+    }
+}
+
+async function reactToStatus(sock, statusKey) {
+    try {
+        if (!isStatusReactionEnabled()) {
+            return;
+        }
+
+        const emoji = getReactionEmoji();
+
+        await sock.relayMessage(
+            'status@broadcast',
+            {
+                reactionMessage: {
+                    key: {
+                        remoteJid: 'status@broadcast',
+                        id: statusKey.id,
+                        participant: statusKey.participant || statusKey.remoteJid,
+                        fromMe: false
+                    },
+                    text: emoji
+                }
+            },
+            {
+                messageId: statusKey.id,
+                statusJidList: [statusKey.remoteJid, statusKey.participant || statusKey.remoteJid]
+            }
+        );
+        
+    } catch (error) {
+        console.error('React error:', error.message);
+    }
+}
+
+async function handleStatusUpdate(sock, status) {
+    try {
+        if (!isAutoStatusEnabled()) {
+            return;
+        }
+
+        await new Promise(resolve => setTimeout(resolve, 1000));
+
+        let statusKey = null;
+
+        if (status.messages && status.messages.length > 0) {
+            statusKey = status.messages[0].key;
+        } else if (status.key) {
+            statusKey = status.key;
+        } else if (status.reaction && status.reaction.key) {
+            statusKey = status.reaction.key;
+        }
+
+        if (statusKey && statusKey.remoteJid === 'status@broadcast') {
+            try {
+                await sock.readMessages([statusKey]);
+                await reactToStatus(sock, statusKey);
+                
+            } catch (err) {
+                if (err.message?.includes('rate-overlimit')) {
+                    await new Promise(resolve => setTimeout(resolve, 2000));
+                    await sock.readMessages([statusKey]);
+                } else {
+                    console.error('Status error:', err.message);
+                }
+            }
+        }
+
+    } catch (error) {
+        console.error('Status update error:', error.message);
+    }
+}
+
+module.exports = {
+    autoStatusCommand,
+    handleStatusUpdate,
+    isAutoStatusEnabled,
+    isStatusReactionEnabled,
+    getReactionEmoji,
+    isRandomReactionsEnabled,
+    getRandomEmoji
+};

package/davexcore/automation/autotyping.js

@@ -0,0 +1,197 @@
+const { getOwnerConfig, setOwnerConfig, parseToggleCommand } = require('../../Database/settingsStore');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+const typingIntervals = new Map();
+
+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 autotypingCommand(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 text = message.message?.conversation || message.message?.extendedTextMessage?.text || '';
+        const args = text.trim().split(/\s+/).slice(1);
+        const action = args[0]?.toLowerCase();
+        const action2 = args[1]?.toLowerCase();
+
+        const config = getOwnerConfig('autotyping') || { enabled: false, duration: 3000, pm: true, group: true };
+
+        if (!action) {
+            const helpText = `✦ *AUTOTYPING*
+    
+  Status: ${config.enabled ? 'ON' : 'OFF'}
+  PM: ${config.pm ? 'ON' : 'OFF'}
+  Group: ${config.group ? 'ON' : 'OFF'}
+
+✦ *Commands:*
+  › on
+  › off
+  › pm
+  › group
+  › both
+  › pm on/off
+  › group on/off
+  › both on/off`;
+            await sock.sendMessage(chatId, { text: helpText }, { quoted: fake });
+            return;
+        }
+
+        let newConfig = { ...config };
+        let responseText = '';
+
+        const toggle = parseToggleCommand(action);
+
+        if (toggle === 'on') {
+            newConfig.enabled = true;
+            newConfig.pm = true;
+            newConfig.group = true;
+            responseText = `✦ Autotyping ENABLED for both PMs & Groups`;
+        } else if (toggle === 'off') {
+            newConfig.enabled = false;
+            stopAllTypingIntervals();
+            responseText = `✦ Autotyping DISABLED`;
+        } else if (action === 'pm') {
+            const toggle2 = action2 ? parseToggleCommand(action2) : null;
+            if (toggle2 === 'off') {
+                newConfig.pm = false;
+                if (!newConfig.group) newConfig.enabled = false;
+                responseText = `✦ Autotyping PM mode DISABLED\n  Group: ${newConfig.group ? 'ON' : 'OFF'}`;
+            } else {
+                newConfig.pm = true;
+                newConfig.group = false;
+                newConfig.enabled = true;
+                responseText = `✦ Autotyping enabled for PMs only`;
+                if (toggle2 === 'on') {
+                    newConfig.group = config.group;
+                    responseText = `✦ Autotyping PM mode ENABLED\n  Group: ${newConfig.group ? 'ON' : 'OFF'}`;
+                }
+            }
+        } else if (action === 'group') {
+            const toggle2 = action2 ? parseToggleCommand(action2) : null;
+            if (toggle2 === 'off') {
+                newConfig.group = false;
+                if (!newConfig.pm) newConfig.enabled = false;
+                responseText = `✦ Autotyping Group mode DISABLED\n  PM: ${newConfig.pm ? 'ON' : 'OFF'}`;
+            } else {
+                newConfig.group = true;
+                newConfig.pm = false;
+                newConfig.enabled = true;
+                responseText = `✦ Autotyping enabled for Groups only`;
+                if (toggle2 === 'on') {
+                    newConfig.pm = config.pm;
+                    responseText = `✦ Autotyping Group mode ENABLED\n  PM: ${newConfig.pm ? 'ON' : 'OFF'}`;
+                }
+            }
+        } else if (action === 'both') {
+            const toggle2 = action2 ? parseToggleCommand(action2) : null;
+            if (toggle2 === 'off') {
+                newConfig.enabled = false;
+                newConfig.pm = false;
+                newConfig.group = false;
+                stopAllTypingIntervals();
+                responseText = `✦ Autotyping DISABLED for both PMs & Groups`;
+            } else {
+                newConfig.pm = true;
+                newConfig.group = true;
+                newConfig.enabled = true;
+                responseText = `✦ Autotyping enabled for both PMs & Groups`;
+            }
+        } else {
+            responseText = `✦ Invalid! Use: on, off, pm, group, both\n  Or: pm on/off, group on/off, both on/off`;
+        }
+
+        if (responseText && !responseText.includes('Invalid')) {
+            if (!newConfig.pm && !newConfig.group) {
+                newConfig.enabled = false;
+                stopAllTypingIntervals();
+            }
+            setOwnerConfig('autotyping', newConfig);
+        }
+
+        await sock.sendMessage(chatId, { text: responseText }, { quoted: fake });
+    } catch (error) {
+        console.error('Error in autotyping command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+function isAutotypingEnabled() {
+    const config = getOwnerConfig('autotyping');
+    return config?.enabled || false;
+}
+
+function stopAllTypingIntervals() {
+    for (const [key, interval] of typingIntervals.entries()) {
+        clearInterval(interval);
+        typingIntervals.delete(key);
+    }
+}
+
+async function handleAutotypingForMessage(sock, chatId) {
+    try {
+        const config = getOwnerConfig('autotyping');
+        if (!config?.enabled) return;
+        
+        const isGroup = chatId.endsWith('@g.us');
+        if (isGroup && !config.group) return;
+        if (!isGroup && !config.pm) return;
+        
+        if (typingIntervals.has(chatId)) {
+            clearInterval(typingIntervals.get(chatId));
+        }
+
+        await sock.presenceSubscribe(chatId);
+        await sock.sendPresenceUpdate('composing', chatId);
+
+        const interval = setInterval(async () => {
+            try {
+                const currentConfig = getOwnerConfig('autotyping');
+                if (!currentConfig?.enabled) {
+                    clearInterval(interval);
+                    typingIntervals.delete(chatId);
+                    return;
+                }
+                await sock.sendPresenceUpdate('composing', chatId);
+            } catch (e) {
+                clearInterval(interval);
+                typingIntervals.delete(chatId);
+            }
+        }, 4000);
+
+        typingIntervals.set(chatId, interval);
+
+        setTimeout(() => {
+            if (typingIntervals.has(chatId)) {
+                clearInterval(typingIntervals.get(chatId));
+                typingIntervals.delete(chatId);
+                try { sock.sendPresenceUpdate('paused', chatId); } catch(e) {}
+            }
+        }, 30000);
+    } catch (error) {
+        console.error('Autotyping error:', error.message);
+    }
+}
+
+module.exports = {
+    autotypingCommand,
+    isAutotypingEnabled,
+    handleAutotypingForMessage,
+    stopAllTypingIntervals
+};