innovators-bot2 2.0.0 → 2.0.2

package/example.js

@@ -76,6 +76,19 @@ async function start() {
         console.log('📦 New LID/PN mappings received')
     })
 
+    // Handle Contact Events
+    client.on('contacts-received', (contacts) => {
+        console.log(`\n👥 History Sync: Received ${contacts.length} contacts`);
+    })
+
+    client.on('contacts-upsert', (contacts) => {
+        console.log(`\n👥 New Contacts: ${contacts.length} contacts added/updated`);
+    })
+
+    client.on('contacts-update', (updates) => {
+        console.log(`\n👥 Contact Updates: ${updates.length} contacts modified`);
+    })
+
     // Handle Anti-Delete system
     client.on('message-deleted', async (data) => {
         console.log(`\n🛡️ Message from ${data.jid} was deleted!`)
@@ -91,7 +104,7 @@ async function start() {
         console.log('Is Removed:', reaction.isRemoved)
         console.log('Message ID:', reaction.messageKey.id)
     })
-    
+
     client.on('call', (call) => {
         const callData = call[0]; // Get the first call object from the array
         if (callData.status !== 'offer') return;
@@ -242,29 +255,6 @@ async function start() {
                                 { title: 'Security', id: 'security', description: 'Security and login options' },
                                 { title: 'Payments', id: 'payments', description: 'Manage payment methods' },
                                 { title: 'Subscriptions', id: 'subscriptions', description: 'View your subscriptions' },
-                                { title: 'Orders', id: 'orders', description: 'View order history' },
-                                { title: 'Wishlist', id: 'wishlist', description: 'Your saved items' },
-                                { title: 'Addresses', id: 'addresses', description: 'Manage shipping addresses' },
-                                { title: 'Help Center', id: 'help', description: 'Get help and support' },
-                                { title: 'Contact Us', id: 'contact', description: 'Reach out to our team' },
-                                { title: 'FAQs', id: 'faqs', description: 'Frequently asked questions' },
-                                { title: 'About Us', id: 'about', description: 'Learn about our company' },
-                                { title: 'Careers', id: 'careers', description: 'Join our team' },
-                                { title: 'Blog', id: 'blog', description: 'Read our latest articles' },
-                                { title: 'Newsletter', id: 'newsletter', description: 'Subscribe to updates' },
-                                { title: 'Events', id: 'events', description: 'Upcoming events' },
-                                { title: 'Webinars', id: 'webinars', description: 'Join live webinars' },
-                                { title: 'Tutorials', id: 'tutorials', description: 'Learn how to use features' },
-                                { title: 'Documentation', id: 'docs', description: 'Technical documentation' },
-                                { title: 'API', id: 'api', description: 'Developer API' },
-                                { title: 'Integrations', id: 'integrations', description: 'Third-party integrations' },
-                                { title: 'Download', id: 'download', description: 'Download our app' },
-                                { title: 'Pricing', id: 'pricing', description: 'View pricing plans' },
-                                { title: 'Upgrade', id: 'upgrade', description: 'Upgrade your plan' },
-                                { title: 'Refer a Friend', id: 'refer', description: 'Earn rewards' },
-                                { title: 'Feedback', id: 'feedback', description: 'Share your thoughts' },
-                                { title: 'Report Issue', id: 'report', description: 'Report a problem' },
-                                { title: 'Language', id: 'language', description: 'Change language' }
                             ]
                         },
                         {
@@ -277,29 +267,6 @@ async function start() {
                                 { title: 'Data Saver', id: 'data_saver', description: 'Reduce data usage' },
                                 { title: 'Storage', id: 'storage', description: 'Manage local storage' },
                                 { title: 'Cache', id: 'cache', description: 'Clear cached data' },
-                                { title: 'Backup', id: 'backup', description: 'Backup your data' },
-                                { title: 'Restore', id: 'restore', description: 'Restore from backup' },
-                                { title: 'Export Data', id: 'export', description: 'Download your data' },
-                                { title: 'Delete Account', id: 'delete', description: 'Permanently remove account' },
-                                { title: 'Terms of Service', id: 'tos', description: 'Read terms and conditions' },
-                                { title: 'Privacy Policy', id: 'privacy_policy', description: 'How we handle your data' },
-                                { title: 'Cookie Policy', id: 'cookies', description: 'About our use of cookies' },
-                                { title: 'Accessibility', id: 'accessibility', description: 'Accessibility features' },
-                                { title: 'Version', id: 'version', description: 'App version information' },
-                                { title: 'Changelog', id: 'changelog', description: 'Recent updates' },
-                                { title: 'Roadmap', id: 'roadmap', description: 'Upcoming features' },
-                                { title: 'Status', id: 'status', description: 'Service status' },
-                                { title: 'Legal', id: 'legal', description: 'Legal information' },
-                                { title: 'Partners', id: 'partners', description: 'Our partners' },
-                                { title: 'Press', id: 'press', description: 'Press resources' },
-                                { title: 'Investors', id: 'investors', description: 'Investor relations' },
-                                { title: 'Affiliates', id: 'affiliates', description: 'Become an affiliate' },
-                                { title: 'Merchandise', id: 'merch', description: 'Official merchandise' },
-                                { title: 'Donate', id: 'donate', description: 'Support our work' },
-                                { title: 'Volunteer', id: 'volunteer', description: 'Get involved' },
-                                { title: 'Community', id: 'community', description: 'Join our community' },
-                                { title: 'Forum', id: 'forum', description: 'Community discussions' },
-                                { title: 'Beta Program', id: 'beta', description: 'Try beta features' }
                             ]
                         }
                     ]
@@ -334,10 +301,10 @@ async function start() {
 
                 await client.sendButtons(msg.from, {
                     imagePath: './example.jpg',
-                    caption: '', // Keep it short and concise
-                    title: '', // Max 24 chars
-                    subtitle: '', // Optional, appears below title
-                    footer: '',
+                    caption: 'here is captions of image\nwith linebreaks', // Keep it short and concise
+                    title: 'Image Title', // Max 24 chars
+                    subtitle: 'Image Subtitle (but optional)', // Optional, appears below title
+                    footer: 'Image Footer',
                     interactiveButtons: [
                         {
                             name: 'quick_reply',
@@ -406,7 +373,34 @@ async function start() {
                     `• !invite <number> - Send group invite link\n` +
                     `• !remove <number> - Remove participant\n` +
                     `• !promote <number> - Make admin\n` +
-                    `• !demote <number> - Remove admin\n\n` +
+                    `• !demote <number> - Remove admin\n` +
+                    `• !creategroup <name> - Create a new group\n` +
+                    `• !groupsubject <name> - Change group name\n` +
+                    `• !groupdesc <text> - Change group description\n` +
+                    `• !groupsetting <setting> - Change group settings\n` +
+                    `• !invitecode - Get group invite code\n` +
+                    `• !revokeinvite - Revoke group invite code\n` +
+                    `• !leavegroup - Leave the group\n` +
+                    `• !joingroup <code> - Join group by invite code\n` +
+                    `• !groupinfo <code> - Get group info by invite code\n` +
+                    `• !joinrequests - List pending join requests\n` +
+                    `• !approvejoin <number> - Approve join request\n` +
+                    `• !rejectjoin <number> - Reject join request\n` +
+                    `• !ephemeral <seconds> - Toggle disappearing msgs\n` +
+                    `• !addmode <mode> - Change who can add members\n\n` +
+
+                    `*🔒 Privacy*\n` +
+                    `• !block <number> - Block a user\n` +
+                    `• !unblock <number> - Unblock a user\n` +
+                    `• !privacy - Get privacy settings\n` +
+                    `• !blocklist - Get blocked contacts\n` +
+                    `• !lastseenprivacy <value> - Update last seen\n` +
+                    `• !onlineprivacy <value> - Update online status\n` +
+                    `• !pfpprivacy <value> - Update profile pic privacy\n` +
+                    `• !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` +
 
                     `*🎛️ Templates & Buttons*\n` +
                     `• !buttons - Button template\n` +
@@ -698,6 +692,469 @@ async function start() {
                     }
                 }
                 break
+
+            // ═══════════════════════════════════════════════════
+            // 📁 GROUP MANAGEMENT COMMANDS
+            // ═══════════════════════════════════════════════════
+
+            case '!creategroup':
+                try {
+                    if (!args) {
+                        await client.sendMessage(msg.from, '❌ 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}`);
+                } catch (error) {
+                    console.error('Error creating group:', error);
+                    await client.sendMessage(msg.from, `❌ 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');
+                        break;
+                    }
+                    if (!args) {
+                        await client.sendMessage(msg.from, '❌ 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}*`);
+                } catch (error) {
+                    console.error('Error changing group subject:', error);
+                    await client.sendMessage(msg.from, `❌ 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');
+                        break;
+                    }
+                    if (!args) {
+                        await client.sendMessage(msg.from, '❌ 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!`);
+                } catch (error) {
+                    console.error('Error changing group description:', error);
+                    await client.sendMessage(msg.from, `❌ 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');
+                        break;
+                    }
+                    if (!args || !['announcement', 'not_announcement', 'locked', 'unlocked'].includes(args.trim())) {
+                        await client.sendMessage(msg.from,
+                            `❌ Invalid setting.\n\n` +
+                            `Usage: !groupsetting <setting>\n\n` +
+                            `Available settings:\n` +
+                            `• announcement - Only admins can send messages\n` +
+                            `• not_announcement - Everyone can send messages\n` +
+                            `• locked - Only admins can edit group info\n` +
+                            `• unlocked - Everyone can edit group info`
+                        );
+                        break;
+                    }
+                    await client.changeGroupSettings(msg.raw.key.remoteJid, args.trim());
+                    await client.sendMessage(msg.from, `✅ 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}`);
+                }
+                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');
+                        break;
+                    }
+                    const inviteCode = await client.getGroupInviteCode(msg.raw.key.remoteJid);
+                    await client.sendMessage(msg.from, `✅ 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}`);
+                }
+                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');
+                        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}`);
+                } catch (error) {
+                    console.error('Error revoking invite code:', error);
+                    await client.sendMessage(msg.from, `❌ 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');
+                        break;
+                    }
+                    await client.sendMessage(msg.from, '👋 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}`);
+                }
+                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)');
+                        break;
+                    }
+                    const joinedGroupId = await client.joinGroupByInviteCode(args.trim());
+                    await client.sendMessage(msg.from, `✅ 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}`);
+                }
+                break;
+
+            case '!groupinfo':
+                try {
+                    if (!args) {
+                        await client.sendMessage(msg.from, '❌ Please provide an invite code.\nUsage: !groupinfo AbCdEfGhIjK');
+                        break;
+                    }
+                    const groupInfoResult = await client.getGroupInfoByInviteCode(args.trim());
+                    let infoText = `*📋 Group Info*\n\n`;
+                    infoText += `Name: *${groupInfoResult.subject || 'N/A'}*\n`;
+                    infoText += `ID: ${groupInfoResult.id || 'N/A'}\n`;
+                    infoText += `Creator: ${groupInfoResult.owner || 'N/A'}\n`;
+                    infoText += `Description: ${groupInfoResult.desc || 'No description'}\n`;
+                    infoText += `Members: ${groupInfoResult.size || groupInfoResult.participants?.length || 'N/A'}\n`;
+                    infoText += `Created: ${groupInfoResult.creation ? new Date(groupInfoResult.creation * 1000).toLocaleString() : 'N/A'}`;
+                    await client.sendMessage(msg.from, infoText);
+                } catch (error) {
+                    console.error('Error getting group info:', error);
+                    await client.sendMessage(msg.from, `❌ 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');
+                        break;
+                    }
+                    const requests = await client.getGroupJoinRequests(msg.raw.key.remoteJid);
+                    if (requests && requests.length > 0) {
+                        let requestList = `*📋 Pending Join Requests (${requests.length}):*\n\n`;
+                        requests.forEach((req, i) => {
+                            requestList += `${i + 1}. ${req.jid}\n`;
+                            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);
+                    } else {
+                        await client.sendMessage(msg.from, '✅ 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}`);
+                }
+                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');
+                        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');
+                        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}`);
+                } catch (error) {
+                    console.error('Error approving join request:', error);
+                    await client.sendMessage(msg.from, `❌ 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');
+                        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');
+                        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}`);
+                } catch (error) {
+                    console.error('Error rejecting join request:', error);
+                    await client.sendMessage(msg.from, `❌ 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');
+                        break;
+                    }
+                    const ephemeralSeconds = parseInt(args);
+                    if (isNaN(ephemeralSeconds)) {
+                        await client.sendMessage(msg.from,
+                            `❌ Please provide duration in seconds.\n\n` +
+                            `Usage: !ephemeral <seconds>\n\n` +
+                            `Options:\n` +
+                            `• 0 - Turn off\n` +
+                            `• 86400 - 24 hours\n` +
+                            `• 604800 - 7 days\n` +
+                            `• 7776000 - 90 days`
+                        );
+                        break;
+                    }
+                    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}*`);
+                } catch (error) {
+                    console.error('Error toggling ephemeral:', error);
+                    await client.sendMessage(msg.from, `❌ 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');
+                        break;
+                    }
+                    if (!args || !['all_member_add', 'admin_add'].includes(args.trim())) {
+                        await client.sendMessage(msg.from,
+                            `❌ Invalid mode.\n\n` +
+                            `Usage: !addmode <mode>\n\n` +
+                            `Options:\n` +
+                            `• all_member_add - All members can add\n` +
+                            `• admin_add - Only admins can add`
+                        );
+                        break;
+                    }
+                    await client.changeGroupAddMode(msg.raw.key.remoteJid, args.trim());
+                    await client.sendMessage(msg.from, `✅ 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}`);
+                }
+                break;
+
+            // ═══════════════════════════════════════════════════
+            // 🔒 PRIVACY COMMANDS
+            // ═══════════════════════════════════════════════════
+
+            case '!block':
+                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');
+                        break;
+                    }
+                    await client.blockUser(blockNum + '@s.whatsapp.net');
+                    await client.sendMessage(msg.from, `✅ User ${blockNum} has been blocked.`);
+                } catch (error) {
+                    console.error('Error blocking user:', error);
+                    await client.sendMessage(msg.from, `❌ Failed to block user: ${error.message}`);
+                }
+                break;
+
+            case '!unblock':
+                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');
+                        break;
+                    }
+                    await client.unblockUser(unblockNum + '@s.whatsapp.net');
+                    await client.sendMessage(msg.from, `✅ User ${unblockNum} has been unblocked.`);
+                } catch (error) {
+                    console.error('Error unblocking user:', error);
+                    await client.sendMessage(msg.from, `❌ Failed to unblock user: ${error.message}`);
+                }
+                break;
+
+            case '!privacy':
+                try {
+                    const privacySettings = await client.getPrivacySettings();
+                    let privacyText = `*🔒 Privacy Settings*\n\n`;
+                    for (const [key, value] of Object.entries(privacySettings)) {
+                        privacyText += `• ${key}: *${value}*\n`;
+                    }
+                    await client.sendMessage(msg.from, privacyText);
+                } catch (error) {
+                    console.error('Error fetching privacy settings:', error);
+                    await client.sendMessage(msg.from, `❌ Failed to get privacy settings: ${error.message}`);
+                }
+                break;
+
+            case '!blocklist':
+                try {
+                    const blockedList = await client.getBlockList();
+                    if (blockedList && blockedList.length > 0) {
+                        let blockText = `*🚫 Blocked Contacts (${blockedList.length}):*\n\n`;
+                        blockedList.forEach((jid, i) => {
+                            blockText += `${i + 1}. ${jid}\n`;
+                        });
+                        await client.sendMessage(msg.from, blockText);
+                    } else {
+                        await client.sendMessage(msg.from, '✅ No blocked contacts.');
+                    }
+                } catch (error) {
+                    console.error('Error fetching block list:', error);
+                    await client.sendMessage(msg.from, `❌ Failed to get block list: ${error.message}`);
+                }
+                break;
+
+            case '!lastseenprivacy':
+                try {
+                    const lsValues = ['all', 'contacts', 'contact_blacklist', 'none'];
+                    if (!args || !lsValues.includes(args.trim())) {
+                        await client.sendMessage(msg.from,
+                            `❌ 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()}*`);
+                } catch (error) {
+                    console.error('Error updating last seen privacy:', error);
+                    await client.sendMessage(msg.from, `❌ Failed to update: ${error.message}`);
+                }
+                break;
+
+            case '!onlineprivacy':
+                try {
+                    const onValues = ['all', 'match_last_seen'];
+                    if (!args || !onValues.includes(args.trim())) {
+                        await client.sendMessage(msg.from,
+                            `❌ 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()}*`);
+                } catch (error) {
+                    console.error('Error updating online privacy:', error);
+                    await client.sendMessage(msg.from, `❌ Failed to update: ${error.message}`);
+                }
+                break;
+
+            case '!pfpprivacy':
+                try {
+                    const pfpValues = ['all', 'contacts', 'contact_blacklist', 'none'];
+                    if (!args || !pfpValues.includes(args.trim())) {
+                        await client.sendMessage(msg.from,
+                            `❌ 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()}*`);
+                } catch (error) {
+                    console.error('Error updating profile picture privacy:', error);
+                    await client.sendMessage(msg.from, `❌ Failed to update: ${error.message}`);
+                }
+                break;
+
+            case '!statusprivacy':
+                try {
+                    const stValues = ['all', 'contacts', 'contact_blacklist', 'none'];
+                    if (!args || !stValues.includes(args.trim())) {
+                        await client.sendMessage(msg.from,
+                            `❌ 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()}*`);
+                } catch (error) {
+                    console.error('Error updating status privacy:', error);
+                    await client.sendMessage(msg.from, `❌ Failed to update: ${error.message}`);
+                }
+                break;
+
+            case '!readreceiptprivacy':
+                try {
+                    const rrValues = ['all', 'none'];
+                    if (!args || !rrValues.includes(args.trim())) {
+                        await client.sendMessage(msg.from,
+                            `❌ 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()}*`);
+                } catch (error) {
+                    console.error('Error updating read receipts privacy:', error);
+                    await client.sendMessage(msg.from, `❌ Failed to update: ${error.message}`);
+                }
+                break;
+
+            case '!groupaddprivacy':
+                try {
+                    const gaValues = ['all', 'contacts', 'contact_blacklist'];
+                    if (!args || !gaValues.includes(args.trim())) {
+                        await client.sendMessage(msg.from,
+                            `❌ 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()}*`);
+                } catch (error) {
+                    console.error('Error updating groups add privacy:', error);
+                    await client.sendMessage(msg.from, `❌ Failed to update: ${error.message}`);
+                }
+                break;
+
+            case '!disappearing':
+                try {
+                    const disappearingSeconds = parseInt(args);
+                    if (isNaN(disappearingSeconds)) {
+                        await client.sendMessage(msg.from,
+                            `❌ Please provide duration in seconds.\n\n` +
+                            `Usage: !disappearing <seconds>\n\n` +
+                            `Options:\n` +
+                            `• 0 - Turn off\n` +
+                            `• 86400 - 24 hours\n` +
+                            `• 604800 - 7 days\n` +
+                            `• 7776000 - 90 days`
+                        );
+                        break;
+                    }
+                    await client.updateDefaultDisappearingMode(disappearingSeconds);
+                    const disappearText = disappearingSeconds === 0 ? 'OFF' : `${disappearingSeconds} seconds`;
+                    await client.sendMessage(msg.from, `✅ 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}`);
+                }
+                break;
         }
     })