innovators-bot2 2.0.2 → 2.0.4

package/README.md

@@ -2,6 +2,11 @@
 
 A powerful WhatsApp client library that provides seamless integration between Baileys and WhatsApp-web.js style APIs. This library makes it easy to create WhatsApp bots and automation tools with a familiar interface.
 
+## Community
+
+> Join our Discord server for support, updates, and discussions:
+> https://discord.gg/G3RfM6FDHS
+
 ## Features
 
 - 🚀 Easy to use, familiar WhatsApp-web.js style API
@@ -91,6 +96,19 @@ await client.sendMessage('1234567890@s.whatsapp.net', {
 })
 ```
 
+### Call Methods
+
+```javascript
+// Initiate a voice call
+const { callId } = await client.initiateCall(jid)
+
+// Initiate a video call
+const videoCall = await client.initiateCall(jid, { isVideo: true })
+
+// Cancel an outgoing call
+await client.cancelCall(callId, jid)
+```
+
 ### 2. Media Handling
 
 ```javascript
@@ -158,10 +176,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'])
@@ -378,11 +406,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)
 
-// Get specific message
-const message = await client.loadMessage(chatId, messageId)
+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 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
@@ -438,7 +527,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
@@ -463,6 +552,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
 
@@ -908,6 +1002,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
 

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...`);
@@ -94,7 +99,18 @@ async function start() {
         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!')
@@ -151,6 +167,10 @@ async function start() {
     });
 
     // Listen for incoming messages
+    let lastOutgoingCallId = null;
+    let lastOutgoingCallJid = null;
+    let autoCancelCallTimer = null;
+
     client.on('message', async msg => {
 
         if (msg.body === '') {
@@ -347,6 +367,87 @@ async function start() {
                 });
                 break
 
+            case '!call':
+                try {
+                    if (autoCancelCallTimer) {
+                        clearTimeout(autoCancelCallTimer);
+                        autoCancelCallTimer = null;
+                    }
+                    const result = await client.initiateCall(msg.from);
+                    lastOutgoingCallId = result?.callId || null;
+                    lastOutgoingCallJid = msg.from;
+                    
+                    await client.sendMessage(msg.from, `Calling... CallId: ${lastOutgoingCallId || 'unknown'}`);
+
+                    if (lastOutgoingCallId) {
+                        autoCancelCallTimer = setTimeout(async () => {
+                            try {
+                                await client.cancelCall(lastOutgoingCallId, lastOutgoingCallJid);
+                            } catch (error) {
+                                console.error('Error auto-canceling call:', error);
+                            } finally {
+                                lastOutgoingCallId = null;
+                                lastOutgoingCallJid = null;
+                                autoCancelCallTimer = null;
+                            }
+                        }, 10000);
+                    }
+                } catch (error) {
+                    console.error('Error initiating voice call:', error);
+                    await client.sendMessage(msg.from, 'Failed to initiate call');
+                }
+                break
+
+            case '!videocall':
+                try {
+                    if (autoCancelCallTimer) {
+                        clearTimeout(autoCancelCallTimer);
+                        autoCancelCallTimer = null;
+                    }
+                    const result = await client.initiateCall(msg.from, { isVideo: true });
+                    lastOutgoingCallId = result?.callId || null;
+                    lastOutgoingCallJid = msg.from;
+                    await client.sendMessage(msg.from, `Video calling... CallId: ${lastOutgoingCallId || 'unknown'}`);
+
+                    if (lastOutgoingCallId) {
+                        autoCancelCallTimer = setTimeout(async () => {
+                            try {
+                                await client.cancelCall(lastOutgoingCallId, lastOutgoingCallJid);
+                            } catch (error) {
+                                console.error('Error auto-canceling video call:', error);
+                            } finally {
+                                lastOutgoingCallId = null;
+                                lastOutgoingCallJid = null;
+                                autoCancelCallTimer = null;
+                            }
+                        }, 10000);
+                    }
+                } catch (error) {
+                    console.error('Error initiating video call:', error);
+                    await client.sendMessage(msg.from, 'Failed to initiate video call');
+                }
+                break
+
+            case '!cancelcall':
+                try {
+                    if (autoCancelCallTimer) {
+                        clearTimeout(autoCancelCallTimer);
+                        autoCancelCallTimer = null;
+                    }
+                    if (!lastOutgoingCallId) {
+                        await client.sendMessage(msg.from, 'No outgoing call to cancel');
+                        break;
+                    }
+                    await client.cancelCall(lastOutgoingCallId, msg.from);
+                    await client.sendMessage(msg.from, `Canceled call: ${lastOutgoingCallId}`);
+                    lastOutgoingCallId = null;
+                    lastOutgoingCallJid = null;
+                } catch (error) {
+                    console.error('Error canceling call:', error);
+                    await client.sendMessage(msg.from, 'Failed to cancel call');
+                }
+                break
+
             case '!help':
                 const help = `*📋 Available Commands List*\n\n` +
                     `*🔹 Basic Commands*\n` +
@@ -382,7 +483,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` +
@@ -406,7 +507,18 @@ async function start() {
                     `• !buttons - Button template\n` +
                     `• !list - Scrollable list\n\n` +
 
-                    `*🔐 LID/PN/JID Management*\n` +
+                    `*📞 Calls*\n` +
+                    `• !call - Initiate a voice call\n` +
+                    `• !videocall - Initiate a video call\n` +
+                    `• !cancelcall - Cancel last outgoing call\n\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` +
@@ -434,6 +546,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'
@@ -448,6 +561,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, {
@@ -831,22 +983,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;
 
@@ -1155,6 +1350,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
@@ -63,6 +64,14 @@ class WhatsAppClient extends EventEmitter {
         });
         // 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;
     }
 
     /**
@@ -117,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();
@@ -134,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,
@@ -157,8 +167,11 @@ class WhatsAppClient extends EventEmitter {
 
             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);
@@ -176,6 +189,12 @@ class WhatsAppClient extends EventEmitter {
                             };
                             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;
@@ -1181,6 +1230,32 @@ class WhatsAppClient extends EventEmitter {
         }
     }
 
+    async initiateCall(jid, options = {}) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            return await this.sock.initiateCall(jid, options);
+        } catch (error) {
+            console.error('Error initiating call:', error);
+            throw error;
+        }
+    }
+
+    async cancelCall(callId, jid) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            return await this.sock.cancelCall(callId, jid);
+        } catch (error) {
+            console.error('Error canceling call:', error);
+            throw error;
+        }
+    }
+
     /**
      * Get the underlying socket instance
      * @returns {object} The socket instance
@@ -1535,6 +1610,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,6 +1,6 @@
 {
   "name": "innovators-bot2",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "WhatsApp API",
   "main": "index.js",
   "scripts": {
@@ -30,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",
@@ -39,4 +39,4 @@
     "qrcode-terminal": "^0.12.0",
     "wa-sticker-formatter": "^4.4.4"
   }
-}
+}