innovators-bot2 2.0.4 → 2.0.6

package/example.js

@@ -1,4 +1,4 @@
-const { WhatsAppClient } = require('./index')
+const { WhatsAppClient, STATUS_BACKGROUNDS, STATUS_FONTS } = require('./index')
 const qrcode = require('qrcode-terminal')
 const fs = require('fs');
 const readline = require('readline');
@@ -9,6 +9,10 @@ const rl = readline.createInterface({
     output: process.stdout
 });
 
+String.prototype.toTitleCase = function () {
+    return this.split(' ').map(w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(' ');
+};
+
 const question = (text) => new Promise((resolve) => rl.question(text, resolve));
 
 async function start() {
@@ -177,10 +181,22 @@ 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)
 
@@ -189,32 +205,40 @@ async function start() {
 
         switch (command) {
             case '!ping':
-                await client.sendMessage(msg.from, 'pong')
+                await client.sendMessage(msgFrom, 'Hello Pong! 🎊')
                 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
@@ -222,7 +246,7 @@ async function start() {
                 break
 
             case '!contact':
-                await client.sendMessage(msg.from, {
+                await client.sendMessage(msgFrom, {
                     type: 'contact',
                     fullName: 'John Doe',
                     organization: 'Example Corp',
@@ -232,7 +256,7 @@ async function start() {
 
             case '!react':
                 await client.sendMessage(
-                    msg.from,
+                    msgFrom,
                     {
                         type: 'reaction',
                         emoji: '💖',
@@ -242,24 +266,24 @@ 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 '!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',
@@ -294,7 +318,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!',
@@ -319,7 +343,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
@@ -367,17 +391,154 @@ async function start() {
                 });
                 break
 
+            case '!quickreplyv2':
+                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' }
+                ], { footer: 'Powered by Innovators Soft' });
+                break
+
+            case '!urlbuttonv2':
+                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(msgFrom, 'Your OTP Code is:', '123456', '📋 Copy Code');
+                break
+
+            case '!combinedv2':
+                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' },
+                    { type: 'copy', displayText: '📋 Copy Promo', copyCode: 'PROMO2024' }
+                ], { title: 'Main Menu', footer: 'Innovators Soft' });
+                break
+
+            case '!listv2':
+                await client.sendListV2(msgFrom, {
+                    title: '📋 Product Menu',
+                    buttonText: 'View Menu',
+                    description: 'Please select a product',
+                    footer: 'Powered by Innovators Soft',
+                    sections: [
+                        {
+                            title: 'Food',
+                            rows: [
+                                { rowId: 'nasi-goreng', title: 'Fried Rice', description: '$2.50' },
+                                { rowId: 'mie-goreng', title: 'Fried Noodles', description: '$2.00' }
+                            ]
+                        },
+                        {
+                            title: 'Beverages',
+                            rows: [
+                                { rowId: 'es-teh', title: 'Ice Tea', description: '$0.50' },
+                                { rowId: 'kopi', title: 'Coffee', description: '$1.00' }
+                            ]
+                        }
+                    ]
+                });
+                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 {
                     if (autoCancelCallTimer) {
                         clearTimeout(autoCancelCallTimer);
                         autoCancelCallTimer = null;
                     }
-                    const result = await client.initiateCall(msg.from);
+                    const result = await client.initiateCall(msgFrom);
                     lastOutgoingCallId = result?.callId || null;
-                    lastOutgoingCallJid = msg.from;
-                    
-                    await client.sendMessage(msg.from, `Calling... CallId: ${lastOutgoingCallId || 'unknown'}`);
+                    lastOutgoingCallJid = msgFrom;
+
+                    await client.sendMessage(msgFrom, `Calling... CallId: ${lastOutgoingCallId || 'unknown'}`);
 
                     if (lastOutgoingCallId) {
                         autoCancelCallTimer = setTimeout(async () => {
@@ -394,7 +555,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
 
@@ -404,10 +565,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 () => {
@@ -424,7 +585,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
 
@@ -435,16 +596,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
 
@@ -501,11 +662,26 @@ async function start() {
                     `• !statusprivacy <value> - Update status privacy\n` +
                     `• !readreceiptprivacy <value> - Update read receipts\n` +
                     `• !groupaddprivacy <value> - Who can add to groups\n` +
-                    `• !disappearing <seconds> - Default disappearing mode\n\n` +
+                    `• !disappearing <seconds> - Default disappearing mode\n` +
+                    `• !updatestatus <text> - Update profile status\n` +
+                    `• !updatename <text> - Update profile name\n\n` +
 
                     `*🎛️ Templates & Buttons*\n` +
                     `• !buttons - Button template\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` +
+                    `• !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` +
@@ -532,10 +708,14 @@ async function start() {
                     `• !typing - Show typing indicator\n` +
                     `• !recording - Show recording indicator\n` +
                     `• !paused - Clear typing or recording indicator\n` +
+                    `• !typing_simulate - Simulate typing for 5s then send msg\n` +
+                    `• !typing_start - Start typing with auto-pause\n` +
+                    `• !typing_stop - Stop typing indicator\n` +
+                    `• !recording_start - Start recording indicator\n` +
                     `• !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 '!groups':
@@ -551,13 +731,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
 
@@ -566,7 +746,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)
@@ -591,18 +771,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',
@@ -629,26 +809,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;
 
@@ -657,23 +837,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',
@@ -686,48 +866,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(msgFrom, 'Simulating typing for 5 seconds...');
+                const typing = client.createPresenceController();
+                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(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(msgFrom);
+                await client.sendMessage(msgFrom, 'Typing indicator stopped.');
+                break;
+
+            case '!recording_start':
+                const recordingIndicator = client.createPresenceController();
+                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(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':
@@ -736,7 +950,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
                     }
 
@@ -744,7 +958,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)`
@@ -754,7 +968,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` +
@@ -783,18 +997,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
@@ -803,7 +1017,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
                     }
 
@@ -811,7 +1025,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)`
@@ -821,7 +1035,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` +
@@ -834,13 +1048,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
@@ -852,61 +1066,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` +
@@ -918,66 +1132,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;
 
@@ -989,7 +1203,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)
@@ -1002,7 +1216,7 @@ async function start() {
                     }
 
                     if (!groupInfoResult) {
-                        await client.sendMessage(msg.from, '❌ Group not found.')
+                        await client.sendMessage(msgFrom, '❌ Group not found.')
                         break
                     }
 
@@ -1038,17 +1252,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);
@@ -1059,63 +1273,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` +
@@ -1128,21 +1342,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` +
@@ -1152,10 +1366,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;
 
@@ -1167,14 +1381,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;
 
@@ -1182,14 +1396,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;
 
@@ -1200,10 +1414,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;
 
@@ -1215,13 +1429,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;
 
@@ -1229,16 +1443,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;
 
@@ -1246,16 +1460,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;
 
@@ -1263,16 +1477,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;
 
@@ -1280,16 +1494,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;
 
@@ -1297,16 +1511,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;
 
@@ -1314,16 +1528,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;
 
@@ -1331,7 +1545,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` +
@@ -1344,73 +1558,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(msgFrom, '❌ Please provide a new status.\nUsage: !updatestatus <text>');
+                        break;
+                    }
+                    await client.updateProfileStatus(args.trim());
+                    await client.sendMessage(msgFrom, `✅ Profile status updated successfully!`);
+                } catch (error) {
+                    console.error('Error updating profile status:', error);
+                    await client.sendMessage(msgFrom, `❌ Failed to update profile status: ${error.message}`);
+                }
+                break;
+
+            case '!updatename':
+                try {
+                    if (!args) {
+                        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(msgFrom, `✅ *${newName}* \nProfile name updated successfully!`);
+                } catch (error) {
+                    console.error('Error updating profile name:', error);
+                    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}`
                     );