innovators-bot2 2.0.0 → 2.0.2

package/index.js

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