innovators-bot2 2.0.4 → 2.0.6

package/index.js

@@ -14,7 +14,17 @@ const {
     // Anti-Delete
     MessageStore,
     createMessageStoreHandler,
-    createAntiDeleteHandler
+    createAntiDeleteHandler,
+    createTypingIndicator,
+    generateInteractiveButtonMessage,
+    generateInteractiveListMessage,
+    generateCombinedButtons,
+    generateCopyCodeButton,
+    generateUrlButtonMessage,
+    generateQuickReplyButtons,
+    StatusHelper,
+    STATUS_BACKGROUNDS,
+    STATUS_FONTS,
 } = require('@innovatorssoft/baileys');
 
 const { Sticker, StickerTypes } = require('wa-sticker-formatter');
@@ -117,18 +127,43 @@ class WhatsAppClient extends EventEmitter {
         return jid.replace(/:\d+@/, '@');
     }
 
+    /**
+     * Internal helper to handle mentions and the "mention all" flag
+     * @param {string[]} mentions - Array of JIDs or keywords like 'all'/'@all'
+     * @param {boolean} mentionAll - Explicit mentionAll flag
+     * @returns {object} Object containing processed mentions and mentionAll flag
+     * @private
+     */
+    _handleMentions(mentions, mentionAll) {
+        let processedMentions = mentions;
+        let finalMentionAll = mentionAll;
+
+        if (mentions && Array.isArray(mentions)) {
+            processedMentions = mentions
+                .filter(jid => jid !== 'all' && jid !== '@all')
+                .map(jid => this._normalizeJid(jid));
+            if (mentions.includes('all') || mentions.includes('@all')) {
+                finalMentionAll = true;
+            }
+        }
+
+        return {
+            mentions: processedMentions,
+            mentionAll: finalMentionAll
+        };
+    }
+
     async connect() {
         try {
+            if (this._connectionState === 'connecting' && this.sock) {
+                return; // Prevent concurrent connection attempts
+            }
 
             if (this._connectionState !== 'connecting') {
                 this._connectionState = 'connecting';
                 this.emit('connecting', 'Connecting to WhatsApp...');
             }
 
-            const browserConfig = this.authmethod === 'pairing'
-                ? Browsers.iOS('chrome')
-                : ["Innovators Soft", "chrome", "1000.26100.275.0"];
-
             const { version: baileysVersion, isLatest: baileysIsLatest } = await fetchLatestBaileysVersion();
             const { version: waWebVersion, isLatest: waWebIsLatest } = await fetchLatestWaWebVersion();
 
@@ -142,13 +177,13 @@ class WhatsAppClient extends EventEmitter {
                 auth: state,
                 logger,
                 markOnlineOnConnect: false,
-                syncFullHistory: true,
+                syncFullHistory: false,
                 getMessage: async (key) => (this.messageStore.getOriginalMessage(key))?.message,
                 generateHighQualityLinkPreview: true,
                 linkPreviewImageThumbnailWidth: 192,
                 emitOwnEvents: true,
-                browser: browserConfig,
-                version: waWebVersion,
+                browser: Browsers.android('Innovators Soft'),
+                version: baileysVersion,
                 cachedGroupMetadata: async (jid) => {
                     const cached = this.groupMetadataCache.get(jid);
                     if (cached) {
@@ -285,6 +320,10 @@ class WhatsAppClient extends EventEmitter {
                 // Save message store to file immediately
                 await this.saveMessageStore();
 
+                /*console.log('-'.repeat(50));
+                console.dir(update, { depth: null });
+                console.log('-'.repeat(50));*/
+
                 try {
                     if (update.type !== 'notify' || !update.messages?.length) return;
                     const [message] = update.messages;
@@ -295,19 +334,14 @@ class WhatsAppClient extends EventEmitter {
 
                     const msg = message.message || {};
 
+                    let jid = this._normalizeJid(message.key.remoteJid);
 
-                    let jid = message.key.remoteJid;
-
-                    // Prefer PN (Phone Number) JID over LID for better compatibility
-                    // remoteJidAlt contains the alternate JID (PN if primary is LID, or vice versa)
-                    if (typeof message.key.remoteJidAlt === 'string' &&
-                        message.key.remoteJidAlt.endsWith('@s.whatsapp.net')
-                    ) {
-                        jid = message.key.remoteJidAlt;
-                    }
+                    // Keep the original technical JID as the primary identifier for Signal sessions
+                    // remoteJidAlt can be used if needed, but not to replace the primary jid for technical replies
+                    const jidAlt = this._normalizeJid(message.key.remoteJidAlt) || null;
                     // Resolve the actual sender (preferring PN over LID)
-                    const participant = message.key.participant || message.participant || null;
-                    const participantAlt = message.key.participantAlt || null;
+                    const participant = this._normalizeJid(message.key.participant || message.participant) || null;
+                    const participantAlt = this._normalizeJid(message.key.participantAlt) || null;
 
                     let sender = jid;
                     if (jid.endsWith('@g.us') || jid === 'status@broadcast') {
@@ -395,6 +429,7 @@ class WhatsAppClient extends EventEmitter {
 
                     this.emit('message', {
                         from: jid,
+                        fromAlt: jidAlt,
                         sender,
                         participant,
                         participantAlt,
@@ -421,13 +456,13 @@ class WhatsAppClient extends EventEmitter {
             this.sock.ev.on('messages.update', (updates) => {
                 const deletedMessages = antiDeleteHandler(updates);
                 for (const info of deletedMessages) {
-                    let jid = info.key.remoteJid;
-                    if (typeof info.key.remoteJidAlt === 'string' && info.key.remoteJidAlt.endsWith('@s.whatsapp.net')) {
-                        jid = info.key.remoteJidAlt;
-                    }
+                    let jid = this._normalizeJid(info.key.remoteJid);
+                    // Use original remoteJid for technical identification
+                    const jidAlt = this._normalizeJid(info.key.remoteJidAlt) || null;
 
                     this.emit('message-deleted', {
                         jid: jid,
+                        jidAlt: jidAlt,
                         originalMessage: info.originalMessage,
                         key: info.key
                     });
@@ -440,16 +475,16 @@ class WhatsAppClient extends EventEmitter {
 
                 try {
                     for (const reaction of reactions) {
+                        if (reaction.key?.fromMe) continue;
+
                         // Get the chat JID, preferring PN over LID
-                        let jid = reaction.key.remoteJid;
-                        if (typeof reaction.key.remoteJidAlt === 'string' &&
-                            reaction.key.remoteJidAlt.endsWith('@s.whatsapp.net')) {
-                            jid = reaction.key.remoteJidAlt;
-                        }
+                        let jid = this._normalizeJid(reaction.key.remoteJid);
+                        // Use original remoteJid for technical identification
+                        const jidAlt = this._normalizeJid(reaction.key.remoteJidAlt) || null;
 
                         // Resolve the sender (who reacted), preferring PN over LID
-                        const participant = reaction.key.participant || null;
-                        const participantAlt = reaction.key.participantAlt || null;
+                        const participant = this._normalizeJid(reaction.key.participant) || null;
+                        const participantAlt = this._normalizeJid(reaction.key.participantAlt) || null;
 
                         let sender = jid;
                         if (jid.endsWith('@g.us') || jid === 'status@broadcast') {
@@ -464,6 +499,7 @@ class WhatsAppClient extends EventEmitter {
                         // Emit the reaction event
                         this.emit('message-reaction', {
                             from: jid,
+                            fromAlt: jidAlt,
                             sender: sender,
                             participant: participant,
                             participantAlt: participantAlt,
@@ -604,6 +640,7 @@ class WhatsAppClient extends EventEmitter {
      * @throws {Error} If client is not connected or message sending fails
      */
     async sendMessage(chatId, message, options = {}) {
+        chatId = this._normalizeJid(chatId);
         if (!this.isConnected) {
             throw new Error('Client is not connected');
         }
@@ -618,9 +655,9 @@ class WhatsAppClient extends EventEmitter {
             switch (message.type) {
                 case 'text':
                     messageContent = { text: message.text };
-                    if (message.mentions) {
-                        messageContent.mentions = message.mentions;
-                    }
+                    const { mentions: textMentions, mentionAll: textMentionAll } = this._handleMentions(message.mentions, message.mentionAll);
+                    if (textMentions) messageContent.mentions = textMentions;
+                    if (textMentionAll !== undefined) messageContent.mentionAll = textMentionAll;
                     break;
 
                 case 'location':
@@ -682,6 +719,7 @@ class WhatsAppClient extends EventEmitter {
      * @throws {Error} If client is not connected or file not found
      */
     async sendMedia(chatId, filePath, options = {}) {
+        chatId = this._normalizeJid(chatId);
         if (!this.isConnected) {
             throw new Error('Client is not connected');
         }
@@ -733,9 +771,9 @@ class WhatsAppClient extends EventEmitter {
                     throw new Error('Unsupported file type: ' + fileExtension);
             }
 
-            if (options.mentions) {
-                mediaMessage.mentions = options.mentions;
-            }
+            const { mentions: mediaMentions, mentionAll: mediaMentionAll } = this._handleMentions(options.mentions, options.mentionAll);
+            if (mediaMentions) mediaMessage.mentions = mediaMentions;
+            if (mediaMentionAll !== undefined) mediaMessage.mentionAll = mediaMentionAll;
 
             return await this.sock.sendMessage(chatId, mediaMessage, { ai: true });
         } catch (error) {
@@ -753,6 +791,7 @@ class WhatsAppClient extends EventEmitter {
      * @throws {Error} If client is not connected or file not found
      */
     async sendDocument(chatId, filePath, caption = '') {
+        chatId = this._normalizeJid(chatId);
         if (!this.isConnected) {
             throw new Error('Client is not connected');
         }
@@ -776,7 +815,10 @@ class WhatsAppClient extends EventEmitter {
 
             if (typeof caption === 'object' && caption !== null) {
                 if (caption.caption) messageContent.caption = caption.caption;
-                if (caption.mentions) messageContent.mentions = caption.mentions;
+
+                const { mentions: docMentions, mentionAll: docMentionAll } = this._handleMentions(caption.mentions, caption.mentionAll);
+                if (docMentions) messageContent.mentions = docMentions;
+                if (docMentionAll !== undefined) messageContent.mentionAll = docMentionAll;
             }
 
             return await this.sock.sendMessage(chatId, {
@@ -804,6 +846,7 @@ class WhatsAppClient extends EventEmitter {
      * @throws {Error} If client is not connected or message sending fails
      */
     async sendButtons(chatId, options = {}, extraOptions = {}) {
+        chatId = this._normalizeJid(chatId);
         if (!this.isConnected) {
             throw new Error('Client is not connected');
         }
@@ -886,7 +929,9 @@ class WhatsAppClient extends EventEmitter {
      * @returns {Promise<object>} The sent message info
      * @throws {Error} If client is not connected or message sending fails
      */
+
     async SendList(chatId, listOptions) {
+        chatId = this._normalizeJid(chatId);
         if (!this.isConnected) {
             throw new Error('Client is not connected');
         }
@@ -913,6 +958,97 @@ class WhatsAppClient extends EventEmitter {
             throw error;
         }
     }
+
+    /**
+     * Send Quick Reply Buttons (V2)
+     * @param {string} jid - Target JID
+     * @param {string} text - Message text
+     * @param {Array<object>} buttons - Array of { id, displayText }
+     * @param {object} options - { footer }
+     */
+    async sendQuickReplyV2(jid, text, buttons, options = {}) {
+        jid = this._normalizeJid(jid);
+        if (!this.isConnected) throw new Error('Client is not connected');
+        const message = generateQuickReplyButtons(text, buttons, options);
+        return await this.sock.sendMessage(jid, message, { ai: true });
+    }
+
+    /**
+     * Send Generic Interactive Button Message (V2)
+     * @param {string} jid - Target JID
+     * @param {object} options - Button options
+     */
+    async sendInteractiveButtonV2(jid, options) {
+        jid = this._normalizeJid(jid);
+        if (!this.isConnected) throw new Error('Client is not connected');
+        const message = generateInteractiveButtonMessage(options);
+        return await this.sock.sendMessage(jid, message, { ai: true });
+    }
+
+    /**
+     * Send URL Button (V2)
+     * @param {string} jid - Target JID
+     * @param {string} text - Message text
+     * @param {Array<object>} buttons - Array of { displayText, url }
+     * @param {object} options - { title, footer }
+     */
+    async sendUrlButtonV2(jid, text, buttons, options = {}) {
+        jid = this._normalizeJid(jid);
+        if (!this.isConnected) throw new Error('Client is not connected');
+        const message = generateUrlButtonMessage(text, buttons, options);
+        return await this.sock.sendMessage(jid, message, { ai: true });
+    }
+
+    /**
+     * Send Copy Code Button (V2)
+     * @param {string} jid - Target JID
+     * @param {string} text - Message text
+     * @param {string} code - Code to be copied
+     * @param {string} buttonText - Text on the copy button
+     */
+    async sendCopyCodeV2(jid, text, code, buttonText) {
+        jid = this._normalizeJid(jid);
+        if (!this.isConnected) throw new Error('Client is not connected');
+        const message = generateCopyCodeButton(text, code, buttonText);
+        return await this.sock.sendMessage(jid, message, { ai: true });
+    }
+
+    /**
+     * Send Combined Buttons (V2)
+     * @param {string} jid - Target JID
+     * @param {string} text - Message text
+     * @param {Array<object>} buttons - Mix of { type: 'reply'|'url'|'call'|'copy', ... }
+     * @param {object} options - { title, footer }
+     */
+    async sendCombinedButtonsV2(jid, text, buttons, options = {}) {
+        jid = this._normalizeJid(jid);
+        if (!this.isConnected) throw new Error('Client is not connected');
+        const message = generateCombinedButtons(text, buttons, options);
+        return await this.sock.sendMessage(jid, message, { ai: true });
+    }
+
+    /**
+     * Send Interactive List Message (V2)
+     * @param {string} jid - Target JID
+     * @param {object} options - List options (title, buttonText, description, footer, sections)
+     */
+    async sendListV2(jid, options) {
+        jid = this._normalizeJid(jid);
+        if (!this.isConnected) throw new Error('Client is not connected');
+        const message = generateInteractiveListMessage(options);
+        return await this.sock.relayMessage(jid, message, { ai: true });
+    }
+
+    /**
+     * Send Buttons Cards Message
+     * @param {string} jid - Target JID
+     * @param {object} options - Cards options (text, title, subtile, footer, cards)
+     */
+    async sendcards(jid, options) {
+        jid = this._normalizeJid(jid);
+        if (!this.isConnected) throw new Error('Client is not connected');
+        return await this.sock.sendMessage(jid, options, { ai: true });
+    }
     /**
      * Send an external ad reply with a local image
      * @param {string} number - The phone number to send the ad to
@@ -924,6 +1060,7 @@ class WhatsAppClient extends EventEmitter {
      */
 
     async sendAdReply(number, msg, imgpath, title, body, sourceurl) {
+        number = this._normalizeJid(number);
         if (!this.isConnected) {
             throw new Error('Client is not connected');
         }
@@ -993,7 +1130,8 @@ class WhatsAppClient extends EventEmitter {
         const results = [];
 
         try {
-            for (const participantId of participantIds) {
+            for (let participantId of participantIds) {
+                participantId = this._normalizeJid(participantId);
                 try {
                     let updateResult = await this.sock.groupParticipantsUpdate(
                         groupId,
@@ -1294,6 +1432,17 @@ class WhatsAppClient extends EventEmitter {
         await this.sock.sendPresenceUpdate("paused", jid);
     }
 
+    /**
+     * Create a typing indicator controller for manual or standalone presence control
+     * @returns {object} The typing indicator controller
+     */
+    createPresenceController() {
+        if (!this.sock) throw new Error('Client is not connected');
+        return createTypingIndicator(
+            (jid, presence) => this.sock.sendPresenceUpdate(presence, jid)
+        );
+    }
+
     /**
      * Reinitialize the WhatsApp client by clearing the session and reconnecting
      * @returns {Promise<void>}
@@ -2374,6 +2523,42 @@ class WhatsAppClient extends EventEmitter {
         }
     }
 
+    /**
+     * Update profile status (about)
+     * @param {string} status - The new status message
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or update fails
+     */
+    async updateProfileStatus(status) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+        try {
+            await this.sock.updateProfileStatus(status);
+        } catch (error) {
+            console.error('Error updating profile status:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Update profile name
+     * @param {string} name - The new profile name
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or update fails
+     */
+    async updateProfileName(name) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+        try {
+            await this.sock.updateProfileName(name);
+        } catch (error) {
+            console.error('Error updating profile name:', error);
+            throw error;
+        }
+    }
+
     /**
      * Add EXIF metadata to an existing WebP buffer
      * @param {Buffer} buffer - WebP buffer
@@ -2392,6 +2577,89 @@ class WhatsAppClient extends EventEmitter {
             throw error;
         }
     }
+
+    /**
+     * Post a status update (story) with various media types and styles
+     * @param {object} options Options for the status update
+     * @param {string} [options.text] Text content for a text status
+     * @param {string|number[]} [options.backgroundColor] Background color for text status (hex or array of rgb)
+     * @param {number} [options.font] Font type for text status (1-5)
+     * @param {string} [options.textColor] Text color (hex)
+     * @param {string} [options.imagePath] Path to image file for image status
+     * @param {string} [options.videoPath] Path to video file for video status
+     * @param {string} [options.audioPath] Path to audio file for voice note status
+     * @param {Buffer} [options.imageBuffer] Buffer containing image data
+     * @param {Buffer} [options.videoBuffer] Buffer containing video data
+     * @param {Buffer} [options.audioBuffer] Buffer containing audio data
+     * @param {string} [options.caption] Caption for image or video status
+     * @param {boolean} [options.isGif=false] Whether the video should be played as a GIF
+     * @param {Array<string>} [contacts=[]] List of JIDs who should receive the status (important for Multi-Device)
+     * @returns {Promise<object>} The sent message info
+     * @throws {Error} If client is not connected or options are invalid
+     */
+    async sendStatus(options = {}, contacts = []) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            let statusMessage;
+
+            // Voice Note Status
+            if (options.audioPath || options.audioBuffer) {
+                const buffer = options.audioBuffer || fs.readFileSync(options.audioPath);
+                statusMessage = StatusHelper.voiceNote(buffer);
+            }
+            // Image Status
+            else if (options.imagePath || options.imageBuffer) {
+                const buffer = options.imageBuffer || fs.readFileSync(options.imagePath);
+                statusMessage = StatusHelper.image(buffer, options.caption || '');
+            }
+            // Video / GIF Status
+            else if (options.videoPath || options.videoBuffer) {
+                const buffer = options.videoBuffer || fs.readFileSync(options.videoPath);
+                if (options.isGif) {
+                    statusMessage = StatusHelper.gif(buffer, options.caption || '');
+                } else {
+                    statusMessage = StatusHelper.video(buffer, options.caption || '');
+                }
+            }
+            // Text Status
+            else if (options.text) {
+                statusMessage = StatusHelper.text(
+                    options.text,
+                    options.backgroundColor || STATUS_BACKGROUNDS.solid.purple,
+                    options.font || STATUS_FONTS.SANS_SERIF,
+                    options.textColor
+                );
+            } else {
+                throw new Error('Invalid status options: Provide text, image, video, or audio.');
+            }
+
+            // Send using the new StatusHelper
+            return await StatusHelper.send(this.sock, statusMessage, contacts);
+
+        } catch (error) {
+            console.error('Error sending status:', error);
+            throw error;
+        }
+    }
+
+    async sendGroupStatus(jid, content = {}, options = {}) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        if (!jid || typeof jid !== 'string' || !jid.endsWith('@g.us')) {
+            throw new Error('Invalid group JID. Expected a JID ending with @g.us');
+        }
+
+        if (!content || typeof content !== 'object') {
+            throw new Error('Invalid content. Expected an object');
+        }
+
+        return await this.sock.sendMessage(jid, { ...content, groupStatus: true }, options);
+    }
 }
 
 function formatCode(code) {
@@ -2404,4 +2672,6 @@ function formatCode(code) {
 module.exports = {
     WhatsAppClient: WhatsAppClient,
     Group: Group,
+    STATUS_BACKGROUNDS,
+    STATUS_FONTS
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "innovators-bot2",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "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": "latest",
+    "@innovatorssoft/baileys": "^7.4.3",
     "figlet": "^1.8.0",
     "mime": "^3.0.0",
     "mime-types": "^2.1.35",

package/publish-dual.js

@@ -1,40 +0,0 @@
-const { execSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
-const packagePath = path.join(__dirname, 'package.json');
-
-// Read the original package.json
-const originalPackage = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-const originalName = originalPackage.name;
-
-console.log('🚀 Starting dual npm publish...\n');
-
-try {
-    // Step 1: Publish as unscoped package (innovators-bot2)
-    console.log(`📦 Publishing as "${originalName}"...`);
-    execSync('npm publish', { stdio: 'inherit', cwd: __dirname });
-    console.log(`✅ Successfully published "${originalName}"\n`);
-
-    // Step 2: Change name to scoped package
-    const scopedName = '@innovatorssoft/innovators-bot2';
-    console.log(`📦 Publishing as "${scopedName}"...`);
-    
-    originalPackage.name = scopedName;
-    fs.writeFileSync(packagePath, JSON.stringify(originalPackage, null, 2) + '\n');
-
-    // Step 3: Publish as scoped package with public access
-    execSync('npm publish --access public', { stdio: 'inherit', cwd: __dirname });
-    console.log(`✅ Successfully published "${scopedName}"\n`);
-
-} catch (error) {
-    console.error('❌ Error during publish:', error.message);
-    process.exitCode = 1;
-} finally {
-    // Step 4: Always restore original package.json
-    console.log('🔄 Restoring original package.json...');
-    originalPackage.name = originalName;
-    fs.writeFileSync(packagePath, JSON.stringify(originalPackage, null, 2) + '\n');
-    console.log('✅ Original package.json restored');
-    console.log('\n🎉 Dual publish complete!');
-}