@innovatorssoft/innovators-bot2 1.2.8 → 2.0.1

package/README.md

@@ -145,6 +145,45 @@ client.on('message-deleted', async (data) => {
 // Get all groups
 const groups = await client.getAllGroups()
 
+// Get group metadata (participants, name, description...)
+const metadata = await client.getGroupMetadata(groupId)
+console.log(metadata.id, metadata.subject, metadata.desc)
+
+// Create a new group
+const newGroup = await client.createGroup('Group Name', ['1234567890@s.whatsapp.net'])
+console.log('Created group:', newGroup.id)
+
+// Change group subject (name)
+await client.changeGroupSubject(groupId, 'New Group Name')
+
+// Change group description
+await client.changeGroupDescription(groupId, 'New description for the group')
+
+// Change group settings
+// Options: 'announcement' (only admins send), 'not_announcement' (everyone sends),
+//          'locked' (only admins edit info), 'unlocked' (everyone edits info)
+await client.changeGroupSettings(groupId, 'announcement')
+
+// Get group invite code
+const code = await client.getGroupInviteCode(groupId)
+console.log('Invite link: https://chat.whatsapp.com/' + code)
+
+// Revoke invite code (generates a new one)
+const newCode = await client.revokeGroupInviteCode(groupId)
+console.log('New invite link: https://chat.whatsapp.com/' + newCode)
+
+// Join group by invite code
+const joinedGroupId = await client.joinGroupByInviteCode('AbCdEfGhIjK')
+// Also accepts full URL - it strips the prefix automatically
+await client.joinGroupByInviteCode('https://chat.whatsapp.com/AbCdEfGhIjK')
+
+// Get group info by invite code (without joining)
+const groupInfo = await client.getGroupInfoByInviteCode('AbCdEfGhIjK')
+console.log('Group name:', groupInfo.subject)
+
+// Leave a group
+await client.leaveGroup(groupId)
+
 // Add participant to group
 // Note: If adding fails due to user's privacy settings (403), 
 // an invitation link is automatically sent to the user instead.
@@ -165,9 +204,71 @@ await client.changeGroupParticipants(groupId, ['1234567890@s.whatsapp.net'], 'pr
 
 // Demote admin
 await client.changeGroupParticipants(groupId, ['1234567890@s.whatsapp.net'], 'demote')
+
+// Get pending join requests
+const requests = await client.getGroupJoinRequests(groupId)
+console.log('Pending requests:', requests)
+
+// Approve/Reject join requests
+await client.handleGroupJoinRequest(groupId, ['1234567890@s.whatsapp.net'], 'approve')
+await client.handleGroupJoinRequest(groupId, ['1234567890@s.whatsapp.net'], 'reject')
+
+// Toggle ephemeral (disappearing) messages
+// Options: 0 (off), 86400 (24h), 604800 (7d), 7776000 (90d)
+await client.toggleGroupEphemeral(groupId, 86400)
+
+// Change who can add members
+// Options: 'all_member_add' or 'admin_add'
+await client.changeGroupAddMode(groupId, 'admin_add')
 ```
 
-### 4. Interactive Messages
+### 6. Privacy Management
+
+```javascript
+// Block a user
+await client.blockUser('1234567890@s.whatsapp.net')
+
+// Unblock a user
+await client.unblockUser('1234567890@s.whatsapp.net')
+
+// Get all privacy settings
+const settings = await client.getPrivacySettings()
+console.log('Privacy settings:', settings)
+
+// Get blocked contacts list
+const blocklist = await client.getBlockList()
+console.log('Blocked users:', blocklist)
+
+// Update last seen privacy
+// Options: 'all' | 'contacts' | 'contact_blacklist' | 'none'
+await client.updateLastSeenPrivacy('contacts')
+
+// Update online status privacy
+// Options: 'all' | 'match_last_seen'
+await client.updateOnlinePrivacy('match_last_seen')
+
+// Update profile picture privacy
+// Options: 'all' | 'contacts' | 'contact_blacklist' | 'none'
+await client.updateProfilePicturePrivacy('contacts')
+
+// Update status privacy
+// Options: 'all' | 'contacts' | 'contact_blacklist' | 'none'
+await client.updateStatusPrivacy('contacts')
+
+// Update read receipts privacy
+// Options: 'all' | 'none'
+await client.updateReadReceiptsPrivacy('all')
+
+// Update who can add you to groups
+// Options: 'all' | 'contacts' | 'contact_blacklist'
+await client.updateGroupsAddPrivacy('contacts')
+
+// Update default disappearing mode for new chats
+// Options: 0 (off), 86400 (24h), 604800 (7d), 7776000 (90d)
+await client.updateDefaultDisappearingMode(604800)
+```
+
+### 7. Interactive Messages
 
 #### Buttons
 ```javascript
@@ -223,7 +324,7 @@ await client.SendList('1234567890@s.whatsapp.net', {
 });
 ```
 
-### 4. Message History
+### 8. Message History
 
 ```javascript
 // Get chat history
@@ -260,13 +361,16 @@ The library includes example bot commands that you can use:
 - `!react` - React to your message with ❤️
 - `!read` - Mark messages as read
 - `!typing` - Show typing indicator
-- `!presence` - Set online presence
+- `!recording` - Show recording indicator
+- `!paused` - Clear typing or recording indicator
 
 ### Media & Content
 - `!media` - Send an example image
 - `!doc` - Send an example document
 - `!location` - Send a location
 - `!contact` - Send a contact card
+- `!sticker` - Create a sticker from an image
+- `!ad` - Send an ad reply message
 
 ### Group Management
 - `!groups` - List all your groups
@@ -274,7 +378,34 @@ The library includes example bot commands that you can use:
 - `!remove <number>` - Remove participant from group
 - `!promote <number>` - Promote participant to admin
 - `!demote <number>` - Demote admin to participant
-- `!list` - Show interactive list message
+- `!invite <number>` - Send group invite link to user
+- `!creategroup <name>` - Create a new group
+- `!groupsubject <name>` - Change group name
+- `!groupdesc <text>` - Change group description
+- `!groupsetting <setting>` - Change group settings (announcement/not_announcement/locked/unlocked)
+- `!invitecode` - Get group invite code/link
+- `!revokeinvite` - Revoke current invite code and generate new one
+- `!leavegroup` - Leave the current group
+- `!joingroup <code>` - Join a group by invite code
+- `!groupinfo <code>` - Get group info by invite code without joining
+- `!joinrequests` - List pending join requests
+- `!approvejoin <number>` - Approve a join request
+- `!rejectjoin <number>` - Reject a join request
+- `!ephemeral <seconds>` - Toggle disappearing messages (0/86400/604800/7776000)
+- `!addmode <mode>` - Change who can add members (all_member_add/admin_add)
+
+### 🔒 Privacy
+- `!block <number>` - Block a user
+- `!unblock <number>` - Unblock a user
+- `!privacy` - View all privacy settings
+- `!blocklist` - List all blocked contacts
+- `!lastseenprivacy <value>` - Update last seen privacy (all/contacts/contact_blacklist/none)
+- `!onlineprivacy <value>` - Update online privacy (all/match_last_seen)
+- `!pfpprivacy <value>` - Update profile picture privacy (all/contacts/contact_blacklist/none)
+- `!statusprivacy <value>` - Update status privacy (all/contacts/contact_blacklist/none)
+- `!readreceiptprivacy <value>` - Update read receipts privacy (all/none)
+- `!groupaddprivacy <value>` - Update who can add you to groups (all/contacts/contact_blacklist)
+- `!disappearing <seconds>` - Update default disappearing mode (0/86400/604800/7776000)
 
 ### Interactive Messages
 - `!buttons` - Show interactive buttons
@@ -290,9 +421,6 @@ The library includes example bot commands that you can use:
 - `!parse <jid>` - Parse detailed JID information
 - `!normalize <number>` - Normalize a number to JID format
 
-### 🎨 Sticker Commands
-- `!sticker` - Create a sticker from an image
-
 ### Connection Events
 ```javascript
 // When QR code is generated

package/example.js

@@ -91,7 +91,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;
@@ -406,7 +406,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 +725,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;
         }
     })
 

package/index.js

@@ -1461,6 +1461,522 @@ class WhatsAppClient extends EventEmitter {
         }
     }
 
+    // ═══════════════════════════════════════════════════════════
+    // 📁 GROUP MANAGEMENT METHODS
+    // ═══════════════════════════════════════════════════════════
+
+    /**
+     * Create a new WhatsApp group
+     * @param {string} name - The name/subject of the group
+     * @param {Array<string>} participants - Array of participant JIDs (e.g., ['1234@s.whatsapp.net'])
+     * @returns {Promise<object>} The created group info (includes gid/id)
+     * @throws {Error} If client is not connected or group creation fails
+     */
+    async createGroup(name, participants = []) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            const group = await this.sock.groupCreate(name, participants);
+            return group;
+        } catch (error) {
+            console.error('Error creating group:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Change the subject (name) of a group
+     * @param {string} groupId - The group JID
+     * @param {string} newSubject - The new subject/name for the group
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or update fails
+     */
+    async changeGroupSubject(groupId, newSubject) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            await this.sock.groupUpdateSubject(groupId, newSubject);
+            // Update the cache with the new subject
+            const cached = this.groupMetadataCache.get(groupId);
+            if (cached) {
+                cached.subject = newSubject;
+                this.updateGroupMetadataCache(groupId, cached);
+            }
+        } catch (error) {
+            console.error('Error changing group subject:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Change the description of a group
+     * @param {string} groupId - The group JID
+     * @param {string} newDescription - The new description for the group
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or update fails
+     */
+    async changeGroupDescription(groupId, newDescription) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            await this.sock.groupUpdateDescription(groupId, newDescription);
+            // Update the cache with the new description
+            const cached = this.groupMetadataCache.get(groupId);
+            if (cached) {
+                cached.desc = newDescription;
+                this.updateGroupMetadataCache(groupId, cached);
+            }
+        } catch (error) {
+            console.error('Error changing group description:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Change group settings (announcement mode, locked/unlocked)
+     * @param {string} groupId - The group JID
+     * @param {string} setting - The setting to apply: 'announcement' (only admins send), 'not_announcement' (everyone sends), 'locked' (only admins edit info), 'unlocked' (everyone edits info)
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or update fails
+     */
+    async changeGroupSettings(groupId, setting) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        const validSettings = ['announcement', 'not_announcement', 'locked', 'unlocked'];
+        if (!validSettings.includes(setting)) {
+            throw new Error(`Invalid setting: ${setting}. Must be one of: ${validSettings.join(', ')}`);
+        }
+
+        try {
+            await this.sock.groupSettingUpdate(groupId, setting);
+        } catch (error) {
+            console.error('Error changing group settings:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Get the invite code for a group
+     * @param {string} groupId - The group JID
+     * @returns {Promise<string>} The invite code (use with https://chat.whatsapp.com/{code})
+     * @throws {Error} If client is not connected or fetch fails
+     */
+    async getGroupInviteCode(groupId) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            const code = await this.sock.groupInviteCode(groupId);
+            return code;
+        } catch (error) {
+            console.error('Error getting group invite code:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Revoke the current invite code for a group (generates a new one)
+     * @param {string} groupId - The group JID
+     * @returns {Promise<string>} The new invite code
+     * @throws {Error} If client is not connected or revoke fails
+     */
+    async revokeGroupInviteCode(groupId) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            const newCode = await this.sock.groupRevokeInvite(groupId);
+            return newCode;
+        } catch (error) {
+            console.error('Error revoking group invite code:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Leave a group
+     * @param {string} groupId - The group JID
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or leave fails
+     */
+    async leaveGroup(groupId) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            await this.sock.groupLeave(groupId);
+            // Clean up the cache for this group
+            this.clearGroupMetadataCache(groupId);
+        } catch (error) {
+            console.error('Error leaving group:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Join a group using an invitation code
+     * @param {string} inviteCode - The invite code (without https://chat.whatsapp.com/)
+     * @returns {Promise<string>} The group JID that was joined
+     * @throws {Error} If client is not connected or join fails
+     */
+    async joinGroupByInviteCode(inviteCode) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            // Strip URL prefix if accidentally included
+            const code = inviteCode.replace('https://chat.whatsapp.com/', '');
+            const response = await this.sock.groupAcceptInvite(code);
+            return response;
+        } catch (error) {
+            console.error('Error joining group by invite code:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Get group info by invite code (without joining)
+     * @param {string} inviteCode - The invite code (without https://chat.whatsapp.com/)
+     * @returns {Promise<object>} The group information
+     * @throws {Error} If client is not connected or fetch fails
+     */
+
+    async getGroupInfoByInviteCode(inviteCode) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            // Strip URL prefix if accidentally included
+            const code = inviteCode.replace('https://chat.whatsapp.com/', '');
+            const response = await this.sock.groupGetInviteInfo(code);
+            return response;
+        } catch (error) {
+            console.error('Error getting group info by invite code:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Get the list of pending join requests for a group
+     * @param {string} groupId - The group JID
+     * @returns {Promise<Array>} Array of pending join requests
+     * @throws {Error} If client is not connected or fetch fails
+     */
+
+    async getGroupJoinRequests(groupId) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            const response = await this.sock.groupRequestParticipantsList(groupId);
+            return response;
+        } catch (error) {
+            console.error('Error getting group join requests:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Approve or reject group join requests
+     * @param {string} groupId - The group JID
+     * @param {Array<string>} participantIds - Array of participant JIDs to approve/reject
+     * @param {string} action - 'approve' or 'reject'
+     * @returns {Promise<object>} The response from the action
+     * @throws {Error} If client is not connected or action fails
+     */
+    async handleGroupJoinRequest(groupId, participantIds, action) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        const validActions = ['approve', 'reject'];
+        if (!validActions.includes(action)) {
+            throw new Error(`Invalid action: ${action}. Must be one of: ${validActions.join(', ')}`);
+        }
+
+        try {
+            const response = await this.sock.groupRequestParticipantsUpdate(groupId, participantIds, action);
+            return response;
+        } catch (error) {
+            console.error(`Error ${action}ing group join request:`, error);
+            throw error;
+        }
+    }
+
+    /**
+     * Toggle ephemeral (disappearing) messages in a group
+     * @param {string} groupId - The group JID
+     * @param {number} ephemeralExpiration - Duration in seconds (0 = off, 86400 = 24h, 604800 = 7d, 7776000 = 90d)
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or toggle fails
+     */
+    async toggleGroupEphemeral(groupId, ephemeralExpiration) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            await this.sock.groupToggleEphemeral(groupId, ephemeralExpiration);
+        } catch (error) {
+            console.error('Error toggling group ephemeral:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Change who can add members to a group
+     * @param {string} groupId - The group JID
+     * @param {string} mode - 'all_member_add' (all members can add) or 'admin_add' (only admins can add)
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or update fails
+     */
+    async changeGroupAddMode(groupId, mode) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        const validModes = ['all_member_add', 'admin_add'];
+        if (!validModes.includes(mode)) {
+            throw new Error(`Invalid mode: ${mode}. Must be one of: ${validModes.join(', ')}`);
+        }
+
+        try {
+            await this.sock.groupMemberAddMode(groupId, mode);
+        } catch (error) {
+            console.error('Error changing group add mode:', error);
+            throw error;
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════
+    // 🔒 PRIVACY METHODS
+    // ═══════════════════════════════════════════════════════════
+
+    /**
+     * Block a user
+     * @param {string} jid - The JID of the user to block
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or block fails
+     */
+    async blockUser(jid) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            await this.sock.updateBlockStatus(jid, 'block');
+        } catch (error) {
+            console.error('Error blocking user:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Unblock a user
+     * @param {string} jid - The JID of the user to unblock
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or unblock fails
+     */
+    async unblockUser(jid) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            await this.sock.updateBlockStatus(jid, 'unblock');
+        } catch (error) {
+            console.error('Error unblocking user:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Get current privacy settings
+     * @param {boolean} [forceGet=true] - Whether to force-fetch the latest settings
+     * @returns {Promise<object>} The privacy settings object
+     * @throws {Error} If client is not connected or fetch fails
+     */
+    async getPrivacySettings(forceGet = true) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            const settings = await this.sock.fetchPrivacySettings(forceGet);
+            return settings;
+        } catch (error) {
+            console.error('Error fetching privacy settings:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Get the list of blocked contacts
+     * @returns {Promise<Array<string>>} Array of blocked JIDs
+     * @throws {Error} If client is not connected or fetch fails
+     */
+    async getBlockList() {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            const blocklist = await this.sock.fetchBlocklist();
+            return blocklist;
+        } catch (error) {
+            console.error('Error fetching block list:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Update last seen privacy setting
+     * @param {string} value - 'all' | 'contacts' | 'contact_blacklist' | 'none'
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or update fails
+     */
+    async updateLastSeenPrivacy(value) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            await this.sock.updateLastSeenPrivacy(value);
+        } catch (error) {
+            console.error('Error updating last seen privacy:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Update online status privacy setting
+     * @param {string} value - 'all' | 'match_last_seen'
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or update fails
+     */
+    async updateOnlinePrivacy(value) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            await this.sock.updateOnlinePrivacy(value);
+        } catch (error) {
+            console.error('Error updating online privacy:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Update profile picture privacy setting
+     * @param {string} value - 'all' | 'contacts' | 'contact_blacklist' | 'none'
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or update fails
+     */
+    async updateProfilePicturePrivacy(value) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            await this.sock.updateProfilePicturePrivacy(value);
+        } catch (error) {
+            console.error('Error updating profile picture privacy:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Update status privacy setting
+     * @param {string} value - 'all' | 'contacts' | 'contact_blacklist' | 'none'
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or update fails
+     */
+    async updateStatusPrivacy(value) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            await this.sock.updateStatusPrivacy(value);
+        } catch (error) {
+            console.error('Error updating status privacy:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Update read receipts privacy setting
+     * @param {string} value - 'all' | 'none'
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or update fails
+     */
+
+    async updateReadReceiptsPrivacy(value) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            await this.sock.updateReadReceiptsPrivacy(value);
+        } catch (error) {
+            console.error('Error updating read receipts privacy:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Update groups add privacy setting (who can add you to groups)
+     * @param {string} value - 'all' | 'contacts' | 'contact_blacklist'
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or update fails
+     */
+
+    async updateGroupsAddPrivacy(value) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+        try {
+            await this.sock.updateGroupsAddPrivacy(value);
+        } catch (error) {
+            console.error('Error updating groups add privacy:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Update default disappearing mode for new chats
+     * @param {number} duration - Duration in seconds (0 = off, 86400 = 24h, 604800 = 7d, 7776000 = 90d)
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or update fails
+     */
+
+    async updateDefaultDisappearingMode(duration) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+        try {
+            await this.sock.updateDefaultDisappearingMode(duration);
+        } catch (error) {
+            console.error('Error updating default disappearing mode:', error);
+            throw error;
+        }
+    }
+
     /**
      * Add EXIF metadata to an existing WebP buffer
      * @param {Buffer} buffer - WebP buffer

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@innovatorssoft/innovators-bot2",
-  "version": "1.2.8",
-  "description": "",
+  "version": "2.0.1",
+  "description": "WhatsApp API",
   "main": "index.js",
   "scripts": {
     "start": "node example.js",
-    "publish-dual": "node publish-dual.js"
+    "publish:all": "node publish-dual.js"
   },
   "keywords": [
     "whatsapp",
@@ -22,16 +22,15 @@
     "client"
   ],
   "author": "Javed Arshad Bhatti",
-  "license": "ISC",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/innovatorssoft/WhatsAppAPI.git"
   },
   "homepage": "https://github.com/innovatorssoft/WhatsAppAPI?tab=readme-ov-file#whatsapp-api",
   "dependencies": {
-    "@innovatorssoft/baileys": "^7.3.5",
+    "@innovatorssoft/baileys": "^7.4.0",
     "figlet": "^1.8.0",
-    "link-preview-js": "^3.0.13",
     "mime": "^3.0.0",
     "mime-types": "^2.1.35",
     "node-cache": "^5.1.2",