innovators-bot2 2.0.5 → 2.0.7

package/example.js

@@ -1,4 +1,11 @@
-const { WhatsAppClient } = require('./index')
+const { WhatsAppClient,
+    STATUS_BACKGROUNDS,
+    STATUS_FONTS,
+    renderLatexToPng,
+    uploadUnencryptedToWA,
+    RichSubMessageType
+} = require('./index')
+
 const qrcode = require('qrcode-terminal')
 const fs = require('fs');
 const readline = require('readline');
@@ -48,6 +55,7 @@ async function start() {
         sessionName: sessionDir,
         authmethod: authMethod,
         pairingPhoneNumber: pairingPhoneNumber,
+        ai: true, // Enable/Disable AI flag for outgoing messages (default: true)
         // Message store persistence configuration
         messageStoreFilePath: path.join(sessionDir, 'message-store.json'),
         autoSaveInterval: 5 * 60 * 1000, // Auto-save every 5 minutes
@@ -124,6 +132,37 @@ async function start() {
         console.log('Is Removed:', reaction.isRemoved)
         console.log('Message ID:', reaction.messageKey.id)
     })
+    client.on('poll-votes-update', async (data) => {
+        console.log('\n📊 Poll Votes Updated!');
+        console.log('Chat:', data.jid);
+        console.log('Voter:', data.voter);
+
+        // 1. Extract Poll Creation Message (Question, Options, etc.)
+        const pollCreation = data.pollCreationMessage;
+        if (pollCreation && pollCreation.message) {
+            const pollMessage = pollCreation.message.pollCreationMessage ||
+                pollCreation.message.pollCreationMessageV2 ||
+                pollCreation.message.pollCreationMessageV3;
+
+            if (pollMessage) {
+                console.log('\n📝 Poll Creation Details:');
+                console.log('Question:', pollMessage.name);
+                console.log('Options:', pollMessage.options?.map(o => o.optionName) || []);
+            }
+        }
+
+        // 2. Extract voters array from pollUpdate
+        console.log('\n🗳️ Vote Breakdown:');
+        let totalVotesCount = 0;
+        data.pollUpdate.forEach((option) => {
+            console.log(`--> ${option.name}: ${option.voters.length} vote(s) ${JSON.stringify(option.voters)}`);
+            totalVotesCount += option.voters.length;
+        });
+        console.log(`--> Total Votes Cast: ${totalVotesCount}`);
+        const winner = data.pollUpdate.reduce((prev, current) =>
+            prev.voters.length > current.voters.length ? prev : current);
+        console.log(`--> The Winner Is ${winner.name} With ${winner.voters.length} votes`);
+    });
 
     client.on('call', (call) => {
         const callData = call[0]; // Get the first call object from the array
@@ -181,44 +220,74 @@ async function start() {
             return
         }
 
+
         console.log('Message Received');
-        console.log('Number:', msg.from);
-        console.log('Sender:', msg.raw.pushName);
+
+
+        isGroupMsg = msg.isGroup
+        if (isGroupMsg) {
+            msgFrom = msg.from
+        } else {
+            msgFrom = msg.sender
+        }
+
+        console.log('Msg From:', msg.from);
+        console.log('Msg Sender:', msg.sender);
+        console.log('Sender Name:', msg.raw.pushName);
         console.log('Message:', msg.body);
+        console.log('Is Group:', msg.isGroup);
         // Mark the message as read
         await client.readMessage(msg.raw.key)
 
-        const command = msg.body.toLowerCase().split(' ')[0]
-        const args = msg.body.toLowerCase().split(' ').slice(1).join(' ')
+        const command = msg.body.split(' ')[0].toLowerCase()
+        const args = msg.body.split(' ').slice(1).join(' ')
 
         switch (command) {
             case '!ping':
-                await client.sendMessage(msg.from, 'pong')
+                await client.sendMessage(msgFrom, 'Hello Pong! 🎊')
+                break
+            case '!poll':
+                await client.sendMessage(msgFrom, '', {
+                    poll: {
+                        name: 'Which programming language do you like most?',
+                        options: ['JavaScript', 'Python', 'C++', 'Java'],
+                        selectableOptionsCount: 1,
+                        messageId: 'poll1'
+                    }
+                });
                 break
-
             case '!echo':
                 if (args) {
-                    await client.sendMessage(msg.from, args)
+                    await client.sendMessage(msgFrom, args)
                 } else {
-                    await client.sendMessage(msg.from, 'Please provide text to echo')
+                    await client.sendMessage(msgFrom, 'Please provide text to echo')
                 }
                 break
-
             case '!mention':
-                const number = msg.from.split('@')[0]
-                await client.sendMessage(msg.from, {
+                const number = msg.sender.split('@')[0]
+                await client.sendMessage(msgFrom, {
                     type: 'text',
                     text: `Hey @${number}! How are you?`,
-                    mentions: [msg.from]
+                    mentions: [number]
+                })
+                break
+            case '!mentionall':
+                if (!isGroupMsg) {
+                    await client.sendMessage(msgFrom, 'This command is only for groups')
+                    return
+                }
+                await client.sendMessage(msgFrom, {
+                    type: 'text',
+                    text: `Hey @all! How are you?`,
+                    mentions: ['@all']
                 })
                 break
-
             case '!reply':
                 await msg.reply('This is a reply message')
                 break
 
             case '!location':
-                await client.sendMessage(msg.from, {
+                await client.sendMessage(msgFrom, {
                     type: 'location',
                     latitude: 24.121231,
                     longitude: 55.1121221
@@ -226,7 +295,7 @@ async function start() {
                 break
 
             case '!contact':
-                await client.sendMessage(msg.from, {
+                await client.sendMessage(msgFrom, {
                     type: 'contact',
                     fullName: 'John Doe',
                     organization: 'Example Corp',
@@ -236,7 +305,7 @@ async function start() {
 
             case '!react':
                 await client.sendMessage(
-                    msg.from,
+                    msgFrom,
                     {
                         type: 'reaction',
                         emoji: '💖',
@@ -246,24 +315,36 @@ async function start() {
                 break
             case '!media':
                 if (fs.existsSync('./example.jpg')) {
-                    await client.sendMedia(msg.from, './example.jpg', {
+                    await client.sendMedia(msgFrom, './example.jpg', {
                         caption: 'Check out this image!'
                     })
                 } else {
-                    await client.sendMessage(msg.from, 'Example image not found')
+                    await client.sendMessage(msgFrom, 'Example image not found')
+                }
+                break
+
+            case '!urlimage':
+                try {
+                    const integrationFormula = '\\dpi{900}\\int\\frac{1}{x}dx=\\ln\\left|x\\right|+C';
+                    const mediaurl = `https://latex.codecogs.com/png.image?${encodeURIComponent(integrationFormula)}`;
+                    await client.sendMedia(msgFrom, mediaurl, {
+                        caption: 'Check out this image!'
+                    })
+                } catch (error) {
+                    await client.sendMessage(msgFrom, `Failed to send image from URL: ${error.message}`)
                 }
                 break
 
             case '!doc':
                 if (fs.existsSync('./example.pdf')) {
-                    await client.sendDocument(msg.from, './example.pdf', 'Check out this document!')
+                    await client.sendDocument(msgFrom, './example.pdf', 'Check out this document!')
                 } else {
-                    await client.sendMessage(msg.from, 'Example document not found')
+                    await client.sendMessage(msgFrom, 'Example document not found')
                 }
                 break
 
             case '!list':
-                await client.SendList(msg.from, {
+                await client.SendList(msgFrom, {
                     text: 'Please select an option from the list below:',
                     title: 'Comprehensive Menu',
                     buttonText: 'View All Options',
@@ -298,7 +379,7 @@ async function start() {
                 break
             case '!buttons':
                 // Example: Send a text interactive message (modern Baileys format)
-                await client.sendButtons(msg.from, {
+                await client.sendButtons(msgFrom, {
                     text: 'Do you like this bot?',
                     title: 'Feedback',
                     subtitle: 'Let us know!',
@@ -323,7 +404,7 @@ async function start() {
 
                 // Example: Send an image interactive message (modern Baileys format)
 
-                await client.sendButtons(msg.from, {
+                await client.sendButtons(msgFrom, {
                     imagePath: './example.jpg',
                     caption: 'here is captions of image\nwith linebreaks', // Keep it short and concise
                     title: 'Image Title', // Max 24 chars
@@ -372,7 +453,7 @@ async function start() {
                 break
 
             case '!quickreplyv2':
-                await client.sendQuickReplyV2(msg.from, 'Please select an option below:', [
+                await client.sendQuickReplyV2(msgFrom, 'Please select an option below:', [
                     { id: 'btn-1', displayText: '✅ Accept' },
                     { id: 'btn-2', displayText: '❌ Reject' },
                     { id: 'btn-3', displayText: '📞 Contact Support' }
@@ -380,17 +461,17 @@ async function start() {
                 break
 
             case '!urlbuttonv2':
-                await client.sendUrlButtonV2(msg.from, 'Visit our website for more info', [
+                await client.sendUrlButtonV2(msgFrom, 'Visit our website for more info', [
                     { displayText: '🌐 Open Website', url: 'https://example.com' }
                 ], { title: 'Product Info', footer: 'Click to open' });
                 break
 
             case '!copycodev2':
-                await client.sendCopyCodeV2(msg.from, 'Your OTP Code is:', '123456', '📋 Copy Code');
+                await client.sendCopyCodeV2(msgFrom, 'Your OTP Code is:', '123456', '📋 Copy Code');
                 break
 
             case '!combinedv2':
-                await client.sendCombinedButtonsV2(msg.from, 'Choose an action:', [
+                await client.sendCombinedButtonsV2(msgFrom, 'Choose an action:', [
                     { type: 'reply', displayText: '🛒 Order Now', id: 'order' },
                     { type: 'url', displayText: '🌐 Website', url: 'https://example.com' },
                     { type: 'call', displayText: '📞 Phone', phoneNumber: '+923224559543' },
@@ -399,7 +480,7 @@ async function start() {
                 break
 
             case '!listv2':
-                await client.sendListV2(msg.from, {
+                await client.sendListV2(msgFrom, {
                     title: '📋 Product Menu',
                     buttonText: 'View Menu',
                     description: 'Please select a product',
@@ -423,6 +504,90 @@ async function start() {
                 });
                 break
 
+            case '!cards':
+                if (fs.existsSync('./example.jpg')) {
+                    const imageBuffer = fs.readFileSync('./example.jpg');
+                    const videoBuffer = fs.readFileSync('./example.mp4');
+
+                    await client.sendcards(msgFrom, {
+                        text: 'Body Message',
+                        title: 'Title Message',
+                        subtile: 'Subtitle Message',
+                        footer: 'Footer Message',
+                        cards: [
+                            {
+                                image: imageBuffer, // use local buffer
+                                title: 'Title Cards 1',
+                                body: 'Body Cards 1',
+                                footer: 'Footer Cards 1',
+                                buttons: [
+                                    {
+                                        name: 'quick_reply',
+                                        buttonParamsJson: JSON.stringify({
+                                            display_text: 'Display Button',
+                                            id: 'ID'
+                                        })
+                                    },
+                                    {
+                                        name: 'cta_url',
+                                        buttonParamsJson: JSON.stringify({
+                                            display_text: 'Display Button',
+                                            url: 'https://www.example.com'
+                                        })
+                                    }
+                                ]
+                            },
+                            {
+                                video: { url: 'https://files.inqscribe.com/samples/IS_Intro.mp4' },//videoBuffer, // use same local buffer for second card
+                                title: 'Title Cards 2',
+                                body: 'Body Cards 2',
+                                footer: 'Video URL',
+                                buttons: [
+                                    {
+                                        name: 'quick_reply',
+                                        buttonParamsJson: JSON.stringify({
+                                            display_text: 'Display Button',
+                                            id: 'ID2'
+                                        })
+                                    },
+                                    {
+                                        name: 'cta_url',
+                                        buttonParamsJson: JSON.stringify({
+                                            display_text: 'Display Button',
+                                            url: 'https://www.example.com'
+                                        })
+                                    }
+                                ]
+                            },
+                            {
+                                video: videoBuffer, // use same local buffer for second card
+                                title: 'Title Cards 3',
+                                body: 'Body Cards 3',
+                                footer: 'Video Buffer',
+                                buttons: [
+                                    {
+                                        name: 'quick_reply',
+                                        buttonParamsJson: JSON.stringify({
+                                            display_text: 'Display Button',
+                                            id: 'ID3'
+                                        })
+                                    },
+                                    {
+                                        name: 'cta_url',
+                                        buttonParamsJson: JSON.stringify({
+                                            display_text: 'Display Button',
+                                            url: 'https://www.example.com'
+                                        })
+                                    }
+                                ]
+                            }
+                        ]
+                    });
+                } else {
+                    await client.sendMessage(msgFrom, 'Example image (example.jpg) not found for cards demonstration.');
+                }
+                break
+
 
             case '!call':
                 try {
@@ -430,11 +595,11 @@ async function start() {
                         clearTimeout(autoCancelCallTimer);
                         autoCancelCallTimer = null;
                     }
-                    const result = await client.initiateCall(msg.from);
+                    const result = await client.initiateCall(msgFrom);
                     lastOutgoingCallId = result?.callId || null;
-                    lastOutgoingCallJid = msg.from;
+                    lastOutgoingCallJid = msgFrom;
 
-                    await client.sendMessage(msg.from, `Calling... CallId: ${lastOutgoingCallId || 'unknown'}`);
+                    await client.sendMessage(msgFrom, `Calling... CallId: ${lastOutgoingCallId || 'unknown'}`);
 
                     if (lastOutgoingCallId) {
                         autoCancelCallTimer = setTimeout(async () => {
@@ -451,7 +616,7 @@ async function start() {
                     }
                 } catch (error) {
                     console.error('Error initiating voice call:', error);
-                    await client.sendMessage(msg.from, 'Failed to initiate call');
+                    await client.sendMessage(msgFrom, 'Failed to initiate call');
                 }
                 break
 
@@ -461,10 +626,10 @@ async function start() {
                         clearTimeout(autoCancelCallTimer);
                         autoCancelCallTimer = null;
                     }
-                    const result = await client.initiateCall(msg.from, { isVideo: true });
+                    const result = await client.initiateCall(msgFrom, { isVideo: true });
                     lastOutgoingCallId = result?.callId || null;
-                    lastOutgoingCallJid = msg.from;
-                    await client.sendMessage(msg.from, `Video calling... CallId: ${lastOutgoingCallId || 'unknown'}`);
+                    lastOutgoingCallJid = msgFrom;
+                    await client.sendMessage(msgFrom, `Video calling... CallId: ${lastOutgoingCallId || 'unknown'}`);
 
                     if (lastOutgoingCallId) {
                         autoCancelCallTimer = setTimeout(async () => {
@@ -481,7 +646,7 @@ async function start() {
                     }
                 } catch (error) {
                     console.error('Error initiating video call:', error);
-                    await client.sendMessage(msg.from, 'Failed to initiate video call');
+                    await client.sendMessage(msgFrom, 'Failed to initiate video call');
                 }
                 break
 
@@ -492,16 +657,16 @@ async function start() {
                         autoCancelCallTimer = null;
                     }
                     if (!lastOutgoingCallId) {
-                        await client.sendMessage(msg.from, 'No outgoing call to cancel');
+                        await client.sendMessage(msgFrom, 'No outgoing call to cancel');
                         break;
                     }
-                    await client.cancelCall(lastOutgoingCallId, msg.from);
-                    await client.sendMessage(msg.from, `Canceled call: ${lastOutgoingCallId}`);
+                    await client.cancelCall(lastOutgoingCallId, msgFrom);
+                    await client.sendMessage(msgFrom, `Canceled call: ${lastOutgoingCallId}`);
                     lastOutgoingCallId = null;
                     lastOutgoingCallJid = null;
                 } catch (error) {
                     console.error('Error canceling call:', error);
-                    await client.sendMessage(msg.from, 'Failed to cancel call');
+                    await client.sendMessage(msgFrom, 'Failed to cancel call');
                 }
                 break
 
@@ -562,14 +727,33 @@ async function start() {
                     `• !updatestatus <text> - Update profile status\n` +
                     `• !updatename <text> - Update profile name\n\n` +
 
+                    `*🤖 Rich AI Messaging*\n` +
+                    `• !table - Send a formatted table\n` +
+                    `• !richlist - Send a bulleted list\n` +
+                    `• !codeblock - Send a syntax-highlighted code snippet\n` +
+                    `• !latex - Send LaTeX text\n` +
+                    `• !lateximage - Send LaTeX image\n` +
+                    `• !latexinlineimage - Send LaTeX inline image\n` +
+                    `• !rich - Send demo rich message\n` +
+                    `• !markdown - Send native markdown message\n` +
+                    `• !richresponse - Send rich text with code block\n\n` +
+
                     `*🎛️ Templates & Buttons*\n` +
                     `• !buttons - Button template\n` +
-                    `• !list - Scrollable list\n` +
+                    `• !list - Scrollable list\n\n` +
                     `• !quickreplyv2 - Quick reply buttons V2\n` +
                     `• !urlbuttonv2 - URL button V2\n` +
                     `• !copycodev2 - Copy code button V2\n` +
                     `• !combinedv2 - Mixed buttons V2\n` +
-                    `• !listv2 - Interactive list V2\n\n` +
+                    `• !listv2 - Interactive list V2\n` +
+                    `• !cards - Interactive cards message\n\n` +
+
+                    `*🟢 Status*\n` +
+                    `• !statustext - Post a text status\n` +
+                    `• !statusimage - Post an image status\n` +
+                    `• !statusvideo - Post a video status\n` +
+                    `• !statusvoice - Post a voice note status\n` +
+                    `• !groupstatus - Post a status directly inside a group (@g.us)\n\n` +
 
                     `*📞 Calls*\n` +
                     `• !call - Initiate a voice call\n` +
@@ -603,9 +787,179 @@ async function start() {
                     `• !logout - End session\n\n` +
 
                     `*📝 Note*:\nReplace <number> with phone number\n(without + or spaces)`
-                await client.sendMessage(msg.from, help)
+                await client.sendMessage(msgFrom, help)
                 break
 
+            case '!table':
+                await client.sendTable(
+                    msgFrom,
+                    'Price List',
+                    ['Item', 'Qty', 'Price'],
+                    [
+                        ['Apple', '3', '$1.50'],
+                        ['Banana', '6', '$0.90'],
+                        ['Cherry', '1', '$3.00']
+                    ],
+                    msg.raw,
+                    { headerText: 'Here is your order summary:', footer: 'Thank you!' }
+                );
+                break;
+
+            case '!richlist':
+                await client.sendRichList(
+                    msgFrom,
+                    'Available Commands',
+                    ['!help', '!ping', '!menu', '!info'],
+                    msg.raw,
+                    { headerText: 'Bot commands:', footer: 'Type any command to use it.' }
+                );
+                break;
+
+            case '!codeblock':
+                await client.sendCodeBlock(
+                    msgFrom,
+                    `async function fetchData(url) {\n  const res = await fetch(url)\n  return res.json()\n}`,
+                    msg.raw,
+                    { title: '📦 Example – fetch helper', language: 'javascript', footer: 'Copy and paste into your project.' }
+                );
+                break;
+
+            case '!latex':
+                await client.sendLatex(
+                    msgFrom,
+                    { text: 'Quadratic formula:', expressions: [{ latexExpression: 'x=\\frac{-b\\pm\\sqrt{b^2-4ac}}{2a}' }] }
+                );
+                break;
+
+            case '!lateximage':
+                try {
+                    await client.sendLatexImage(
+                        msgFrom,
+                        {
+                            formula: 'E=mc^2',
+                            caption: 'Mass-Energy Equivalence (DPI 600)'
+                        }
+                    );
+                } catch (error) {
+                    return (error)
+                }
+                break;
+
+            case '!latexinlineimage':
+                try {
+                    await client.sendLatexInlineImage(
+                        msgFrom,
+                        {
+                            expressions: [
+                                { latexExpression: 'e^{i\\pi} + 1 = 0' },
+                                { latexExpression: '\\int_a^b x^2 \\, dx = \\frac{b^3 - a^3}{3}' },
+                                { latexExpression: 'f(x) = \\sum_{n=0}^{\\infty} \\frac{f^{(n)}(a)}{n!} (x-a)^n' }
+                            ],
+                            caption: true // Use each LaTeX expression as the caption for its respective image in the album
+                        }
+                    );
+                } catch (error) {
+                    return (error)
+                }
+                break;
+
+            case '!rich':
+                const richLatexExpr = 'E = mc^2';
+                const richPngBuf = await renderLatexToPng(richLatexExpr);
+                const richImageUrl = (await uploadUnencryptedToWA(richPngBuf.buffer, client.sock.waUploadToServer)).url;
+
+                await client.sendRichMessage(msgFrom, [
+                    {
+                        messageType: RichSubMessageType.TEXT,
+                        messageText: '# H1\n## H2\n### H3\n#### H4\n##### H5\n###### H6\n\n___\n\n> To use a horizontal line, you need to have two "\\n" above and below the "___"\n==Highlighted text==\n# By the way, ^you^ can _mix_ ==multiple markdowns== for a **richer response**\n###### Try different combinations...'
+                    },
+                    {
+                        messageType: RichSubMessageType.TABLE,
+                        tableMetadata: {
+                            title: 'Product Prices',
+                            rows: [
+                                { items: ['Product', 'Price', 'Stock'], isHeading: true },
+                                { items: ['Innovators Baileys Pro', '$49.99', 'In Stock'] },
+                                { items: ['Rust WASM Plugin', '$19.99', 'Low Stock'] }
+                            ]
+                        }
+                    },
+                    {
+                        messageType: RichSubMessageType.TEXT,
+                        messageText: 'LaTeX Formula:'
+                    },
+                    {
+                        messageType: RichSubMessageType.INLINE_IMAGE,
+                        imageMetadata: {
+                            imageUrl: {
+                                imagePreviewUrl: richImageUrl,
+                                imageHighResUrl: richImageUrl
+                            },
+                            imageText: richLatexExpr,
+                            alignment: 2
+                        }
+                    },
+                    {
+                        messageType: RichSubMessageType.CODE,
+                        codeMetadata: {
+                            codeLanguage: 'javascript',
+                            codeBlocks: [
+                                { highlightType: 1, codeContent: 'const ' },
+                                { highlightType: 0, codeContent: 'price = ' },
+                                { highlightType: 4, codeContent: '49.99' },
+                                { highlightType: 0, codeContent: ';\n' },
+                                { highlightType: 1, codeContent: 'if ' },
+                                { highlightType: 0, codeContent: '(price > ' },
+                                { highlightType: 4, codeContent: '20' },
+                                { highlightType: 0, codeContent: ') {\n    console.log(' },
+                                { highlightType: 3, codeContent: '"Premium tier"' },
+                                { highlightType: 0, codeContent: ');\n}' }
+                            ]
+                        }
+                    }
+                ], null, { useMarkdown: true });
+                break;
+
+            case '!markdown':
+                await client.sendMarkdown(
+                    msgFrom,
+                    '# Markdown Demo\n## Headers work\n==Highlighted text==\n_Italics_ and **Bold** are supported!',
+                    msg.raw
+                );
+                break;
+
+            case '!richresponse':
+                // Demonstrate that sendMessage can now natively accept an array of rich submessages
+                await client.sendMessage(msgFrom, {
+                    richResponse: [
+                        {
+                            messageType: 2,
+                            messageText: '# H1\n## H2\n### H3\n#### H4\n##### H5\n###### H6\n\n___\n\n> To use a horizontal line, you need to have two "\\n" above and below the "___"\n==Highlighted text==\n# By the way, ^you^ can _mix_ ==multiple markdowns== for a **richer response**\n###### Try different combinations...'
+                        },
+                        {
+                            messageType: 2,
+                            messageText: 'And here is a syntax-highlighted code block natively passed:'
+                        },
+                        {
+                            messageType: 5,
+                            codeMetadata: {
+                                codeLanguage: 'javascript',
+                                codeBlocks: [
+                                    { highlightType: 1, codeContent: 'const ' },
+                                    { highlightType: 0, codeContent: 'greet = (name) => {\n  console.log(' },
+                                    { highlightType: 3, codeContent: '"Hello, "' },
+                                    { highlightType: 0, codeContent: ' + name)\n}\n' },
+                                    { highlightType: 0, codeContent: 'greet(' },
+                                    { highlightType: 3, codeContent: '"World"' },
+                                    { highlightType: 0, codeContent: ')' }
+                                ]
+                            }
+                        }
+                    ]
+                },
+                    { markdown: true });
+                break;
+
             case '!groups':
                 try {
                     const groups = await client.getAllGroups()
@@ -619,13 +973,13 @@ async function start() {
                             if (group.desc) groupList += `   Description: ${group.desc}\n`
                             groupList += '\n'
                         })
-                        await client.sendMessage(msg.from, groupList)
+                        await client.sendMessage(msgFrom, groupList)
                     } else {
-                        await client.sendMessage(msg.from, 'You are not in any groups')
+                        await client.sendMessage(msgFrom, 'You are not in any groups')
                     }
                 } catch (error) {
                     console.error('Error fetching groups:', error)
-                    await client.sendMessage(msg.from, 'Failed to fetch groups')
+                    await client.sendMessage(msgFrom, 'Failed to fetch groups')
                 }
                 break
 
@@ -634,7 +988,7 @@ async function start() {
                     // Use provided group JID or current group
                     const groupJid = args.trim() || msg.raw.key.remoteJid
                     if (!groupJid || !groupJid.endsWith('@g.us')) {
-                        await client.sendMessage(msg.from, '❌ Please provide a group JID or use this command in a group.\nUsage: !groupinfo <groupJid>')
+                        await client.sendMessage(msgFrom, '❌ Please provide a group JID or use this command in a group.\nUsage: !groupinfo <groupJid>')
                         break
                     }
                     const groupInfo = await client.getGroupMetadata(groupJid)
@@ -659,18 +1013,18 @@ async function start() {
                             groupList += '\n'
                         })
 
-                        await client.sendMessage(msg.from, groupList)
+                        await client.sendMessage(msgFrom, groupList)
                     } else {
-                        await client.sendMessage(msg.from, 'Group not found')
+                        await client.sendMessage(msgFrom, 'Group not found')
                     }
                 } catch (error) {
                     console.error('Error fetching group info:', error)
-                    await client.sendMessage(msg.from, 'Failed to fetch group info')
+                    await client.sendMessage(msgFrom, 'Failed to fetch group info')
                 }
                 break
             case '!logout':
                 // Ask for confirmation before logging out
-                await client.sendButtons(msg.from, {
+                await client.sendButtons(msgFrom, {
                     text: 'Are you sure you want to logout?',
                     title: 'Logout Confirmation',
                     footer: 'Choose Yes to logout or No to cancel',
@@ -697,26 +1051,26 @@ async function start() {
             case 'yes':
             case 'logout_yes':
 
-                await client.sendMessage(msg.from, 'You have been logged out.');
+                await client.sendMessage(msgFrom, 'You have been logged out.');
                 await client.logout();
                 break;
             case 'No':
             case 'no':
             case 'logout_no':
-                await client.sendMessage(msg.from, 'Logout cancelled.');
+                await client.sendMessage(msgFrom, 'Logout cancelled.');
                 break;
             case '!lid':
                 // Get LID for the user's phone number
                 try {
-                    const lid = await client.getLIDForPN(msg.from);
+                    const lid = await client.getLIDForPN(msgFrom);
                     if (lid) {
-                        await client.sendMessage(msg.from, `Your LID: ${lid}\nYour PN: ${msg.from}`);
+                        await client.sendMessage(msgFrom, `Your LID: ${lid}\nYour PN: ${msgFrom}`);
                     } else {
-                        await client.sendMessage(msg.from, `No LID found for ${msg.from}. You might be using a PN-only session.`);
+                        await client.sendMessage(msgFrom, `No LID found for ${msgFrom}. You might be using a PN-only session.`);
                     }
                 } catch (error) {
                     console.error('Error getting LID:', error);
-                    await client.sendMessage(msg.from, 'Failed to get LID.');
+                    await client.sendMessage(msgFrom, 'Failed to get LID.');
                 }
                 break;
 
@@ -725,23 +1079,23 @@ async function start() {
                 try {
                     const lidToCheck = args.trim();
                     if (!lidToCheck) {
-                        await client.sendMessage(msg.from, 'Please provide a LID. Example: !pn 123456@lid');
+                        await client.sendMessage(msgFrom, 'Please provide a LID. Example: !pn 123456@lid');
                         break;
                     }
                     const pn = await client.getPNForLID(lidToCheck);
                     if (pn) {
-                        await client.sendMessage(msg.from, `Phone Number for ${lidToCheck}: ${pn}`);
+                        await client.sendMessage(msgFrom, `Phone Number for ${lidToCheck}: ${pn}`);
                     } else {
-                        await client.sendMessage(msg.from, `No phone number found for LID: ${lidToCheck}`);
+                        await client.sendMessage(msgFrom, `No phone number found for LID: ${lidToCheck}`);
                     }
                 } catch (error) {
                     console.error('Error getting PN from LID:', error);
-                    await client.sendMessage(msg.from, 'Failed to get phone number.');
+                    await client.sendMessage(msgFrom, 'Failed to get phone number.');
                 }
                 break;
             case '!ad':
                 await client.sendAdReply(
-                    msg.from,
+                    msgFrom,
                     'Ad Message',
                     './example.jpg',
                     'Ad Title',
@@ -754,82 +1108,82 @@ async function start() {
                 if (fs.existsSync('./example.jpg')) {
                     const path = './example.jpg';
                     const imageBuffer = fs.readFileSync(path);
-                    await client.sendSticker(msg.from, imageBuffer, { packName: 'Innovators', author: 'Innovators Soft' });
+                    await client.sendSticker(msgFrom, imageBuffer, { packName: 'Innovators', author: 'Innovators Soft' });
                 } else {
-                    await client.sendMessage(msg.from, 'Example image (jpg) not found')
+                    await client.sendMessage(msgFrom, 'Example image (jpg) not found')
                 }
                 break;
 
             case '!parse':
                 if (args) {
                     const info = client.parseJid(args);
-                    await client.sendMessage(msg.from, `*JID Info:*\n\nUser: ${info.user}\nServer: ${info.server}\nIs LID: ${info.isLid}`);
+                    await client.sendMessage(msgFrom, `*JID Info:*\n\nUser: ${info.user}\nServer: ${info.server}\nIs LID: ${info.isLid}`);
                 } else {
-                    await client.sendMessage(msg.from, 'Please provide a JID to parse');
+                    await client.sendMessage(msgFrom, 'Please provide a JID to parse');
                 }
                 break;
 
             case '!normalize':
                 if (args) {
                     const jid = client.normalizePhoneToJid(args);
-                    await client.sendMessage(msg.from, `*Normalized JID:* ${jid}`);
+                    await client.sendMessage(msgFrom, `*Normalized JID:* ${jid}`);
                 } else {
-                    await client.sendMessage(msg.from, 'Please provide a phone number');
+                    await client.sendMessage(msgFrom, 'Please provide a phone number');
                 }
                 break;
 
             case '!typing':
-                await client.sendStateTyping(msg.from);
-                await client.sendMessage(msg.from, 'Typing indicator sent!');
+                await client.sendStateTyping(msgFrom);
+                await client.sendMessage(msgFrom, 'Typing indicator sent!');
                 break;
 
             case '!recording':
-                await client.sendStateRecording(msg.from);
-                await client.sendMessage(msg.from, 'Recording indicator sent!');
+                await client.sendStateRecording(msgFrom);
+                await client.sendMessage(msgFrom, 'Recording indicator sent!');
                 break;
 
             case '!paused':
-                await client.clearState(msg.from);
-                await client.sendMessage(msg.from, 'Stopped typing/recording indicator sent!');
+                await client.clearState(msgFrom);
+                await client.sendMessage(msgFrom, 'Stopped typing/recording indicator sent!');
                 break;
 
             case '!typing_simulate':
                 // Show "typing..." for 5 seconds, then send the message — all in one call
-                await client.sendMessage(msg.from, 'Simulating typing for 5 seconds...');
+                await client.sendMessage(msgFrom, 'Simulating typing for 5 seconds...');
                 const typing = client.createPresenceController();
-                await typing.simulateTyping(msg.from, 5000, async () => {
-                    await client.sendMessage(msg.from, 'This message was sent after 5 seconds of typing! ✅');
+                await typing.simulateTyping(msgFrom, 5000, async () => {
+                    await client.sendMessage(msgFrom, 'This message was sent after 5 seconds of typing! ✅');
                 });
                 break;
 
             case '!typing_start':
                 // Manual start (auto-pauses after 5 s by default if not specified)
                 const typingStart = client.createPresenceController();
-                await typingStart.startTyping(msg.from, { duration: 10000 }); // Show for 10s
-                await client.sendMessage(msg.from, 'Typing indicator started for 10 seconds.');
+                await typingStart.startTyping(msgFrom, { duration: 10000 }); // Show for 10s
+                await client.sendMessage(msgFrom, 'Typing indicator started for 10 seconds.');
                 break;
 
             case '!typing_stop':
                 const typingStop = client.createPresenceController();
-                await typingStop.stopTyping(msg.from);
-                await client.sendMessage(msg.from, 'Typing indicator stopped.');
+                await typingStop.stopTyping(msgFrom);
+                await client.sendMessage(msgFrom, 'Typing indicator stopped.');
                 break;
 
             case '!recording_start':
                 const recordingIndicator = client.createPresenceController();
-                await recordingIndicator.startRecording(msg.from, { duration: 5000 });
-                await client.sendMessage(msg.from, 'Recording indicator started for 5 seconds.');
+                await recordingIndicator.startRecording(msgFrom, { duration: 5000 });
+                await client.sendMessage(msgFrom, 'Recording indicator started for 5 seconds.');
                 break;
 
             case '!typing_stop_all':
                 const typingStopAll = client.createPresenceController();
                 await typingStopAll.stopAll();
-                await client.sendMessage(msg.from, 'All active indicators for this controller stopped.');
+                await client.sendMessage(msgFrom, 'All active indicators for this controller stopped.');
                 break;
 
             case '!read':
                 await client.readMessage(msg.raw.key);
-                await client.sendMessage(msg.from, 'Message marked as read!');
+                await client.sendMessage(msgFrom, 'Message marked as read!');
                 break;
 
             case '!add':
@@ -838,7 +1192,7 @@ async function start() {
             case '!demote':
                 try {
                     if (!msg.raw.key.remoteJid.endsWith('@g.us')) {
-                        await client.sendMessage(msg.from, 'This command can only be used in groups')
+                        await client.sendMessage(msgFrom, 'This command can only be used in groups')
                         break
                     }
 
@@ -846,7 +1200,7 @@ async function start() {
 
                     // Validate phone number format
                     if (!rawNumber || rawNumber.length < 10) {
-                        await client.sendMessage(msg.from,
+                        await client.sendMessage(msgFrom,
                             `❌ Invalid phone number format.\n\n` +
                             `✅ Correct format: !${command.slice(1)} 923001234567\n` +
                             `(Include country code without + or spaces)`
@@ -856,7 +1210,7 @@ async function start() {
 
                     // Ensure country code is present (check if starts with common codes)
                     if (rawNumber.startsWith('0')) {
-                        await client.sendMessage(msg.from,
+                        await client.sendMessage(msgFrom,
                             `❌ Phone number must include country code.\n\n` +
                             `Example:\n` +
                             `• Pakistan: 923001234567 (not 03001234567)\n` +
@@ -885,18 +1239,18 @@ async function start() {
                     }
 
                     if (result[0].status == 200) {
-                        await client.sendMessage(msg.from, `Successfully ${actionMap[action]} the group`)
+                        await client.sendMessage(msgFrom, `Successfully ${actionMap[action]} the group`)
                     } else if (result[0].status == 403 && result[0].invitationSent) {
-                        await client.sendMessage(msg.from, `⚠️ Could not add directly due to privacy settings.\n✅ Group invitation link has been sent to the user instead!`)
+                        await client.sendMessage(msgFrom, `⚠️ Could not add directly due to privacy settings.\n✅ Group invitation link has been sent to the user instead!`)
                     } else {
-                        await client.sendMessage(msg.from, `Failed to ${action} participant: ${result[0].message || result[0].content || result[0].error || 'Unknown error'}`)
+                        await client.sendMessage(msgFrom, `Failed to ${action} participant: ${result[0].message || result[0].content || result[0].error || 'Unknown error'}`)
                     }
                 } catch (error) {
                     console.error(`Error ${command} participant:`, error)
                     if (error.output?.statusCode === 408) {
-                        await client.sendMessage(msg.from, `⏱️ Request timed out. The number might be invalid or not on WhatsApp.`)
+                        await client.sendMessage(msgFrom, `⏱️ Request timed out. The number might be invalid or not on WhatsApp.`)
                     } else {
-                        await client.sendMessage(msg.from, `Failed to ${command.slice(1)} participant: ${error.message || 'Unknown error'}`)
+                        await client.sendMessage(msgFrom, `Failed to ${command.slice(1)} participant: ${error.message || 'Unknown error'}`)
                     }
                 }
                 break
@@ -905,7 +1259,7 @@ async function start() {
             case '!invite':
                 try {
                     if (!msg.raw.key.remoteJid.endsWith('@g.us')) {
-                        await client.sendMessage(msg.from, 'This command can only be used in groups')
+                        await client.sendMessage(msgFrom, 'This command can only be used in groups')
                         break
                     }
 
@@ -913,7 +1267,7 @@ async function start() {
 
                     // Validate phone number format
                     if (!rawInviteNumber || rawInviteNumber.length < 10) {
-                        await client.sendMessage(msg.from,
+                        await client.sendMessage(msgFrom,
                             `❌ Invalid phone number format.\n\n` +
                             `✅ Correct format: !invite 923001234567\n` +
                             `(Include country code without + or spaces)`
@@ -923,7 +1277,7 @@ async function start() {
 
                     // Ensure country code is present
                     if (rawInviteNumber.startsWith('0')) {
-                        await client.sendMessage(msg.from,
+                        await client.sendMessage(msgFrom,
                             `❌ Phone number must include country code.\n\n` +
                             `Example:\n` +
                             `• Pakistan: 923001234567 (not 03001234567)\n` +
@@ -936,13 +1290,13 @@ async function start() {
                     const inviteNumber = rawInviteNumber + '@s.whatsapp.net'
 
                     await client.sendGroupInvitation(msg.raw.key.remoteJid, inviteNumber)
-                    await client.sendMessage(msg.from, `✅ Group invitation sent to ${rawInviteNumber}`)
+                    await client.sendMessage(msgFrom, `✅ Group invitation sent to ${rawInviteNumber}`)
                 } catch (error) {
                     console.error('Error sending invitation:', error)
                     if (error.output?.statusCode === 408) {
-                        await client.sendMessage(msg.from, `⏱️ Request timed out. The number might be invalid or not on WhatsApp.`)
+                        await client.sendMessage(msgFrom, `⏱️ Request timed out. The number might be invalid or not on WhatsApp.`)
                     } else {
-                        await client.sendMessage(msg.from, `Failed to send group invitation: ${error.message || 'Unknown error'}`)
+                        await client.sendMessage(msgFrom, `Failed to send group invitation: ${error.message || 'Unknown error'}`)
                     }
                 }
                 break
@@ -954,61 +1308,61 @@ async function start() {
             case '!creategroup':
                 try {
                     if (!args) {
-                        await client.sendMessage(msg.from, '❌ Please provide a group name.\nUsage: !creategroup My New Group');
+                        await client.sendMessage(msgFrom, '❌ Please provide a group name.\nUsage: !creategroup My New Group');
                         break;
                     }
-                    const newGroup = await client.createGroup(args, [msg.sender]);
-                    await client.sendMessage(msg.from, `✅ Group created!\n\nName: *${args}*\nID: ${newGroup.id || newGroup.gid}`);
+                    const newGroup = await client.createGroup(args, [msgFrom]);
+                    await client.sendMessage(msgFrom, `✅ Group created!\n\nName: *${args}*\nID: ${newGroup.id || newGroup.gid}`);
                 } catch (error) {
                     console.error('Error creating group:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to create group: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to create group: ${error.message}`);
                 }
                 break;
 
             case '!groupsubject':
                 try {
                     if (!msg.raw.key.remoteJid.endsWith('@g.us')) {
-                        await client.sendMessage(msg.from, '❌ This command can only be used in groups');
+                        await client.sendMessage(msgFrom, '❌ This command can only be used in groups');
                         break;
                     }
                     if (!args) {
-                        await client.sendMessage(msg.from, '❌ Please provide a new group name.\nUsage: !groupsubject New Name');
+                        await client.sendMessage(msgFrom, '❌ Please provide a new group name.\nUsage: !groupsubject New Name');
                         break;
                     }
                     await client.changeGroupSubject(msg.raw.key.remoteJid, args);
-                    await client.sendMessage(msg.from, `✅ Group name changed to: *${args}*`);
+                    await client.sendMessage(msgFrom, `✅ Group name changed to: *${args}*`);
                 } catch (error) {
                     console.error('Error changing group subject:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to change group name: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to change group name: ${error.message}`);
                 }
                 break;
 
             case '!groupdesc':
                 try {
                     if (!msg.raw.key.remoteJid.endsWith('@g.us')) {
-                        await client.sendMessage(msg.from, '❌ This command can only be used in groups');
+                        await client.sendMessage(msgFrom, '❌ This command can only be used in groups');
                         break;
                     }
                     if (!args) {
-                        await client.sendMessage(msg.from, '❌ Please provide a new description.\nUsage: !groupdesc New description here');
+                        await client.sendMessage(msgFrom, '❌ Please provide a new description.\nUsage: !groupdesc New description here');
                         break;
                     }
                     await client.changeGroupDescription(msg.raw.key.remoteJid, args);
-                    await client.sendMessage(msg.from, `✅ Group description updated!`);
+                    await client.sendMessage(msgFrom, `✅ Group description updated!`);
                 } catch (error) {
                     console.error('Error changing group description:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to change description: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to change description: ${error.message}`);
                 }
                 break;
 
             case '!groupsetting':
                 try {
                     if (!msg.raw.key.remoteJid.endsWith('@g.us')) {
-                        await client.sendMessage(msg.from, '❌ This command can only be used in groups');
+                        await client.sendMessage(msgFrom, '❌ This command can only be used in groups');
                         break;
                     }
                     if (!args || !['announcement', 'not_announcement', 'locked', 'unlocked'].includes(args.trim())) {
-                        await client.sendMessage(msg.from,
+                        await client.sendMessage(msgFrom,
                             `❌ Invalid setting.\n\n` +
                             `Usage: !groupsetting <setting>\n\n` +
                             `Available settings:\n` +
@@ -1020,66 +1374,66 @@ async function start() {
                         break;
                     }
                     await client.changeGroupSettings(msg.raw.key.remoteJid, args.trim());
-                    await client.sendMessage(msg.from, `✅ Group setting changed to: *${args.trim()}*`);
+                    await client.sendMessage(msgFrom, `✅ Group setting changed to: *${args.trim()}*`);
                 } catch (error) {
                     console.error('Error changing group settings:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to change setting: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to change setting: ${error.message}`);
                 }
                 break;
 
             case '!invitecode':
                 try {
                     if (!msg.raw.key.remoteJid.endsWith('@g.us')) {
-                        await client.sendMessage(msg.from, '❌ This command can only be used in groups');
+                        await client.sendMessage(msgFrom, '❌ This command can only be used in groups');
                         break;
                     }
                     const inviteCode = await client.getGroupInviteCode(msg.raw.key.remoteJid);
-                    await client.sendMessage(msg.from, `✅ Group Invite Link:\nhttps://chat.whatsapp.com/${inviteCode}`);
+                    await client.sendMessage(msgFrom, `✅ Group Invite Link:\nhttps://chat.whatsapp.com/${inviteCode}`);
                 } catch (error) {
                     console.error('Error getting invite code:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to get invite code: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to get invite code: ${error.message}`);
                 }
                 break;
 
             case '!revokeinvite':
                 try {
                     if (!msg.raw.key.remoteJid.endsWith('@g.us')) {
-                        await client.sendMessage(msg.from, '❌ This command can only be used in groups');
+                        await client.sendMessage(msgFrom, '❌ This command can only be used in groups');
                         break;
                     }
                     const newInviteCode = await client.revokeGroupInviteCode(msg.raw.key.remoteJid);
-                    await client.sendMessage(msg.from, `✅ Invite code revoked!\nNew invite link:\nhttps://chat.whatsapp.com/${newInviteCode}`);
+                    await client.sendMessage(msgFrom, `✅ Invite code revoked!\nNew invite link:\nhttps://chat.whatsapp.com/${newInviteCode}`);
                 } catch (error) {
                     console.error('Error revoking invite code:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to revoke invite code: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to revoke invite code: ${error.message}`);
                 }
                 break;
 
             case '!leavegroup':
                 try {
                     if (!msg.raw.key.remoteJid.endsWith('@g.us')) {
-                        await client.sendMessage(msg.from, '❌ This command can only be used in groups');
+                        await client.sendMessage(msgFrom, '❌ This command can only be used in groups');
                         break;
                     }
-                    await client.sendMessage(msg.from, '👋 Leaving group...');
+                    await client.sendMessage(msgFrom, '👋 Leaving group...');
                     await client.leaveGroup(msg.raw.key.remoteJid);
                 } catch (error) {
                     console.error('Error leaving group:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to leave group: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to leave group: ${error.message}`);
                 }
                 break;
 
             case '!joingroup':
                 try {
                     if (!args) {
-                        await client.sendMessage(msg.from, '❌ Please provide an invite code.\nUsage: !joingroup AbCdEfGhIjK\n(or full link: !joingroup https://chat.whatsapp.com/AbCdEfGhIjK)');
+                        await client.sendMessage(msgFrom, '❌ Please provide an invite code.\nUsage: !joingroup AbCdEfGhIjK\n(or full link: !joingroup https://chat.whatsapp.com/AbCdEfGhIjK)');
                         break;
                     }
                     const joinedGroupId = await client.joinGroupByInviteCode(args.trim());
-                    await client.sendMessage(msg.from, `✅ Successfully joined group!\nGroup ID: ${joinedGroupId}`);
+                    await client.sendMessage(msgFrom, `✅ Successfully joined group!\nGroup ID: ${joinedGroupId}`);
                 } catch (error) {
                     console.error('Error joining group:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to join group: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to join group: ${error.message}`);
                 }
                 break;
 
@@ -1091,7 +1445,7 @@ async function start() {
                     if (!input) {
                         // No args: use current group
                         if (!msg.raw.key.remoteJid.endsWith('@g.us')) {
-                            await client.sendMessage(msg.from, '❌ Use this command in a group, or provide a group JID / invite code.\nUsage:\n• !groupinfo (in a group)\n• !groupinfo 120363xxxxx@g.us\n• !groupinfo AbCdEfGhIjK')
+                            await client.sendMessage(msgFrom, '❌ Use this command in a group, or provide a group JID / invite code.\nUsage:\n• !groupinfo (in a group)\n• !groupinfo 120363xxxxx@g.us\n• !groupinfo AbCdEfGhIjK')
                             break
                         }
                         groupInfoResult = await client.getGroupMetadata(msg.raw.key.remoteJid)
@@ -1104,7 +1458,7 @@ async function start() {
                     }
 
                     if (!groupInfoResult) {
-                        await client.sendMessage(msg.from, '❌ Group not found.')
+                        await client.sendMessage(msgFrom, '❌ Group not found.')
                         break
                     }
 
@@ -1140,17 +1494,17 @@ async function start() {
                         })
                     }
 
-                    await client.sendMessage(msg.from, infoText)
+                    await client.sendMessage(msgFrom, infoText)
                 } catch (error) {
                     console.error('Error getting group info:', error)
-                    await client.sendMessage(msg.from, `❌ Failed to get group info: ${error.message}`)
+                    await client.sendMessage(msgFrom, `❌ Failed to get group info: ${error.message}`)
                 }
                 break;
 
             case '!joinrequests':
                 try {
                     if (!msg.raw.key.remoteJid.endsWith('@g.us')) {
-                        await client.sendMessage(msg.from, '❌ This command can only be used in groups');
+                        await client.sendMessage(msgFrom, '❌ This command can only be used in groups');
                         break;
                     }
                     const requests = await client.getGroupJoinRequests(msg.raw.key.remoteJid);
@@ -1161,63 +1515,63 @@ async function start() {
                             if (req.request_time) requestList += `   Requested: ${new Date(req.request_time * 1000).toLocaleString()}\n`;
                         });
                         requestList += `\nUse !approvejoin or !rejectjoin <number> to respond`;
-                        await client.sendMessage(msg.from, requestList);
+                        await client.sendMessage(msgFrom, requestList);
                     } else {
-                        await client.sendMessage(msg.from, '✅ No pending join requests.');
+                        await client.sendMessage(msgFrom, '✅ No pending join requests.');
                     }
                 } catch (error) {
                     console.error('Error getting join requests:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to get join requests: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to get join requests: ${error.message}`);
                 }
                 break;
 
             case '!approvejoin':
                 try {
                     if (!msg.raw.key.remoteJid.endsWith('@g.us')) {
-                        await client.sendMessage(msg.from, '❌ This command can only be used in groups');
+                        await client.sendMessage(msgFrom, '❌ This command can only be used in groups');
                         break;
                     }
                     const approveNum = args?.replace(/[^0-9]/g, '');
                     if (!approveNum || approveNum.length < 10) {
-                        await client.sendMessage(msg.from, '❌ Please provide a valid phone number.\nUsage: !approvejoin 923001234567');
+                        await client.sendMessage(msgFrom, '❌ Please provide a valid phone number.\nUsage: !approvejoin 923001234567');
                         break;
                     }
                     const approveResult = await client.handleGroupJoinRequest(msg.raw.key.remoteJid, [approveNum + '@s.whatsapp.net'], 'approve');
-                    await client.sendMessage(msg.from, `✅ Join request approved for ${approveNum}`);
+                    await client.sendMessage(msgFrom, `✅ Join request approved for ${approveNum}`);
                 } catch (error) {
                     console.error('Error approving join request:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to approve: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to approve: ${error.message}`);
                 }
                 break;
 
             case '!rejectjoin':
                 try {
                     if (!msg.raw.key.remoteJid.endsWith('@g.us')) {
-                        await client.sendMessage(msg.from, '❌ This command can only be used in groups');
+                        await client.sendMessage(msgFrom, '❌ This command can only be used in groups');
                         break;
                     }
                     const rejectNum = args?.replace(/[^0-9]/g, '');
                     if (!rejectNum || rejectNum.length < 10) {
-                        await client.sendMessage(msg.from, '❌ Please provide a valid phone number.\nUsage: !rejectjoin 923001234567');
+                        await client.sendMessage(msgFrom, '❌ Please provide a valid phone number.\nUsage: !rejectjoin 923001234567');
                         break;
                     }
                     const rejectResult = await client.handleGroupJoinRequest(msg.raw.key.remoteJid, [rejectNum + '@s.whatsapp.net'], 'reject');
-                    await client.sendMessage(msg.from, `✅ Join request rejected for ${rejectNum}`);
+                    await client.sendMessage(msgFrom, `✅ Join request rejected for ${rejectNum}`);
                 } catch (error) {
                     console.error('Error rejecting join request:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to reject: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to reject: ${error.message}`);
                 }
                 break;
 
             case '!ephemeral':
                 try {
                     if (!msg.raw.key.remoteJid.endsWith('@g.us')) {
-                        await client.sendMessage(msg.from, '❌ This command can only be used in groups');
+                        await client.sendMessage(msgFrom, '❌ This command can only be used in groups');
                         break;
                     }
                     const ephemeralSeconds = parseInt(args);
                     if (isNaN(ephemeralSeconds)) {
-                        await client.sendMessage(msg.from,
+                        await client.sendMessage(msgFrom,
                             `❌ Please provide duration in seconds.\n\n` +
                             `Usage: !ephemeral <seconds>\n\n` +
                             `Options:\n` +
@@ -1230,21 +1584,21 @@ async function start() {
                     }
                     await client.toggleGroupEphemeral(msg.raw.key.remoteJid, ephemeralSeconds);
                     const durationText = ephemeralSeconds === 0 ? 'OFF' : `${ephemeralSeconds} seconds`;
-                    await client.sendMessage(msg.from, `✅ Disappearing messages set to: *${durationText}*`);
+                    await client.sendMessage(msgFrom, `✅ Disappearing messages set to: *${durationText}*`);
                 } catch (error) {
                     console.error('Error toggling ephemeral:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to toggle disappearing messages: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to toggle disappearing messages: ${error.message}`);
                 }
                 break;
 
             case '!addmode':
                 try {
                     if (!msg.raw.key.remoteJid.endsWith('@g.us')) {
-                        await client.sendMessage(msg.from, '❌ This command can only be used in groups');
+                        await client.sendMessage(msgFrom, '❌ This command can only be used in groups');
                         break;
                     }
                     if (!args || !['all_member_add', 'admin_add'].includes(args.trim())) {
-                        await client.sendMessage(msg.from,
+                        await client.sendMessage(msgFrom,
                             `❌ Invalid mode.\n\n` +
                             `Usage: !addmode <mode>\n\n` +
                             `Options:\n` +
@@ -1254,10 +1608,10 @@ async function start() {
                         break;
                     }
                     await client.changeGroupAddMode(msg.raw.key.remoteJid, args.trim());
-                    await client.sendMessage(msg.from, `✅ Group add mode changed to: *${args.trim()}*`);
+                    await client.sendMessage(msgFrom, `✅ Group add mode changed to: *${args.trim()}*`);
                 } catch (error) {
                     console.error('Error changing add mode:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to change add mode: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to change add mode: ${error.message}`);
                 }
                 break;
 
@@ -1269,14 +1623,14 @@ async function start() {
                 try {
                     const blockNum = args?.replace(/[^0-9]/g, '');
                     if (!blockNum || blockNum.length < 10) {
-                        await client.sendMessage(msg.from, '❌ Please provide a valid phone number.\nUsage: !block 923001234567');
+                        await client.sendMessage(msgFrom, '❌ Please provide a valid phone number.\nUsage: !block 923001234567');
                         break;
                     }
                     await client.blockUser(blockNum + '@s.whatsapp.net');
-                    await client.sendMessage(msg.from, `✅ User ${blockNum} has been blocked.`);
+                    await client.sendMessage(msgFrom, `✅ User ${blockNum} has been blocked.`);
                 } catch (error) {
                     console.error('Error blocking user:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to block user: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to block user: ${error.message}`);
                 }
                 break;
 
@@ -1284,14 +1638,14 @@ async function start() {
                 try {
                     const unblockNum = args?.replace(/[^0-9]/g, '');
                     if (!unblockNum || unblockNum.length < 10) {
-                        await client.sendMessage(msg.from, '❌ Please provide a valid phone number.\nUsage: !unblock 923001234567');
+                        await client.sendMessage(msgFrom, '❌ Please provide a valid phone number.\nUsage: !unblock 923001234567');
                         break;
                     }
                     await client.unblockUser(unblockNum + '@s.whatsapp.net');
-                    await client.sendMessage(msg.from, `✅ User ${unblockNum} has been unblocked.`);
+                    await client.sendMessage(msgFrom, `✅ User ${unblockNum} has been unblocked.`);
                 } catch (error) {
                     console.error('Error unblocking user:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to unblock user: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to unblock user: ${error.message}`);
                 }
                 break;
 
@@ -1302,10 +1656,10 @@ async function start() {
                     for (const [key, value] of Object.entries(privacySettings)) {
                         privacyText += `• ${key}: *${value}*\n`;
                     }
-                    await client.sendMessage(msg.from, privacyText);
+                    await client.sendMessage(msgFrom, privacyText);
                 } catch (error) {
                     console.error('Error fetching privacy settings:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to get privacy settings: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to get privacy settings: ${error.message}`);
                 }
                 break;
 
@@ -1317,13 +1671,13 @@ async function start() {
                         blockedList.forEach((jid, i) => {
                             blockText += `${i + 1}. ${jid}\n`;
                         });
-                        await client.sendMessage(msg.from, blockText);
+                        await client.sendMessage(msgFrom, blockText);
                     } else {
-                        await client.sendMessage(msg.from, '✅ No blocked contacts.');
+                        await client.sendMessage(msgFrom, '✅ No blocked contacts.');
                     }
                 } catch (error) {
                     console.error('Error fetching block list:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to get block list: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to get block list: ${error.message}`);
                 }
                 break;
 
@@ -1331,16 +1685,16 @@ async function start() {
                 try {
                     const lsValues = ['all', 'contacts', 'contact_blacklist', 'none'];
                     if (!args || !lsValues.includes(args.trim())) {
-                        await client.sendMessage(msg.from,
+                        await client.sendMessage(msgFrom,
                             `❌ Invalid value.\n\nUsage: !lastseenprivacy <value>\n\nOptions: ${lsValues.join(', ')}`
                         );
                         break;
                     }
                     await client.updateLastSeenPrivacy(args.trim());
-                    await client.sendMessage(msg.from, `✅ Last seen privacy updated to: *${args.trim()}*`);
+                    await client.sendMessage(msgFrom, `✅ Last seen privacy updated to: *${args.trim()}*`);
                 } catch (error) {
                     console.error('Error updating last seen privacy:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to update: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to update: ${error.message}`);
                 }
                 break;
 
@@ -1348,16 +1702,16 @@ async function start() {
                 try {
                     const onValues = ['all', 'match_last_seen'];
                     if (!args || !onValues.includes(args.trim())) {
-                        await client.sendMessage(msg.from,
+                        await client.sendMessage(msgFrom,
                             `❌ Invalid value.\n\nUsage: !onlineprivacy <value>\n\nOptions: ${onValues.join(', ')}`
                         );
                         break;
                     }
                     await client.updateOnlinePrivacy(args.trim());
-                    await client.sendMessage(msg.from, `✅ Online privacy updated to: *${args.trim()}*`);
+                    await client.sendMessage(msgFrom, `✅ Online privacy updated to: *${args.trim()}*`);
                 } catch (error) {
                     console.error('Error updating online privacy:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to update: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to update: ${error.message}`);
                 }
                 break;
 
@@ -1365,16 +1719,16 @@ async function start() {
                 try {
                     const pfpValues = ['all', 'contacts', 'contact_blacklist', 'none'];
                     if (!args || !pfpValues.includes(args.trim())) {
-                        await client.sendMessage(msg.from,
+                        await client.sendMessage(msgFrom,
                             `❌ Invalid value.\n\nUsage: !pfpprivacy <value>\n\nOptions: ${pfpValues.join(', ')}`
                         );
                         break;
                     }
                     await client.updateProfilePicturePrivacy(args.trim());
-                    await client.sendMessage(msg.from, `✅ Profile picture privacy updated to: *${args.trim()}*`);
+                    await client.sendMessage(msgFrom, `✅ Profile picture privacy updated to: *${args.trim()}*`);
                 } catch (error) {
                     console.error('Error updating profile picture privacy:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to update: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to update: ${error.message}`);
                 }
                 break;
 
@@ -1382,16 +1736,16 @@ async function start() {
                 try {
                     const stValues = ['all', 'contacts', 'contact_blacklist', 'none'];
                     if (!args || !stValues.includes(args.trim())) {
-                        await client.sendMessage(msg.from,
+                        await client.sendMessage(msgFrom,
                             `❌ Invalid value.\n\nUsage: !statusprivacy <value>\n\nOptions: ${stValues.join(', ')}`
                         );
                         break;
                     }
                     await client.updateStatusPrivacy(args.trim());
-                    await client.sendMessage(msg.from, `✅ Status privacy updated to: *${args.trim()}*`);
+                    await client.sendMessage(msgFrom, `✅ Status privacy updated to: *${args.trim()}*`);
                 } catch (error) {
                     console.error('Error updating status privacy:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to update: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to update: ${error.message}`);
                 }
                 break;
 
@@ -1399,16 +1753,16 @@ async function start() {
                 try {
                     const rrValues = ['all', 'none'];
                     if (!args || !rrValues.includes(args.trim())) {
-                        await client.sendMessage(msg.from,
+                        await client.sendMessage(msgFrom,
                             `❌ Invalid value.\n\nUsage: !readreceiptprivacy <value>\n\nOptions: ${rrValues.join(', ')}`
                         );
                         break;
                     }
                     await client.updateReadReceiptsPrivacy(args.trim());
-                    await client.sendMessage(msg.from, `✅ Read receipts privacy updated to: *${args.trim()}*`);
+                    await client.sendMessage(msgFrom, `✅ Read receipts privacy updated to: *${args.trim()}*`);
                 } catch (error) {
                     console.error('Error updating read receipts privacy:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to update: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to update: ${error.message}`);
                 }
                 break;
 
@@ -1416,16 +1770,16 @@ async function start() {
                 try {
                     const gaValues = ['all', 'contacts', 'contact_blacklist'];
                     if (!args || !gaValues.includes(args.trim())) {
-                        await client.sendMessage(msg.from,
+                        await client.sendMessage(msgFrom,
                             `❌ Invalid value.\n\nUsage: !groupaddprivacy <value>\n\nOptions: ${gaValues.join(', ')}`
                         );
                         break;
                     }
                     await client.updateGroupsAddPrivacy(args.trim());
-                    await client.sendMessage(msg.from, `✅ Groups add privacy updated to: *${args.trim()}*`);
+                    await client.sendMessage(msgFrom, `✅ Groups add privacy updated to: *${args.trim()}*`);
                 } catch (error) {
                     console.error('Error updating groups add privacy:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to update: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to update: ${error.message}`);
                 }
                 break;
 
@@ -1433,7 +1787,7 @@ async function start() {
                 try {
                     const disappearingSeconds = parseInt(args);
                     if (isNaN(disappearingSeconds)) {
-                        await client.sendMessage(msg.from,
+                        await client.sendMessage(msgFrom,
                             `❌ Please provide duration in seconds.\n\n` +
                             `Usage: !disappearing <seconds>\n\n` +
                             `Options:\n` +
@@ -1446,102 +1800,193 @@ async function start() {
                     }
                     await client.updateDefaultDisappearingMode(disappearingSeconds);
                     const disappearText = disappearingSeconds === 0 ? 'OFF' : `${disappearingSeconds} seconds`;
-                    await client.sendMessage(msg.from, `✅ Default disappearing mode set to: *${disappearText}*`);
+                    await client.sendMessage(msgFrom, `✅ Default disappearing mode set to: *${disappearText}*`);
                 } catch (error) {
                     console.error('Error updating default disappearing mode:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to update: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to update: ${error.message}`);
                 }
                 break;
 
             case '!updatestatus':
                 try {
                     if (!args) {
-                        await client.sendMessage(msg.from, '❌ Please provide a new status.\nUsage: !updatestatus <text>');
+                        await client.sendMessage(msgFrom, '❌ Please provide a new status.\nUsage: !updatestatus <text>');
                         break;
                     }
                     await client.updateProfileStatus(args.trim());
-                    await client.sendMessage(msg.from, `✅ Profile status updated successfully!`);
+                    await client.sendMessage(msgFrom, `✅ Profile status updated successfully!`);
                 } catch (error) {
                     console.error('Error updating profile status:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to update profile status: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to update profile status: ${error.message}`);
                 }
                 break;
 
             case '!updatename':
                 try {
                     if (!args) {
-                        await client.sendMessage(msg.from, '❌ Please provide a new name.\nUsage: !updatename <text>');
+                        await client.sendMessage(msgFrom, '❌ Please provide a new name.\nUsage: !updatename <text>');
                         break;
                     }
                     const newName = args.trim().toTitleCase();
                     await client.updateProfileName(newName);
-                    await client.sendMessage(msg.from, `✅ *${newName}* \nProfile name updated successfully!`);
+                    await client.sendMessage(msgFrom, `✅ *${newName}* \nProfile name updated successfully!`);
                 } catch (error) {
                     console.error('Error updating profile name:', error);
-                    await client.sendMessage(msg.from, `❌ Failed to update profile name: ${error.message}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to update profile name: ${error.message}`);
+                }
+                break;
+
+            case '!statustext':
+                try {
+                    await client.sendStatus({
+                        text: 'This is a test status!',
+                        backgroundColor: STATUS_BACKGROUNDS.solid.orange,
+                        font: STATUS_FONTS.SANS_SERIF
+                    }, [msgFrom]);
+                    await client.sendMessage(msgFrom, '✅ Status posted successfully!');
+                } catch (error) {
+                    console.error('Error sending text status:', error);
+                    await client.sendMessage(msgFrom, `❌ Failed to post text status: ${error.message}`);
+                }
+                break;
+
+            case '!statusimage':
+                try {
+                    if (fs.existsSync('./example.jpg')) {
+                        await client.sendStatus({
+                            imagePath: './example.jpg',
+                            caption: args || 'Beautiful day from Innovators Soft! ☀️'
+                        }, [msgFrom]);
+                        await client.sendMessage(msgFrom, '✅ Image status posted successfully!');
+                    } else {
+                        await client.sendMessage(msgFrom, '❌ example.jpg not found for status demonstration.');
+                    }
+                } catch (error) {
+                    console.error('Error sending image status:', error);
+                    await client.sendMessage(msgFrom, `❌ Failed to post image status: ${error.message}`);
+                }
+                break;
+
+            case '!statusvideo':
+                try {
+                    if (fs.existsSync('./example.mp4')) {
+                        await client.sendStatus({
+                            videoPath: './example.mp4',
+                            caption: args || 'Check this out! 🎬',
+                            isGif: false
+                        }, [msgFrom]);
+                        await client.sendMessage(msgFrom, '✅ Video status posted successfully!');
+                    } else {
+                        await client.sendMessage(msgFrom, '❌ example.mp4 not found for status demonstration.');
+                    }
+                } catch (error) {
+                    console.error('Error sending video status:', error);
+                    await client.sendMessage(msgFrom, `❌ Failed to post video status: ${error.message}`);
+                }
+                break;
+
+            case '!statusvoice':
+                try {
+                    if (fs.existsSync('./example.ogg')) {
+                        await client.sendStatus({
+                            audioPath: './example.ogg'
+                        }, [msgFrom]);
+                        await client.sendMessage(msgFrom, '✅ Voice note status posted successfully!');
+                    } else {
+                        await client.sendMessage(msgFrom, '❌ example.ogg not found for status demonstration. Try finding a small audio file.');
+                    }
+                } catch (error) {
+                    console.error('Error sending voice note status:', error);
+                    await client.sendMessage(msgFrom, `❌ Failed to post voice note status: ${error.message}`);
+                }
+                break;
+
+            case '!groupstatus':
+                try {
+                    if (!msgFrom.endsWith('@g.us')) {
+                        await client.sendMessage(msgFrom, '❌ This command only works inside a group chat (@g.us).');
+                        break;
+                    }
+
+                    await client.sendGroupStatus(msgFrom, {
+                        text: 'this is group status'
+                    });
+
+                    if (fs.existsSync('./example.jpg')) {
+                        await client.sendGroupStatus(msgFrom, {
+                            image: { url: './example.jpg' },
+                            caption: args || 'Hello Group!'
+                        });
+                        await client.sendMessage(msgFrom, '✅ Group status posted successfully!');
+                    } else {
+                        await client.sendMessage(msgFrom, '❌ example.jpg not found for group status demonstration.');
+                    }
+                } catch (error) {
+                    console.error('Error sending group status:', error);
+                    await client.sendMessage(msgFrom, `❌ Failed to post group status: ${error.message}`);
                 }
                 break;
 
             case '!messages':
-                const history = client.getStoredMessages(msg.from);
+                const history = client.getStoredMessages(msgFrom);
                 let historyText = `*💾 Stored Messages for this chat (${history.length}):*\n\n`;
                 history.slice(-10).forEach((m, i) => {
                     const content = m.message.conversation || m.message.extendedTextMessage?.text || "[Media/Other]";
                     historyText += `${i + 1}. ID: ${m.key.id}\n   Text: ${content.substring(0, 50)}${content.length > 50 ? '...' : ''}\n\n`;
                 });
-                await client.sendMessage(msg.from, historyText);
+                await client.sendMessage(msgFrom, historyText);
                 break;
 
             case '!message':
                 if (!args) {
-                    await client.sendMessage(msg.from, "❌ Please provide a message ID.");
+                    await client.sendMessage(msgFrom, "❌ Please provide a message ID.");
                     break;
                 }
-                const storedMsg = client.getStoredMessage({ remoteJid: msg.from, id: args.trim(), fromMe: false });
+                const storedMsg = client.getStoredMessage({ remoteJid: msgFrom, id: args.trim(), fromMe: false });
                 if (storedMsg) {
-                    await client.sendMessage(msg.from, `✅ Found message!\n\nContent: ${JSON.stringify(storedMsg.message, null, 2).substring(0, 1000)}`);
+                    await client.sendMessage(msgFrom, `✅ Found message!\n\nContent: ${JSON.stringify(storedMsg.message, null, 2).substring(0, 1000)}`);
                 } else {
-                    await client.sendMessage(msg.from, "❌ Message not found in store.");
+                    await client.sendMessage(msgFrom, "❌ Message not found in store.");
                 }
                 break;
 
             case '!stats':
                 const stats = client.getStoreStats();
-                await client.sendMessage(msg.from, `*📊 Message Store Statistics*\n\n• Total Chats: ${stats.totalChats}\n• Total Messages: ${stats.totalMessages}\n• Total Deleted: ${stats.totalDeleted}`);
+                await client.sendMessage(msgFrom, `*📊 Message Store Statistics*\n\n• Total Chats: ${stats.totalChats}\n• Total Messages: ${stats.totalMessages}\n• Total Deleted: ${stats.totalDeleted}`);
                 break;
 
             case '!allmessages':
                 const allMsgs = client.getAllStoredMessages();
                 const activeChats = client.getStoredChatIds();
-                await client.sendMessage(msg.from, `*🌐 Global Message Store*\n\n• Total Messages Held: ${allMsgs.length}\n• Total Active Chats: ${activeChats.length}\n\n*Active JIDs:* \n${activeChats.join('\n')}`);
+                await client.sendMessage(msgFrom, `*🌐 Global Message Store*\n\n• Total Messages Held: ${allMsgs.length}\n• Total Active Chats: ${activeChats.length}\n\n*Active JIDs:* \n${activeChats.join('\n')}`);
                 break;
 
             case '!savestore':
-                await client.sendMessage(msg.from, '💾 Saving message store to file...');
+                await client.sendMessage(msgFrom, '💾 Saving message store to file...');
                 const saveResult = await client.saveMessageStore();
                 if (saveResult.success) {
-                    await client.sendMessage(msg.from,
+                    await client.sendMessage(msgFrom,
                         `✅ *Store Saved Successfully*\n\n` +
                         `• Messages: ${saveResult.messageCount}\n` +
                         `• Path: ${saveResult.path}\n` +
                         `• Saved at: ${saveResult.savedAt.toLocaleString()}`
                     );
                 } else {
-                    await client.sendMessage(msg.from, `❌ Failed to save store: ${saveResult.error}`);
+                    await client.sendMessage(msgFrom, `❌ Failed to save store: ${saveResult.error}`);
                 }
                 break;
 
             case '!loadstore':
-                await client.sendMessage(msg.from, '📂 Loading message store from file...');
+                await client.sendMessage(msgFrom, '📂 Loading message store from file...');
                 const loadResult = await client.loadMessageStore();
                 if (loadResult.success) {
-                    await client.sendMessage(msg.from,
+                    await client.sendMessage(msgFrom,
                         `✅ *Store Loaded Successfully*\n\n` +
                         `• Messages: ${loadResult.messageCount}\n` +
                         `• Loaded from: ${loadResult.loadedFrom}`
                     );
                 } else {
-                    await client.sendMessage(msg.from,
+                    await client.sendMessage(msgFrom,
                         `⚠️ Could not load store\n` +
                         `Reason: ${loadResult.reason || loadResult.error}`
                     );