innovators-bot2 2.0.1 → 2.0.3

package/README.md

@@ -9,12 +9,14 @@ A powerful WhatsApp client library that provides seamless integration between Ba
 - 💬 Send and receive messages
 - � Message reactions (add/remove emoji reactions)
 - �📸 Media handling (images, videos, documents)
-- 👥 Group management
+- � Mentions support in text and media messages
+- �👥 Group management
 - 💾 Message history and chat management
 - 🔄 Auto-reconnect functionality
 - 📝 Read receipts
 - 🔐 LID (Local Identifier) support for enhanced privacy
 - 🗂️ Signal repository store for LID/PN mapping
+- 🧩 Interactive buttons support for both text and media (URL or local file)
 
 ## Installation
 
@@ -97,10 +99,22 @@ await client.sendMedia('1234567890@s.whatsapp.net', './image.jpg', {
     caption: 'Check out this image!'
 })
 
+// Send an image with mentions
+await client.sendMedia('1234567890@s.whatsapp.net', './image.jpg', {
+    caption: 'Hey @user, check this out!',
+    mentions: ['user@s.whatsapp.net']
+})
+
 // Send a document
 await client.sendDocument('1234567890@s.whatsapp.net', './document.pdf', 
     'Check out this document!'
 )
+
+// Send a document with mentions (caption object is supported)
+await client.sendDocument('1234567890@s.whatsapp.net', './document.pdf', {
+    caption: 'Hey @user, please read this',
+    mentions: ['user@s.whatsapp.net']
+})
 ```
 
 ### 3. Sticker Management
@@ -144,10 +158,20 @@ client.on('message-deleted', async (data) => {
 ```javascript
 // Get all groups
 const groups = await client.getAllGroups()
+groups.forEach(g => console.log(g.subject, g.id, g.notify, g.participants.length))
 
-// Get group metadata (participants, name, description...)
+// Get group metadata (participants, name, description, settings...)
 const metadata = await client.getGroupMetadata(groupId)
-console.log(metadata.id, metadata.subject, metadata.desc)
+console.log(metadata.id, metadata.subject, metadata.desc, metadata.notify)
+console.log('Owner:', metadata.owner, 'Created:', new Date(metadata.creation * 1000))
+console.log('Announce:', metadata.announce, 'Restrict:', metadata.restrict)
+
+// Access participants with roles and notify names
+metadata.participants.forEach(p => {
+    const role = p.admin === 'superadmin' ? 'Super Admin'
+               : p.admin === 'admin' ? 'Admin' : 'Member'
+    console.log(`${p.id} - ${role} - Name: ${p.notify || 'N/A'}`)
+})
 
 // Create a new group
 const newGroup = await client.createGroup('Group Name', ['1234567890@s.whatsapp.net'])
@@ -277,7 +301,7 @@ await client.sendButtons('1234567890@s.whatsapp.net', {
     text: 'Do you like this bot?',
     title: 'Feedback',
     subtitle: 'Let us know!',
-    footer: 'Powered by Baileys',
+    footer: 'Powered by Innovators Soft',
     interactiveButtons: [
         {
             name: 'quick_reply',
@@ -295,6 +319,43 @@ await client.sendButtons('1234567890@s.whatsapp.net', {
         }
     ]
 });
+
+// Send interactive buttons with an image from URL + caption
+await client.sendButtons('1234567890@s.whatsapp.net', {
+    image: { url: 'https://example.com/image.jpg' },
+    caption: 'Body',
+    title: 'Title',
+    subtitle: 'Subtitle',
+    footer: 'Footer',
+    interactiveButtons: [
+        {
+            name: 'quick_reply',
+            buttonParamsJson: JSON.stringify({
+                display_text: 'DisplayText',
+                id: 'ID1'
+            })
+        }
+    ],
+    hasMediaAttachment: false
+});
+
+// Send interactive buttons with a local image file + caption
+await client.sendButtons('1234567890@s.whatsapp.net', {
+    imagePath: './image.jpg',
+    caption: 'Body',
+    title: 'Title',
+    subtitle: 'Subtitle',
+    footer: 'Footer',
+    interactiveButtons: [
+        {
+            name: 'quick_reply',
+            buttonParamsJson: JSON.stringify({
+                display_text: 'DisplayText',
+                id: 'ID1'
+            })
+        }
+    ]
+});
 ```
 
 #### List Messages
@@ -327,11 +388,72 @@ await client.SendList('1234567890@s.whatsapp.net', {
 ### 8. Message History
 
 ```javascript
-// Get chat history
-const messages = await client.loadMessages(chatId, 50)
+### 8. Message Store (History)
+
+The library includes a robust message store to keep track of chat history, even across reloads.
+
+#### Basic Store Operations
+```javascript
+// Get all stored messages for a specific chat
+const messages = client.getStoredMessages('1234567890@s.whatsapp.net');
+
+// Get all stored messages across all chats
+const allMessages = client.getAllStoredMessages();
 
-// Get specific message
-const message = await client.loadMessage(chatId, messageId)
+// Get list of all chat JIDs in the store
+const activeChats = client.getStoredChatIds();
+
+// Get statistics about the message store
+const stats = client.getStoreStats();
+```
+
+#### Message Store Persistence
+
+The message store can be saved to and loaded from a file for consistency across restarts:
+
+```javascript
+// Initialize client with persistence configuration
+const client = new WhatsAppClient({
+    sessionName: 'my-session',
+    messageStoreFilePath: './data/my-session/message-store.json', // Optional custom path
+    autoSaveInterval: 5 * 60 * 1000, // Auto-save every 5 minutes (default)
+    maxMessagesPerChat: 1000, // Maximum messages to keep per chat
+    messageTTL: 24 * 60 * 60 * 1000 // Message time-to-live (24 hours default)
+});
+
+// The store will automatically:
+// - Load from file when connected
+// - Save to file when disconnected
+// - Auto-save periodically (every 5 minutes by default)
+
+// Manual save/load operations
+await client.saveMessageStore(); // Returns {success, path, messageCount, savedAt}
+await client.loadMessageStore(); // Returns {success, messageCount, loadedFrom}
+```
+
+**Features:**
+- 💾 **Auto-save**: Automatically saves the store at regular intervals
+- 🔄 **Auto-load**: Loads the store when connecting
+- 🛡️ **Safe shutdown**: Saves the store before disconnecting
+- 📊 **Change tracking**: Only saves when there are new messages
+- 🗂️ **Custom paths**: Configure where to save the store file
+
+#### Events
+The message store emits events you can listen to:
+- `message-stored`: Emitted when messages are added to the cache.
+- `store-loaded`: Emitted when the store is loaded from file.
+- `store-cleared`: Emitted when the entire store is cleared.
+- `chat-store-cleared`: Emitted when a specific chat's history is cleared.
+
+```javascript
+client.on('message-stored', (messages) => {
+    console.log('Messages cached:', messages.length);
+});
+
+client.on('store-loaded', (info) => {
+    console.log(`Loaded ${info.messageCount} messages from file`);
+});
+```
 ```
 
 ## More Examples and Information
@@ -387,7 +509,7 @@ The library includes example bot commands that you can use:
 - `!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
+- `!groupinfo [jid|code]` - Get full group details (use in-group, by JID, or by invite code) — shows participants, roles, names, and group settings
 - `!joinrequests` - List pending join requests
 - `!approvejoin <number>` - Approve a join request
 - `!rejectjoin <number>` - Reject a join request
@@ -412,6 +534,11 @@ The library includes example bot commands that you can use:
 - `!list` - Display a scrollable list
 - `!logout` - Logout from current session
 
+### 💾 Message Store
+- `!messages` - Get stored messages for current chat
+- `!message <id>` - Get a specific message by ID
+- `!stats` - View store capacity statistics
+
 ### 🛡️ Protection
 - `Anti-Delete` - Automatically tracks and emits events for deleted messages
 
@@ -444,6 +571,24 @@ client.on('disconnected', (error) => {
 })
 ```
 
+### Contact Events
+```javascript
+// When contacts are received from history sync
+client.on('contacts-received', (contacts) => {
+    console.log(`Received ${contacts.length} contacts`);
+})
+
+// When new contacts are added/updated
+client.on('contacts-upsert', (contacts) => {
+    console.log(`New Contacts: ${contacts.length} contacts added/updated`);
+})
+
+// When existing contacts are updated (profile picture changes, etc.)
+client.on('contacts-update', (updates) => {
+    console.log(`Contact Updates: ${updates.length} contacts modified`);
+})
+```
+
 ### Message Events
 ```javascript
 // When a new message is received
@@ -457,7 +602,14 @@ client.on('message', async msg => {
     // Handle different message types
     if (msg.hasMedia) {
         console.log('Message contains media')
-        // Handle media message
+        // Download media (image/video/audio/document)
+        const media = await client.downloadMedia(msg)
+        if (media) {
+            const fs = require('fs')
+            const fileName = `./download-${Date.now()}.${media.extension}`
+            fs.writeFileSync(fileName, media.buffer)
+            console.log('Saved media to:', fileName)
+        }
     }
 })
 ```
@@ -832,6 +984,8 @@ For more detailed information about the LID system implementation, see:
 - [LID_STORE_GUIDE.md](./LID_STORE_GUIDE.md) - Complete implementation guide
 - [Baileys Migration Guide](https://baileys.wiki/docs/migration/to-v7.0.0/) - Official migration documentation
 - [example.js](./example.js) - Working examples with LID handling
+- [Read Baileys Documentation](https://innovatorssoftpk.com/)
+- [Deep Knowlege](https://deepwiki.com/innovatorssoft/Baileys)
 
 ## Contributing
 
@@ -844,3 +998,11 @@ This project is licensed under the MIT License - see the LICENSE file for detail
 ## Credits
 
 Developed by [Innovators Soft](https://facebook.com/innovatorssoft). Based on the [@itsukichan/baileys](https://github.com/itsukichann/baileys) library.
+
+# Special Thanks
+- [@whiskeysockets/baileys](https://github.com/whiskeysockets/Baileys)
+- [@itsukichan](https://github.com/itsukichann)
+- [All Contributors](https://github.com/innovatorssoft/Baileys/)
+- [@ZenboBot](https://discordbot.innovatorssoftpk.com/) - AI Powered Baileys Bot
+# Sponsor Me
+Buy me a coffee - [Innovators Soft](https://facebook.com/innovatorssoft)

package/STORE_PERSISTENCE.md

@@ -0,0 +1,62 @@
+## Message Store Persistence Commands
+
+The following commands have been added to demonstrate the message store persistence functionality:
+
+### !savestore
+Manually saves the current message store to a JSON file.
+- Creates/updates the file at the configured path (default: `{sessionName}/message-store.json`)
+- Returns statistics about the save operation
+
+**Usage:**
+```
+!savestore
+```
+
+**Example Response:**
+```
+✅ Store Saved Successfully
+
+• Messages: 2547
+• Path: auth_info_baileys/message-store.json
+• Saved at: 2/17/2026, 11:15:30 AM
+```
+
+### !loadstore
+Manually loads the message store from the saved JSON file.
+- Clears current in-memory store
+- Loads messages from the file
+- Returns statistics about the load operation
+
+**Usage:**
+```
+!loadstore
+```
+
+**Example Response:**
+```
+✅ Store Loaded Successfully
+
+• Messages: 2547
+• Loaded from: 2026-02-17T06:10:25.123Z
+```
+
+## Automatic Persistence
+
+The message store automatically:
+- **Loads** when the client connects
+- **Saves** when the client disconnects
+- **Auto-saves** every 5 minutes (configurable) if there are changes
+
+## Configuration
+
+Configure persistence in the client initialization:
+
+```javascript
+const client = new WhatsAppClient({
+    sessionName: 'my-session',
+    messageStoreFilePath: './data/my-session/message-store.json', // Optional
+    autoSaveInterval: 5 * 60 * 1000, // 5 minutes (default)
+    maxMessagesPerChat: 1000,
+    messageTTL: 24 * 60 * 60 * 1000
+});
+```

package/example.js

@@ -43,7 +43,12 @@ async function start() {
     const client = new WhatsAppClient({
         sessionName: sessionDir,
         authmethod: authMethod,
-        pairingPhoneNumber: pairingPhoneNumber
+        pairingPhoneNumber: pairingPhoneNumber,
+        // Message store persistence configuration
+        messageStoreFilePath: path.join(sessionDir, 'message-store.json'),
+        autoSaveInterval: 5 * 60 * 1000, // Auto-save every 5 minutes
+        maxMessagesPerChat: 1000, // Keep last 1000 messages per chat
+        messageTTL: 24 * 60 * 60 * 1000 // Messages expire after 24 hours
     });
 
     console.log(`\n🚀 Initializing with ${authMethod} method...`);
@@ -76,12 +81,36 @@ 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!`)
         await client.sendMessage(data.jid, '⚠️ I saw you deleted that message! I have it saved in my memory. 😉', { quoted: data.originalMessage });
     })
+    // Example of listening to the new events
+    client.on('message-stored', (messages) => {
+        //console.log(`${messages.length} messages were just cached in the store.`);
+    });
 
+    client.on('store-loaded', (info) => {
+        console.log(`\n💾 Message store loaded: ${info.messageCount} messages restored from file`);
+    });
+
+    client.on('store-cleared', () => {
+        console.log('Main message store has been purged.');
+    });
     // Handle message reactions
     client.on('message-reaction', async (reaction) => {
         console.log('\n👍 Message Reaction Received!')
@@ -242,29 +271,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 +283,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 +317,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',
@@ -415,7 +398,7 @@ async function start() {
                     `• !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` +
+                    `• !groupinfo [jid|code] - Full group details with participants\n` +
                     `• !joinrequests - List pending join requests\n` +
                     `• !approvejoin <number> - Approve join request\n` +
                     `• !rejectjoin <number> - Reject join request\n` +
@@ -439,7 +422,13 @@ async function start() {
                     `• !buttons - Button template\n` +
                     `• !list - Scrollable list\n\n` +
 
-                    `*🔐 LID/PN/JID Management*\n` +
+                    `*� Message Store*\n` +
+                    `• !messages - Get stored messages for this chat\n` +
+                    `• !allmessages - Get statistics for all stored chats\n` +
+                    `• !message - Get a specific message by ID\n` +
+                    `• !stats - Get store capacity statistics\n\n` +
+
+                    `*�🔐 LID/PN/JID Management*\n` +
                     `• !lid - Get your LID\n` +
                     `• !pn <lid> - Get PN from LID\n` +
                     `• !parse <jid> - Parse JID info\n` +
@@ -467,6 +456,7 @@ async function start() {
                         groups.forEach((group, index) => {
                             groupList += `${index + 1}. *${group.subject}*\n`
                             groupList += `   ID: ${group.id}\n`
+                            if (group.notify) groupList += `   Notify: ${group.notify}\n`
                             groupList += `   Members: ${group.participants.length}\n`
                             if (group.desc) groupList += `   Description: ${group.desc}\n`
                             groupList += '\n'
@@ -481,6 +471,45 @@ async function start() {
                 }
                 break
 
+            case '!groupinfo':
+                try {
+                    // 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>')
+                        break
+                    }
+                    const groupInfo = await client.getGroupMetadata(groupJid)
+                    if (groupInfo) {
+                        let groupList = `*Group Info:*\n\n` +
+                            `ID: ${groupInfo.id}\n` +
+                            `Notify: ${groupInfo.notify || 'N/A'}\n` +
+                            `Subject: ${groupInfo.subject}\n` +
+                            `Owner: ${groupInfo.owner || 'N/A'}\n` +
+                            `Created: ${new Date(groupInfo.creation * 1000).toLocaleString()}\n` +
+                            `Members: ${groupInfo.participants.length}\n` +
+                            `Description: ${groupInfo.desc || 'N/A'}\n\n` +
+                            `*👥 Participants:*\n\n`
+
+                        groupInfo.participants.forEach((p, i) => {
+                            const role = p.admin === 'superadmin' ? '👑 Super Admin'
+                                : p.admin === 'admin' ? '🛡️ Admin'
+                                    : '👤 Member'
+                            groupList += `${i + 1}. ${p.id}\n`
+                            groupList += `   Role: ${role}\n`
+                            if (p.notify) groupList += `   Name: ${p.notify}\n`
+                            groupList += '\n'
+                        })
+
+                        await client.sendMessage(msg.from, groupList)
+                    } else {
+                        await client.sendMessage(msg.from, 'Group not found')
+                    }
+                } catch (error) {
+                    console.error('Error fetching group info:', error)
+                    await client.sendMessage(msg.from, 'Failed to fetch group info')
+                }
+                break
             case '!logout':
                 // Ask for confirmation before logging out
                 await client.sendButtons(msg.from, {
@@ -864,22 +893,65 @@ async function start() {
 
             case '!groupinfo':
                 try {
-                    if (!args) {
-                        await client.sendMessage(msg.from, '❌ Please provide an invite code.\nUsage: !groupinfo AbCdEfGhIjK');
-                        break;
+                    const input = args.trim()
+                    let groupInfoResult
+
+                    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')
+                            break
+                        }
+                        groupInfoResult = await client.getGroupMetadata(msg.raw.key.remoteJid)
+                    } else if (input.includes('@g.us')) {
+                        // Argument is a group JID
+                        groupInfoResult = await client.getGroupMetadata(input)
+                    } else {
+                        // Argument is an invite code (or full link)
+                        groupInfoResult = await client.getGroupInfoByInviteCode(input)
                     }
-                    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);
+
+                    if (!groupInfoResult) {
+                        await client.sendMessage(msg.from, '❌ Group not found.')
+                        break
+                    }
+
+                    // Build group info header
+                    let infoText = `*📋 Group Info*\n\n`
+                    infoText += `*Name:* ${groupInfoResult.subject || 'N/A'}\n`
+                    infoText += `*ID:* ${groupInfoResult.id || 'N/A'}\n`
+                    if (groupInfoResult.notify) infoText += `*Notify:* ${groupInfoResult.notify}\n`
+                    infoText += `*Owner:* ${groupInfoResult.owner || 'N/A'}\n`
+                    infoText += `*Created:* ${groupInfoResult.creation ? new Date(groupInfoResult.creation * 1000).toLocaleString() : 'N/A'}\n`
+                    infoText += `*Size:* ${groupInfoResult.size || groupInfoResult.participants?.length || 'N/A'}\n`
+                    infoText += `*Description:* ${groupInfoResult.desc || 'No description'}\n`
+                    if (groupInfoResult.announce !== undefined) infoText += `*Announce:* ${groupInfoResult.announce ? 'Yes (admins only)' : 'No'}\n`
+                    if (groupInfoResult.restrict !== undefined) infoText += `*Restricted:* ${groupInfoResult.restrict ? 'Yes (admins only edit info)' : 'No'}\n`
+                    if (groupInfoResult.ephemeralDuration) infoText += `*Disappearing:* ${groupInfoResult.ephemeralDuration}s\n`
+                    if (groupInfoResult.memberAddMode !== undefined) infoText += `*Member Add:* ${groupInfoResult.memberAddMode ? 'All members' : 'Admins only'}\n`
+                    if (groupInfoResult.isCommunity) infoText += `*Community:* Yes\n`
+                    if (groupInfoResult.linkedParent) infoText += `*Linked Parent:* ${groupInfoResult.linkedParent}\n`
+
+                    // Build participants list if available
+                    if (groupInfoResult.participants && groupInfoResult.participants.length > 0) {
+                        infoText += `\n*👥 Participants (${groupInfoResult.participants.length}):*\n\n`
+                        groupInfoResult.participants.forEach((p, i) => {
+                            const role = p.admin === 'superadmin' ? '👑 Super Admin'
+                                : p.admin === 'admin' ? '🛡️ Admin'
+                                    : '👤 Member'
+                            infoText += `${i + 1}. ${p.id}\n`
+                            infoText += `   Role: ${role}\n`
+                            if (p.notify) infoText += `   Name: ${p.notify}\n`
+                            if (p.lid) infoText += `   LID: ${p.lid}\n`
+                            if (p.phoneNumber) infoText += `   Phone: ${p.phoneNumber}\n`
+                            infoText += '\n'
+                        })
+                    }
+
+                    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}`);
+                    console.error('Error getting group info:', error)
+                    await client.sendMessage(msg.from, `❌ Failed to get group info: ${error.message}`)
                 }
                 break;
 
@@ -1188,6 +1260,72 @@ async function start() {
                     await client.sendMessage(msg.from, `❌ Failed to update: ${error.message}`);
                 }
                 break;
+
+            case '!messages':
+                const history = client.getStoredMessages(msg.from);
+                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);
+                break;
+
+            case '!message':
+                if (!args) {
+                    await client.sendMessage(msg.from, "❌ Please provide a message ID.");
+                    break;
+                }
+                const storedMsg = client.getStoredMessage({ remoteJid: msg.from, 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)}`);
+                } else {
+                    await client.sendMessage(msg.from, "❌ 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}`);
+                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')}`);
+                break;
+
+            case '!savestore':
+                await client.sendMessage(msg.from, '💾 Saving message store to file...');
+                const saveResult = await client.saveMessageStore();
+                if (saveResult.success) {
+                    await client.sendMessage(msg.from,
+                        `✅ *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}`);
+                }
+                break;
+
+            case '!loadstore':
+                await client.sendMessage(msg.from, '📂 Loading message store from file...');
+                const loadResult = await client.loadMessageStore();
+                if (loadResult.success) {
+                    await client.sendMessage(msg.from,
+                        `✅ *Store Loaded Successfully*\n\n` +
+                        `• Messages: ${loadResult.messageCount}\n` +
+                        `• Loaded from: ${loadResult.loadedFrom}`
+                    );
+                } else {
+                    await client.sendMessage(msg.from,
+                        `⚠️ Could not load store\n` +
+                        `Reason: ${loadResult.reason || loadResult.error}`
+                    );
+                }
+                break;
         }
     })
 

package/index.js

@@ -38,6 +38,7 @@ class Group {
     constructor(client, groupData) {
         this.client = client
         this.id = groupData.id
+        this.notify = groupData.notify
         this.subject = groupData.subject
         this.creation = groupData.creation
         this.owner = groupData.owner
@@ -61,6 +62,16 @@ class WhatsAppClient extends EventEmitter {
             maxMessagesPerChat: config.maxMessagesPerChat || 1000,
             ttl: config.messageTTL || 24 * 60 * 60 * 1000
         });
+        // Initialize contacts cache
+        this.contactsCache = new NodeCache({ stdTTL: 0, checkperiod: 20 }); // No TTL, manual cleanup on logout
+
+        // Message store persistence configuration
+        this.messageStoreFilePath = config.messageStoreFilePath || path.join(this.sessionName, 'message-store.json');
+        this.autoSaveInterval = config.autoSaveInterval || 5 * 60 * 1000; // Default: 5 minutes
+        this._autoSaveTimer = null;
+        this._storeChangeCount = 0;
+        this._pairingCodeTimer = null;
+        this._lastStoreSave = null;
     }
 
     /**
@@ -115,7 +126,7 @@ class WhatsAppClient extends EventEmitter {
             }
 
             const browserConfig = this.authmethod === 'pairing'
-                ? Browsers.windows('chrome')
+                ? Browsers.iOS('chrome')
                 : ["Innovators Soft", "chrome", "1000.26100.275.0"];
 
             const { version: baileysVersion, isLatest: baileysIsLatest } = await fetchLatestBaileysVersion();
@@ -132,6 +143,7 @@ class WhatsAppClient extends EventEmitter {
                 logger,
                 markOnlineOnConnect: false,
                 syncFullHistory: true,
+                getMessage: async (key) => (this.messageStore.getOriginalMessage(key))?.message,
                 generateHighQualityLinkPreview: true,
                 linkPreviewImageThumbnailWidth: 192,
                 emitOwnEvents: true,
@@ -150,15 +162,16 @@ class WhatsAppClient extends EventEmitter {
                         console.error(`Error fetching metadata for group ${jid}:`, error);
                         return null;
                     }
-                }
+                },
             });
 
             this.store = this.sock.signalRepository.lidMapping;
 
-
-
-            this.sock.ev.on('connection.update', async (update) => {
-                const { connection, lastDisconnect, qr } = update;
+            this.sock.ev.on('connection.update', async ({ connection, lastDisconnect, qr }) => {
+                if (connection === 'close' && this._pairingCodeTimer) {
+                    clearTimeout(this._pairingCodeTimer);
+                    this._pairingCodeTimer = null;
+                }
 
                 if (qr && this.authmethod === 'qr') {
                     this.emit('qr', qr);
@@ -167,15 +180,21 @@ class WhatsAppClient extends EventEmitter {
                     if (this._connectionState !== 'connected') {
                         const user = getCurrentSenderInfo(this.sock.authState)
                         if (user) {
+                            this.isConnected = true;
                             const userInfo = {
                                 name: user.pushName || 'Unknown',
                                 phone: user.phoneNumber,
                                 platform: user.platform || 'Unknown',
-                                isOnline: true
+                                isOnline: true,
                             };
-                            this.isConnected = true;
                             this._connectionState = 'connected';
                             this.emit('connected', userInfo);
+
+                            // Load message store from file
+                            await this.loadMessageStore();
+
+                            // Start auto-save
+                            this._startAutoSave();
                         }
                     }
                 }
@@ -186,6 +205,13 @@ class WhatsAppClient extends EventEmitter {
                     if (this._connectionState !== 'disconnected') {
                         this.isConnected = false;
                         this._connectionState = 'disconnected';
+
+                        // Save message store before disconnecting
+                        await this.saveMessageStore();
+
+                        // Stop auto-save
+                        this._stopAutoSave();
+
                         this.emit('disconnected', lastDisconnect?.error);
                     }
 
@@ -203,9 +229,20 @@ class WhatsAppClient extends EventEmitter {
                     if (phoneNumber) {
                         try {
                             // Wait a bit for the connection to initialize properly
-                            setTimeout(async () => {
+                            if (this._pairingCodeTimer) {
+                                clearTimeout(this._pairingCodeTimer);
+                            }
+
+                            this._pairingCodeTimer = setTimeout(async () => {
                                 const customeCode = "INOVATOR";
                                 try {
+                                    if (!this.sock || this._connectionState === 'disconnected') {
+                                        const err = new Error('Socket is not available to request pairing code');
+                                        console.error('Error requesting pairing code:', err);
+                                        this.emit('error', err);
+                                        return;
+                                    }
+
                                     const code = await this.sock.requestPairingCode(phoneNumber, customeCode);
                                     if (code) {
                                         // Emit pairing code event so clients can handle it
@@ -216,6 +253,8 @@ class WhatsAppClient extends EventEmitter {
                                 } catch (error) {
                                     console.error('Error requesting pairing code:', error);
                                     this.emit('error', error);
+                                } finally {
+                                    this._pairingCodeTimer = null;
                                 }
                             }, 2000); // Wait 2 seconds before requesting pairing code
                         } catch (error) {
@@ -234,7 +273,17 @@ class WhatsAppClient extends EventEmitter {
 
             this.sock.ev.on('messages.upsert', async (update) => {
                 // 📝 Store message for the Anti-Delete system
-                createMessageStoreHandler(this.messageStore)(update);
+                const storeHandler = createMessageStoreHandler(this.messageStore);
+                storeHandler(update);
+
+                // 📢 Emit event that messages were stored
+                this.emit('message-stored', update.messages);
+
+                // Increment change counter for auto-save
+                this._incrementStoreChangeCount();
+
+                // Save message store to file immediately
+                await this.saveMessageStore();
 
                 try {
                     if (update.type !== 'notify' || !update.messages?.length) return;
@@ -387,6 +436,8 @@ class WhatsAppClient extends EventEmitter {
 
             // 👍 Handle message reactions
             this.sock.ev.on('messages.reaction', async (reactions) => {
+
+
                 try {
                     for (const reaction of reactions) {
                         // Get the chat JID, preferring PN over LID
@@ -509,6 +560,34 @@ class WhatsAppClient extends EventEmitter {
                 }
             });
 
+            // Handle contacts from history sync
+            this.sock.ev.on('messaging-history.set', ({ contacts: newContacts }) => {
+                if (newContacts && newContacts.length > 0) {
+                    for (const contact of newContacts) {
+                        this.contactsCache.set(contact.id, contact);
+                    }
+                    this.emit('contacts-received', newContacts);
+
+                }
+            });
+
+            // Handle contacts upsert (new contacts added)
+            this.sock.ev.on('contacts.upsert', (newContacts) => {
+                for (const contact of newContacts) {
+                    this.contactsCache.set(contact.id, contact);
+                }
+                this.emit('contacts-upsert', newContacts);
+            });
+
+            // Handle contacts update (profile picture changes, etc.)
+            this.sock.ev.on('contacts.update', (updates) => {
+                for (const update of updates) {
+                    const existing = this.contactsCache.get(update.id) || {};
+                    this.contactsCache.set(update.id, { ...existing, ...update });
+                }
+                this.emit('contacts-update', updates);
+            });
+
         } catch (error) {
             console.error('Error in connect:', error);
             this.emit('error', error);
@@ -654,6 +733,10 @@ class WhatsAppClient extends EventEmitter {
                     throw new Error('Unsupported file type: ' + fileExtension);
             }
 
+            if (options.mentions) {
+                mediaMessage.mentions = options.mentions;
+            }
+
             return await this.sock.sendMessage(chatId, mediaMessage, { ai: true });
         } catch (error) {
             console.error('Error sending media:', error);
@@ -684,11 +767,20 @@ class WhatsAppClient extends EventEmitter {
             const fileName = path.basename(filePath);
             const mimeType = mime.getType(filePath);
 
-            return await this.sock.sendMessage(chatId, {
+            const messageContent = {
                 document: fileBuffer,
                 caption: caption,
                 mimetype: mimeType,
                 fileName: fileName,
+            };
+
+            if (typeof caption === 'object' && caption !== null) {
+                if (caption.caption) messageContent.caption = caption.caption;
+                if (caption.mentions) messageContent.mentions = caption.mentions;
+            }
+
+            return await this.sock.sendMessage(chatId, {
+                ...messageContent,
             }, { ai: true });
         } catch (error) {
             console.error('Error sending document:', error);
@@ -719,8 +811,16 @@ class WhatsAppClient extends EventEmitter {
         const {
             text,
             imagePath,
+            image,
+            video,
+            document,
+            location,
+            product,
+            mimetype,
+            jpegThumbnail,
             caption,
             title,
+            subtitle,
             footer,
             interactiveButtons = [],
             hasMediaAttachment = false,
@@ -729,24 +829,40 @@ class WhatsAppClient extends EventEmitter {
         let messageContent = {};
 
         try {
+            const base = {
+                title: title,
+                subtitle: subtitle,
+                footer: footer,
+                interactiveButtons: interactiveButtons,
+                hasMediaAttachment: hasMediaAttachment,
+            };
+
             if (imagePath) {
-                // Handle message with image
+                // Handle message with local image path
                 const imageBuffer = fs.readFileSync(imagePath);
                 messageContent = {
+                    ...base,
                     image: imageBuffer,
                     caption: caption,
-                    title: title,
-                    footer: footer,
-                    interactiveButtons: interactiveButtons,
-                    hasMediaAttachment: hasMediaAttachment,
+                };
+            } else if (image || video || document || location || product) {
+                // Pass-through media objects (e.g. { image: { url } })
+                messageContent = {
+                    ...base,
+                    ...(image ? { image } : {}),
+                    ...(video ? { video } : {}),
+                    ...(document ? { document } : {}),
+                    ...(location ? { location } : {}),
+                    ...(product ? { product } : {}),
+                    ...(mimetype ? { mimetype } : {}),
+                    ...(jpegThumbnail ? { jpegThumbnail } : {}),
+                    caption: caption,
                 };
             } else {
                 // Handle text-only message
                 messageContent = {
+                    ...base,
                     text: text,
-                    title: title,
-                    footer: footer,
-                    interactiveButtons: interactiveButtons,
                 };
             }
 
@@ -1183,6 +1299,12 @@ class WhatsAppClient extends EventEmitter {
                 this.sock = null;
             }
 
+            // Clear store interval
+            if (this._storeInterval) {
+                clearInterval(this._storeInterval);
+                this._storeInterval = null;
+            }
+
             // Add a small delay before reconnecting
             await new Promise(resolve => setTimeout(resolve, 1000));
 
@@ -1332,6 +1454,7 @@ class WhatsAppClient extends EventEmitter {
 
             // Update connection state and emit event
             this.isConnected = false;
+
             this.emit('logout', 'Logged out successfully');
 
             return true;
@@ -1343,11 +1466,11 @@ class WhatsAppClient extends EventEmitter {
     }
 
     /**
-     * Download media from a message
-     * @param {object} message - The message object containing media (must have raw property)
-     * @returns {Promise<object|null>} Object with buffer, mimetype, and extension, or null if no media
-     * @throws {Error} If client is not connected or download fails
-     */
+      * Download media from a message
+      * @param {object} message - The message object containing media (must have raw property)
+      * @returns {Promise<object|null>} Object with buffer, mimetype, and extension, or null if no media
+      * @throws {Error} If client is not connected or download fails
+      */
     async downloadMedia(message) {
         if (!this.isConnected) {
             throw new Error('Client is not connected');
@@ -1461,6 +1584,254 @@ class WhatsAppClient extends EventEmitter {
         }
     }
 
+    /**
+     * Get all stored messages for a specific chat
+     * @param {string} chatId - The JID of the chat
+     * @returns {Array} Array of stored messages (WebMessageInfo)
+     */
+    getStoredMessages(chatId) {
+        return this.messageStore.getChatMessages(chatId);
+    }
+
+    /**
+     * Get a specific stored message by its key
+     * @param {object} key - The message key { remoteJid, id, fromMe }
+     * @returns {object|undefined} The stored message (WebMessageInfo)
+     */
+    getStoredMessage(key) {
+        return this.messageStore.getOriginalMessage(key);
+    }
+
+    /**
+     * Get statistics about the message store
+     * @returns {object} Store statistics
+     */
+    getStoreStats() {
+        return this.messageStore.getStats();
+    }
+
+    /**
+     * Get all stored messages from all chats
+     * @returns {Array} Array of all stored messages
+     */
+    getAllStoredMessages() {
+        return this.messageStore.getChatIds().flatMap(chatId => this.messageStore.getChatMessages(chatId));
+    }
+
+    /**
+     * Get IDs of all chats that have stored messages
+     * @returns {Array<string>} Array of chat JIDs
+     */
+    getStoredChatIds() {
+        return this.messageStore.getChatIds();
+    }
+
+    /**
+     * Clear the entire message store
+     */
+    clearMessageStore() {
+        this.messageStore.clear();
+        this.emit('store-cleared');
+    }
+
+    /**
+     * Clear stored messages for a specific chat
+     * @param {string} chatId - The JID of the chat to clear
+     */
+    clearChatStore(chatId) {
+        this.messageStore.clearChat(chatId);
+        this.emit('chat-store-cleared', chatId);
+    }
+
+    /**
+     * Save the message store to a JSON file
+     * @returns {Promise<{success: boolean, path: string, messageCount: number}>}
+     */
+    async saveMessageStore() {
+        try {
+            const rawAllMessages = this.messageStore.getAllMessages();
+            const stats = this.messageStore.getStats();
+
+            let allMessages = [];
+            if (Array.isArray(rawAllMessages)) {
+                allMessages = rawAllMessages;
+            } else if (rawAllMessages && typeof rawAllMessages[Symbol.iterator] === 'function') {
+                allMessages = Array.from(rawAllMessages);
+            } else if (rawAllMessages && typeof rawAllMessages === 'object') {
+                allMessages = Object.values(rawAllMessages);
+            } else {
+                try {
+                    allMessages = this.messageStore.getChatIds().flatMap(chatId => this.messageStore.getChatMessages(chatId));
+                } catch {
+                    allMessages = [];
+                }
+            }
+
+            // Serialize the store data
+            const storeData = {
+                version: '1.0.0',
+                savedAt: new Date().toISOString(),
+                sessionName: this.sessionName,
+                stats: stats,
+                messages: []
+            };
+
+            // Convert Map structure to serializable array format
+            for (const msg of allMessages) {
+                try {
+                    storeData.messages.push({
+                        key: msg.key,
+                        message: msg.message,
+                        messageTimestamp: msg.messageTimestamp,
+                        pushName: msg.pushName,
+                        broadcast: msg.broadcast,
+                        isDeleted: msg.isDeleted
+                    });
+                } catch (err) {
+                    console.error('Error serializing message:', err);
+                }
+            }
+
+            // Ensure directory exists
+            const dir = path.dirname(this.messageStoreFilePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+
+            // Write to file
+            fs.writeFileSync(
+                this.messageStoreFilePath,
+                JSON.stringify(storeData, null, 2),
+                'utf8'
+            );
+
+            this._lastStoreSave = new Date();
+            this._storeChangeCount = 0;
+
+            // console.log(`[MessageStore] Saved ${storeData.messages.length} messages to ${this.messageStoreFilePath}`);
+
+            return {
+                success: true,
+                path: this.messageStoreFilePath,
+                messageCount: storeData.messages.length,
+                savedAt: this._lastStoreSave
+            };
+        } catch (error) {
+            console.error('[MessageStore] Error saving store:', error);
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+
+    /**
+     * Load the message store from a JSON file
+     * @returns {Promise<{success: boolean, messageCount: number}>}
+     */
+    async loadMessageStore() {
+        try {
+            if (!fs.existsSync(this.messageStoreFilePath)) {
+                // console.log('[MessageStore] No saved store file found');
+                return { success: false, reason: 'file_not_found' };
+            }
+
+            const fileContent = fs.readFileSync(this.messageStoreFilePath, 'utf8');
+            const storeData = JSON.parse(fileContent);
+
+            // Validate data structure
+            if (!storeData.messages || !Array.isArray(storeData.messages)) {
+                throw new Error('Invalid store file format');
+            }
+
+            // Clear existing store
+            this.messageStore.clear();
+
+            // Load messages into the store
+            let loadedCount = 0;
+            for (const msgData of storeData.messages) {
+                try {
+                    // Use the message store's internal handler to properly store messages
+                    const storeHandler = createMessageStoreHandler(this.messageStore);
+                    storeHandler({
+                        messages: [{
+                            key: msgData.key,
+                            message: msgData.message,
+                            messageTimestamp: msgData.messageTimestamp,
+                            pushName: msgData.pushName,
+                            broadcast: msgData.broadcast
+                        }],
+                        type: 'append'
+                    });
+                    loadedCount++;
+                } catch (err) {
+                    console.error('[MessageStore] Error loading message:', err);
+                }
+            }
+
+            this._lastStoreSave = new Date(storeData.savedAt);
+            this._storeChangeCount = 0;
+
+            // console.log(`[MessageStore] Loaded ${loadedCount}/${storeData.messages.length} messages from ${this.messageStoreFilePath}`);
+
+            this.emit('store-loaded', { messageCount: loadedCount });
+
+            return {
+                success: true,
+                messageCount: loadedCount,
+                loadedFrom: storeData.savedAt
+            };
+        } catch (error) {
+            console.error('[MessageStore] Error loading store:', error);
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+
+    /**
+     * Start auto-save timer
+     * @private
+     */
+    _startAutoSave() {
+        if (this._autoSaveTimer) {
+            clearInterval(this._autoSaveTimer);
+        }
+
+        if (this.autoSaveInterval > 0) {
+            this._autoSaveTimer = setInterval(async () => {
+                // Only save if there have been changes
+                if (this._storeChangeCount > 0) {
+                    // console.log(`[MessageStore] Auto-saving (${this._storeChangeCount} changes since last save)`);
+                    await this.saveMessageStore();
+                }
+            }, this.autoSaveInterval);
+
+            // console.log(`[MessageStore] Auto-save enabled (interval: ${this.autoSaveInterval}ms)`);
+        }
+    }
+
+    /**
+     * Stop auto-save timer
+     * @private
+     */
+    _stopAutoSave() {
+        if (this._autoSaveTimer) {
+            clearInterval(this._autoSaveTimer);
+            this._autoSaveTimer = null;
+            // console.log('[MessageStore] Auto-save disabled');
+        }
+    }
+
+    /**
+     * Increment the store change counter (called when messages are added)
+     * @private
+     */
+    _incrementStoreChangeCount() {
+        this._storeChangeCount++;
+    }
+
     // ═══════════════════════════════════════════════════════════
     // 📁 GROUP MANAGEMENT METHODS
     // ═══════════════════════════════════════════════════════════

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "innovators-bot2",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "WhatsApp API",
   "main": "index.js",
   "scripts": {
     "start": "node example.js",
+    "dev": "node --watch example.js",
     "publish:all": "node publish-dual.js"
   },
   "keywords": [
@@ -29,7 +30,7 @@
   },
   "homepage": "https://github.com/innovatorssoft/WhatsAppAPI?tab=readme-ov-file#whatsapp-api",
   "dependencies": {
-    "@innovatorssoft/baileys": "^7.4.0",
+    "@innovatorssoft/baileys": "latest",
     "figlet": "^1.8.0",
     "mime": "^3.0.0",
     "mime-types": "^2.1.35",
@@ -38,4 +39,4 @@
     "qrcode-terminal": "^0.12.0",
     "wa-sticker-formatter": "^4.4.4"
   }
-}
+}