jsdecryptor 4.0.3

package/davexcore/owner/setowner.js

@@ -0,0 +1,144 @@
+const { getOwnerConfig, setOwnerConfig } = require('../../Database/settingsStore');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName, getOwnerName: getOwnerNameFromConfig, setOwnerName: setOwnerNameToConfig } = require('../../davelib/fakeContact');
+const { setOwnerName: setBotConfigOwnerName } = require('../../davelib/botConfig');
+
+const DEFAULT_OWNER_NAME = 'Not set';
+
+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 getOwnerName() {
+    try {
+        return getOwnerNameFromConfig() || DEFAULT_OWNER_NAME;
+    } catch (error) {
+        console.error('Error getting owner name:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        return DEFAULT_OWNER_NAME;
+    }
+}
+
+function setOwnerName(newOwnerName) {
+    try {
+        if (!newOwnerName?.trim() || newOwnerName.trim().length > 20) return false;
+        setBotConfigOwnerName(newOwnerName.trim());
+        return true;
+    } catch (error) {
+        console.error('Error setting owner name:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        return false;
+    }
+}
+
+function resetOwnerName() {
+    try {
+        setBotConfigOwnerName(DEFAULT_OWNER_NAME);
+        return true;
+    } catch (error) {
+        console.error('Error resetting owner name:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        return false;
+    }
+}
+
+function validateOwnerName(name) {
+    if (!name?.trim()) return { isValid: false, message: 'Owner name cannot be empty' };
+
+    const trimmed = name.trim();
+    if (trimmed.length > 20) return { isValid: false, message: 'Owner name must be 1-20 characters long' };
+
+    const invalidChars = /[<>@#\$%\^\*\\\/]/;
+    if (invalidChars.test(trimmed)) return { isValid: false, message: 'Owner name contains invalid characters' };
+
+    return { isValid: true, message: 'Valid owner name' };
+}
+
+async function handleSetOwnerCommand(sock, chatId, message) {
+    try {
+        const senderId = message.key.participant || message.key.remoteJid;
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+
+        if (!await isAuthorized(sock, message)) {
+            const authMsgs = [
+                `*${botName}*\nOwner only.`,
+                `*${botName}*\nPrivileges required.`,
+                `*${botName}*\nBoss only.`
+            ];
+            await sock.sendMessage(chatId, {
+                text: authMsgs[Math.floor(Math.random() * authMsgs.length)]
+            }, { quoted: fake });
+            return;
+        }
+
+        const text = message.message?.conversation || message.message?.extendedTextMessage?.text || '';
+        const args = text.trim().split(' ').slice(1).join(' ');
+
+        if (!args) {
+            const currentOwner = getOwnerName();
+            await sock.sendMessage(chatId, {
+                text: `╭─❖ *OWNER SETTINGS* ❖─╮\n` +
+                    `│ Current : ${currentOwner}\n` +
+                    `╰───────────────────────╯\n\n` +
+                    `✦ .setowner <name>\n` +
+                    `✦ .setowner reset`
+            }, { quoted: fake });
+            return;
+        }
+
+        let responseText = '';
+
+        if (args.toLowerCase() === 'reset') {
+            resetOwnerName();
+            const resetMsgs = [
+                `*${botName}*\n✓ Owner name reset.`,
+                `*${botName}*\n✓ Reset to default.`,
+                `*${botName}*\n✓ Owner name cleared.`
+            ];
+            responseText = resetMsgs[Math.floor(Math.random() * resetMsgs.length)];
+        } else {
+            const validation = validateOwnerName(args);
+            if (!validation.isValid) {
+                const errorMsgs = [
+                    `*${botName}*\n✗ ${validation.message}`,
+                    `*${botName}*\n✗ Invalid: ${validation.message.toLowerCase()}`,
+                    `*${botName}*\n✗ ${validation.message}`
+                ];
+                responseText = errorMsgs[Math.floor(Math.random() * errorMsgs.length)];
+            } else {
+                setOwnerName(args);
+                const successMsgs = [
+                    `*${botName}*\n✓ Owner: ${args}`,
+                    `*${botName}*\n✓ Set to: ${args}`,
+                    `*${botName}*\n✓ Now ${args}`
+                ];
+                responseText = successMsgs[Math.floor(Math.random() * successMsgs.length)];
+            }
+        }
+
+        await sock.sendMessage(chatId, { text: responseText }, { quoted: fake });
+    } catch (error) {
+        console.error('Error in setowner command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        
+        const errorMsgs = [
+            `*${botName}*\n✗ Something went wrong.`,
+            `*${botName}*\n✗ Command failed.`,
+            `*${botName}*\n✗ Try again.`
+        ];
+        await sock.sendMessage(chatId, { 
+            text: errorMsgs[Math.floor(Math.random() * errorMsgs.length)]
+        }, { quoted: fake });
+    }
+}
+
+module.exports = {
+    getOwnerName,
+    setOwnerName,
+    resetOwnerName,
+    validateOwnerName,
+    handleSetOwnerCommand
+};

package/davexcore/owner/setprefix.js

@@ -0,0 +1,131 @@
+const { getOwnerConfig, setOwnerConfig } = require('../../Database/settingsStore');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+const DEFAULT_PREFIX = '.';
+const NO_PREFIX = 'none';
+
+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 getPrefix() {
+    try {
+        const prefix = getOwnerConfig('prefix');
+        if (prefix === NO_PREFIX || prefix === '') return '';
+        return prefix || DEFAULT_PREFIX;
+    } catch (error) {
+        console.error('Error getting prefix:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        return DEFAULT_PREFIX;
+    }
+}
+
+function getRawPrefix() {
+    try {
+        return getOwnerConfig('prefix') || DEFAULT_PREFIX;
+    } catch (error) {
+        console.error('Error getting raw prefix:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        return DEFAULT_PREFIX;
+    }
+}
+
+function setPrefix(newPrefix) {
+    try {
+        setOwnerConfig('prefix', newPrefix);
+        return true;
+    } catch (error) {
+        console.error('Error setting prefix:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        return false;
+    }
+}
+
+async function handleSetPrefixCommand(sock, chatId, message) {
+    try {
+        const senderId = message.key.participant || message.key.remoteJid;
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+
+        if (!await isAuthorized(sock, message)) {
+            const authMsgs = [
+                `*${botName}*\nOnly the boss can do that!`,
+                `*${botName}*\nOwner privileges required.`,
+                `*${botName}*\nThis one's for the owner only.`
+            ];
+            await sock.sendMessage(chatId, {
+                text: authMsgs[Math.floor(Math.random() * authMsgs.length)]
+            }, { quoted: fake });
+            return;
+        }
+
+        const text = message.message?.conversation || message.message?.extendedTextMessage?.text || '';
+        const args = text.trim().split(' ');
+        const newPrefix = args[1];
+
+        if (!newPrefix) {
+            const currentPrefix = getRawPrefix();
+            const displayPrefix = currentPrefix === NO_PREFIX ? 'No prefix' : currentPrefix;
+            
+            await sock.sendMessage(chatId, {
+                text: `╭─❖ *PREFIX SETTINGS* ❖─╮\n` +
+                    `│ Current : ${displayPrefix}\n` +
+                    `╰───────────────────────╯\n\n` +
+                    `✦ .setprefix <symbol>\n` +
+                    `✦ .setprefix none\n` +
+                    `✦ .setprefix reset`
+            }, { quoted: fake });
+            return;
+        }
+
+        let responseText = '';
+
+        if (newPrefix.toLowerCase() === 'none') {
+            setPrefix(NO_PREFIX);
+            const msgs = [
+                `*${botName}*\n✓ Prefix removed. Bot is now prefixless.`,
+                `*${botName}*\n✓ No more prefix! Use commands without one.`,
+                `*${botName}*\n✓ Prefix disabled.`
+            ];
+            responseText = msgs[Math.floor(Math.random() * msgs.length)];
+        } else if (newPrefix.toLowerCase() === 'reset') {
+            setPrefix(DEFAULT_PREFIX);
+            const msgs = [
+                `*${botName}*\n✓ Reset to default: ${DEFAULT_PREFIX}`,
+                `*${botName}*\n✓ Back to ${DEFAULT_PREFIX}`,
+                `*${botName}*\n✓ Default restored: ${DEFAULT_PREFIX}`
+            ];
+            responseText = msgs[Math.floor(Math.random() * msgs.length)];
+        } else if (newPrefix.length > 5) {
+            const msgs = [
+                `*${botName}*\n✗ Max 5 characters!`,
+                `*${botName}*\n✗ Too long! Keep it under 5.`,
+                `*${botName}*\n✗ Prefix must be 1-5 chars.`
+            ];
+            responseText = msgs[Math.floor(Math.random() * msgs.length)];
+        } else {
+            setPrefix(newPrefix);
+            const msgs = [
+                `*${botName}*\n✓ Prefix is now: ${newPrefix}`,
+                `*${botName}*\n✓ Changed to: ${newPrefix}`,
+                `*${botName}*\n✓ Using: ${newPrefix}`
+            ];
+            responseText = msgs[Math.floor(Math.random() * msgs.length)];
+        }
+
+        await sock.sendMessage(chatId, { text: responseText }, { quoted: fake });
+    } catch (error) {
+        console.error('Error in setprefix command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+module.exports = {
+    getPrefix,
+    getRawPrefix,
+    setPrefix,
+    handleSetPrefixCommand
+};

package/davexcore/owner/settings.js

@@ -0,0 +1,98 @@
+const { getOwnerConfig, getGroupConfig } = 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 settingsCommand(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 isGroup = chatId.endsWith('@g.us');
+
+        // Get all configurations
+        const autoStatus = getOwnerConfig('autostatus') || { enabled: false };
+        const autoread = getOwnerConfig('autoread') || { mode: 'off' };
+        const autotyping = getOwnerConfig('autotyping') || { enabled: false };
+        const autorecording = getOwnerConfig('autorecording') || { enabled: false };
+        const pmblocker = getOwnerConfig('pmblocker') || { enabled: false };
+        const anticall = getOwnerConfig('anticall') || { enabled: false };
+        const antiedit = getOwnerConfig('antiedit') || { enabled: false };
+        const antidelete = getOwnerConfig('antidelete') || { enabled: false };
+        const autoReaction = getOwnerConfig('autoReaction') || { enabled: false };
+        const prefix = getOwnerConfig('prefix') || '.';
+
+        // Helper function to format status
+        const formatStatus = (enabled, extra = '') => {
+            return enabled ? `✓ ON ${extra}` : `✗ OFF`;
+        };
+
+        // Build message
+        let messageText = `┌─ ${botName} SETTINGS ─┐\n\n`;
+        
+        messageText += `├─ BASIC ────────────┤\n`;
+        messageText += `│ Prefix    : ${prefix === 'none' ? 'None' : `"${prefix}"`}\n`;
+        messageText += `│ Auto Status : ${formatStatus(autoStatus.enabled)}\n`;
+        messageText += `│ Autoread    : ${autoread.mode !== 'off' ? autoread.mode.toUpperCase() : 'OFF'}\n`;
+        messageText += `│ Autotyping  : ${formatStatus(autotyping.enabled)}\n`;
+        messageText += `│ Autorecording : ${formatStatus(autorecording.enabled)}\n\n`;
+
+        messageText += `├─ PRIVACY ───────────┤\n`;
+        messageText += `│ PM Blocker  : ${formatStatus(pmblocker.enabled)}\n`;
+        messageText += `│ Anticall    : ${anticall.enabled ? `✓ ON (${anticall.mode || 'block'})` : '✗ OFF'}\n`;
+        messageText += `│ Antiedit    : ${formatStatus(antiedit.enabled)}\n`;
+        messageText += `│ Antidelete  : ${antidelete.enabled ? `✓ ON (${antidelete.mode || 'private'})` : '✗ OFF'}\n`;
+        messageText += `│ Auto Reaction : ${formatStatus(autoReaction.enabled)}\n`;
+        
+        if (isGroup) {
+            messageText += `\n├─ GROUP ────────────┤\n`;
+            
+            const antilink = getGroupConfig(chatId, 'antilink') || { enabled: false };
+            const antibadword = getGroupConfig(chatId, 'antibadword') || { enabled: false };
+            const welcome = getGroupConfig(chatId, 'welcome') || { enabled: false };
+            const goodbye = getGroupConfig(chatId, 'goodbye') || { enabled: false };
+            const chatbot = getGroupConfig(chatId, 'chatbot') || false;
+            const antitag = getGroupConfig(chatId, 'antitag') || { enabled: false };
+            const antimention = getGroupConfig(chatId, 'antimention') || { enabled: false };
+            const antichart = getGroupConfig(chatId, 'antichart') || { enabled: false };
+            const antikick = getGroupConfig(chatId, 'antikick') || { enabled: false };
+            const groupAntiedit = getGroupConfig(chatId, 'antiedit') || { enabled: false };
+            const groupAntidelete = getGroupConfig(chatId, 'antidelete') || { enabled: false };
+
+            messageText += `│ Antilink     : ${antilink.enabled ? `✓ ON (${antilink.action || 'delete'})` : '✗ OFF'}\n`;
+            messageText += `│ Antibadword  : ${antibadword.enabled ? `✓ ON (${antibadword.action || 'delete'})` : '✗ OFF'}\n`;
+            messageText += `│ Welcome      : ${formatStatus(welcome.enabled)}\n`;
+            messageText += `│ Goodbye      : ${formatStatus(goodbye.enabled)}\n`;
+            messageText += `│ Chatbot      : ${chatbot ? '✓ ON' : '✗ OFF'}\n`;
+            messageText += `│ Antitag      : ${formatStatus(antitag.enabled)}\n`;
+            messageText += `│ Antimention  : ${formatStatus(antimention.enabled)}\n`;
+            messageText += `│ Antichart    : ${antichart.enabled ? `✓ ON (${antichart.action || 'delete'})` : '✗ OFF'}\n`;
+            messageText += `│ Antikick     : ${formatStatus(antikick.enabled)}\n`;
+            messageText += `│ Antiedit     : ${formatStatus(groupAntiedit.enabled)}\n`;
+            messageText += `│ Antidelete   : ${formatStatus(groupAntidelete.enabled)}\n`;
+        }
+
+        messageText += `\n└────────────────────┘`;
+
+        await sock.sendMessage(chatId, { text: messageText }, { quoted: fake });
+    } catch (error) {
+        console.error('Error in settings command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+module.exports = settingsCommand;

package/davexcore/owner/startupwelcome.js

@@ -0,0 +1,94 @@
+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 isStartupWelcomeOn() {
+    try {
+        const config = getOwnerConfig('startupWelcome');
+        return config !== false;
+    } catch (error) {
+        console.error('Error getting startup welcome:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        return true;
+    }
+}
+
+function setStartupWelcome(enabled) {
+    try {
+        setOwnerConfig('startupWelcome', enabled);
+        return true;
+    } catch (error) {
+        console.error('Error setting startup welcome:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        return false;
+    }
+}
+
+async function startupWelcomeCommand(sock, chatId, message) {
+    const senderId = message.key.participant || message.key.remoteJid;
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+
+    try {
+        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 currentStatus = isStartupWelcomeOn();
+
+        if (!action) {
+            await sock.sendMessage(chatId, {
+                text: `*${botName} STARTUP WELCOME*\n\n` +
+                    `Current Status: ${currentStatus ? 'ON' : 'OFF'}\n\n` +
+                    `*Commands:*\n` +
+                    `.startupwelcome on - Enable startup message\n` +
+                    `.startupwelcome off - Disable startup message`
+            }, { quoted: fake });
+            return;
+        }
+
+        const toggle = parseToggleCommand(action);
+        
+        if (toggle === 'on') {
+            setStartupWelcome(true);
+            await sock.sendMessage(chatId, {
+                text: `*${botName}*\nStartup welcome message enabled!`
+            }, { quoted: fake });
+        } else if (toggle === 'off') {
+            setStartupWelcome(false);
+            await sock.sendMessage(chatId, {
+                text: `*${botName}*\nStartup welcome message disabled!`
+            }, { quoted: fake });
+        } else {
+            await sock.sendMessage(chatId, {
+                text: `*${botName}*\nInvalid option! Use: on/off`
+            }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Startup welcome command error:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        await sock.sendMessage(chatId, {
+            text: `*${botName}*\nCommand failed!`
+        }, { quoted: fake });
+    }
+}
+
+module.exports = { 
+    startupWelcomeCommand, 
+    isStartupWelcomeOn, 
+    setStartupWelcome 
+};

package/davexcore/owner/sudo.js

@@ -0,0 +1,138 @@
+const settings = require('../../daveset');
+const { isSudo, addSudo, removeSudo, getSudoList } = require('../../davelib/index');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+function extractMentionedJid(message) {
+    try {
+        const mentioned = message.message?.extendedTextMessage?.contextInfo?.mentionedJid || [];
+        if (mentioned.length > 0) return mentioned[0];
+
+        const text = message.message?.conversation || message.message?.extendedTextMessage?.text || '';
+        const match = text.match(/\b(\d{7,15})\b/);
+        if (match) return `${match[1]}@s.whatsapp.net`;
+
+        return null;
+    } catch (err) {
+        console.error('extractMentionedJid error:', err.message, 'Line:', err.stack?.split('\n')[1]);
+        return null;
+    }
+}
+
+async function sudoCommand(sock, chatId, message) {
+    const senderId = message.key.participant || message.key.remoteJid;
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+
+    try {
+        const ownerJid = `${settings.ownerNumber}@s.whatsapp.net`;
+        const isOwner = message.key.fromMe || senderId === ownerJid;
+
+        const rawText = message.message?.conversation || message.message?.extendedTextMessage?.text || '';
+        const args = rawText.trim().split(/\s+/).slice(1);
+        const sub = (args[0] || '').toLowerCase();
+
+        if (!sub || !['add', 'del', 'remove', 'list'].includes(sub)) {
+            const helpText = `┌─ *${botName} SUDO* ─┐\n` +
+                           `│\n` +
+                           `│ Usage:\n` +
+                           `│ • .sudo add @user\n` +
+                           `│ • .sudo del @user\n` +
+                           `│ • .sudo list\n` +
+                           `│\n` +
+                           `└──────────────────┘`;
+            await sock.sendMessage(chatId, { text: helpText }, { quoted: fake });
+            return;
+        }
+
+        if (sub === 'list') {
+            const list = getSudoList();
+            if (!list || list.length === 0) {
+                await sock.sendMessage(chatId, { 
+                    text: `┌─ *${botName}* ─┐\n│\n│ No sudo users set.\n│\n└─────────────┘` 
+                }, { quoted: fake });
+                return;
+            }
+
+            const formatted = list.map((jid, i) => `│ ${i + 1}. @${jid.split('@')[0]}`).join('\n');
+            const listText = `┌─ *${botName} SUDO LIST* ─┐\n` +
+                           `│\n` +
+                           `${formatted}\n` +
+                           `│\n` +
+                           `└──────────────────────┘`;
+            
+            await sock.sendMessage(chatId, {
+                text: listText,
+                mentions: list
+            }, { quoted: fake });
+            return;
+        }
+
+        if (!isOwner) {
+            await sock.sendMessage(chatId, { 
+                text: `┌─ *${botName}* ─┐\n│\n│ Owner only command!\n│\n└─────────────┘` 
+            }, { quoted: fake });
+            return;
+        }
+
+        const targetJid = extractMentionedJid(message);
+        if (!targetJid) {
+            await sock.sendMessage(chatId, { 
+                text: `┌─ *${botName}* ─┐\n│\n│ Mention a user or provide phone number!\n│\n└─────────────┘` 
+            }, { quoted: fake });
+            return;
+        }
+
+        if (sub === 'add') {
+            if (isSudo(targetJid)) {
+                await sock.sendMessage(chatId, {
+                    text: `┌─ *${botName}* ─┐\n` +
+                          `│\n` +
+                          `│ @${targetJid.split('@')[0]} is already sudo!\n` +
+                          `│\n` +
+                          `└─────────────┘`,
+                    mentions: [targetJid]
+                }, { quoted: fake });
+                return;
+            }
+
+            addSudo(targetJid);
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐\n` +
+                      `│\n` +
+                      `│ ✓ @${targetJid.split('@')[0]} added as sudo!\n` +
+                      `│\n` +
+                      `└─────────────┘`,
+                mentions: [targetJid]
+            }, { quoted: fake });
+        } else if (sub === 'del' || sub === 'remove') {
+            if (!isSudo(targetJid)) {
+                await sock.sendMessage(chatId, {
+                    text: `┌─ *${botName}* ─┐\n` +
+                          `│\n` +
+                          `│ @${targetJid.split('@')[0]} is not sudo!\n` +
+                          `│\n` +
+                          `└─────────────┘`,
+                    mentions: [targetJid]
+                }, { quoted: fake });
+                return;
+            }
+
+            removeSudo(targetJid);
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐\n` +
+                      `│\n` +
+                      `│ ✗ @${targetJid.split('@')[0]} removed from sudo!\n` +
+                      `│\n` +
+                      `└─────────────┘`,
+                mentions: [targetJid]
+            }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Sudo command error:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        await sock.sendMessage(chatId, { 
+            text: `┌─ *${botName}* ─┐\n│\n│ Sudo command failed!\n│\n└─────────────┘` 
+        }, { quoted: fake });
+    }
+}
+
+module.exports = { sudoCommand };