innovators-bot2 1.0.9 → 1.1.1

package/example.js

@@ -39,6 +39,23 @@ client.on('disconnected', (error) => {
 // Connect to WhatsApp
 client.connect()
 
+client.on('status', async status => {
+
+    console.log ('Status Received');
+    console.log ('Number:', status.from);
+    console.log ('Sender:', status.raw.pushName);
+    console.log ('Message:', status.body);
+    console.log ('Has Media:', status.hasMedia);
+    console.log('ID', status.key)
+
+    await client.readMessage(status.key)
+    await status.reply('Thanks for the status! ❤️');
+    await status.like('❤️');
+    console.log('Status Seen! and Replied With Emoji')
+
+
+});
+
 // Listen for incoming messages
 client.on('message', async msg => {   
     console.log ('Message Received');

package/index.js

@@ -145,171 +145,103 @@ class WhatsAppClient extends EventEmitter {
              * @emits WhatsAppClient#message - When a new message is received
              * @param {object} update - The message update object
              */
+
             this.sock.ev.on('messages.upsert', async (update) => {
                 try {
-                    // Skip if no messages or not a notification
-                    if (!update.messages || update.messages.length === 0 || update.type !== 'notify') {
-                        return;
-                    }
-
+                    if (update.type !== 'notify' || !update.messages?.length) return;
                     const [message] = update.messages;
-                    
-                    // Skip messages sent by the bot itself
-                    if (message.key.fromMe) {
-                        return;
-                    }
-
-                    /**
-                     * Extract message text from different possible locations in the message object
-                     * @type {string}
-                     */
-                    let messageText = '';
-                    let isButtonResponse = false;
-
-                    // Check for list response first
-                    if (message.message?.listResponseMessage) {
-                        messageText = message.message.listResponseMessage.title || 
-                                    message.message.listResponseMessage.description || '';
-                        isButtonResponse = true;
-                    } 
-                    // Check for button response
-                    else if (message.message?.templateButtonReplyMessage) {
-                        messageText = message.message.templateButtonReplyMessage.selectedDisplayText || 
-                                    message.message.templateButtonReplyMessage.selectedId || '';
-                        isButtonResponse = true;
-                    } 
-                    // Check for classic button response
-                    else if (message.message?.buttonsResponseMessage) {
-                        messageText = message.message.buttonsResponseMessage.selectedDisplayText || 
-                                    message.message.buttonsResponseMessage.selectedButtonId || '';
-                        isButtonResponse = true;
-                    } 
-                    // Regular message
-                    else {
-                        messageText = message.message?.conversation ||
-                                    message.message?.extendedTextMessage?.text ||
-                                    message.message?.imageMessage?.caption ||
-                                    message.message?.videoMessage?.caption ||
-                                    '';
-                    }
-
-                    /** @type {string|null} */
-                    let buttonType = null;
-                    /** @type {string} */
-                    let buttonText = '';
-
-                    // Determine message type and extract relevant data
-                    const { message: msg } = message;
-
-                    // Check for different types of button messages
-                    if (msg?.buttonsMessage) {
-                        buttonType = 'classic_buttons';
-                    } 
-                    // Check for hydrated template messages
-                    else if (msg?.templateMessage?.hydratedTemplate?.hydratedButtons) {
-                        buttonType = 'classic_buttons_hydrated';
-                    } 
-                    // Check for different types of hydrated four row templates
-                    else if (msg?.templateMessage?.hydratedFourRowTemplate) {
-                        const template = msg.templateMessage.hydratedFourRowTemplate;
-                        
-                        if (template.hydratedButtons) {
-                            buttonType = 'template_buttons_hydrated';
-                        } else if (template.title) {
-                            buttonType = 'template_text_hydrated';
-                        } else if (template.imageMessage) {
-                            buttonType = 'template_image_hydrated';
-                        } else if (template.videoMessage) {
-                            buttonType = 'template_video_hydrated';
-                        } else if (template.documentMessage) {
-                            buttonType = 'template_document_hydrated';
-                        }
-                    }
-
-                    // Handle interactive response messages
-                    if (msg?.interactiveResponseMessage) {
-                        const interactive = msg.interactiveResponseMessage;
-
-                        if (interactive.nativeFlowResponse?.response?.reply) {
-                            buttonType = 'interactive_buttons_modern_native_flow';
-                            buttonText = interactive.nativeFlowResponse.response.reply;
-                        } else if (interactive.reply) {
-                            buttonType = 'interactive_buttons_modern_reply';
-                            buttonText = interactive.reply;
-                        } else if (interactive.buttonReplyMessage?.displayText) {
-                            buttonType = 'interactive_buttons_modern_button_reply';
-                            buttonText = interactive.buttonReplyMessage.displayText;
-                        }
-                    }
-
-                    // Handle button and list responses
-                    if (msg?.listResponseMessage) {
-                        // Handle list response messages
-                        buttonType = 'list_response';
-                        buttonText = msg.listResponseMessage.title || '';
-                        if (msg.listResponseMessage.description) {
-                            buttonText = buttonText ? `${buttonText} - ${msg.listResponseMessage.description}` : msg.listResponse.description;
-                        }
-                    } else if (msg?.buttonsResponseMessage?.selectedButtonId) {
-                        // Handle classic button responses
-                        buttonType = 'classic_buttons';
-                        buttonText = msg.buttonsResponseMessage.selectedDisplayText || 
-                                    msg.buttonsResponseMessage.selectedButtonId || '';
-                    } else if (msg?.templateButtonReplyMessage?.selectedId) {
-                        // Handle template button replies
-                        buttonType = 'template_button_reply';
-                        buttonText = msg.templateButtonReplyMessage.selectedDisplayText || 
-                                    msg.templateButtonReplyMessage.selectedId || '';
-                    } else if (msg?.interactiveResponseMessage) {
-                        // Handle interactive responses (including list selections)
-                        const interactive = msg.interactiveResponseMessage;
-                        if (interactive.listResponse) {
-                            buttonType = 'list_selection';
-                            buttonText = interactive.listResponse.title || interactive.listResponse.description || '';
-                        } else if (interactive.nativeFlowResponse?.response?.reply) {
-                            buttonType = 'interactive_buttons_modern_native_flow';
-                            buttonText = interactive.nativeFlowResponse.response.reply;
+                    if (!message || message.key?.fromMe) return;
+            
+                    // 🚫 Ignore revoked/deleted messages (including deleted statuses)
+                    if (message.message?.protocolMessage?.type === 0) return;
+            
+                    const msg = message.message || {};
+                    const jid = message.key.remoteJid;
+                    const timestamp = new Date((message.messageTimestamp || Date.now()) * 1000);
+            
+                    const getText = () =>
+                        msg.conversation ||
+                        msg.extendedTextMessage?.text ||
+                        msg.imageMessage?.caption ||
+                        msg.videoMessage?.caption ||
+                        '';
+            
+                    const getButtonText = () => {
+                        if (msg.listResponseMessage)
+                            return msg.listResponseMessage.title || msg.listResponseMessage.description || '';
+                        if (msg.templateButtonReplyMessage)
+                            return msg.templateButtonReplyMessage.selectedDisplayText || msg.templateButtonReplyMessage.selectedId || '';
+                        if (msg.buttonsResponseMessage)
+                            return msg.buttonsResponseMessage.selectedDisplayText || msg.buttonsResponseMessage.selectedButtonId || '';
+                        if (msg.interactiveResponseMessage) {
+                            const i = msg.interactiveResponseMessage;
+                            return i.listResponse?.title ||
+                                   i.listResponse?.description ||
+                                   i.nativeFlowResponse?.response?.reply ||
+                                   i.reply ||
+                                   i.buttonReplyMessage?.displayText || '';
                         }
+                        return '';
+                    };
+            
+                    const reply = async (text) => this.sock.sendMessage(jid, { text }, { quoted: message });
+            
+                    // ✅ Handle status updates (stories)
+                    if (jid === 'status@broadcast') {
+                        const from = message.key?.participant || message.participant || message.pushName;
+                        this.emit('status', {
+                            from,
+                            body: getText(),
+                            hasMedia: Boolean(msg.imageMessage || msg.videoMessage),
+                            timestamp,
+                            key: message.key,
+                            raw: message,
+            
+                            // Reply to status
+                            reply: async (text) => {
+                                if (!from) throw new Error('Missing participant JID');
+                                return this.sock.sendMessage(from, { text }, { quoted: message });
+                            },
+            
+                            // 👍 Like (react) to status
+                            like: async (emoji = '❤️') => {
+                                if (!from) throw new Error('Missing participant JID');
+                                return this.sock.sendMessage(from, {
+                                    react: {
+                                        text: emoji,
+                                        key: message.key
+                                    }
+                                });
+                            }
+                        });
+                        return;
                     }
-
-                    // Prepare the message body - prioritize button/list responses over regular text
-                    const messageBody = buttonText || messageText || 
-                                     (msg?.listResponseMessage?.singleSelectReply?.selectedRowId) ||
-                                     (msg?.listResponseMessage?.title) ||
-                                     (msg?.listResponseMessage?.description) ||
-                                     '';
-
-                    // Emit the message event with all extracted data
+            
+                    // ✅ Handle normal/chat messages
+                    const buttonText = getButtonText();
+                    const body = buttonText || getText() ||
+                        msg.listResponseMessage?.singleSelectReply?.selectedRowId || '';
+            
                     this.emit('message', {
-                        from: message.key.remoteJid,
-                        body: messageText,
-                        hasMedia: Boolean(msg?.imageMessage || msg?.videoMessage || msg?.audioMessage || msg?.documentMessage),
-                        isGroup: message.key.remoteJid.endsWith('@g.us'),
-                        timestamp: message.messageTimestamp ? new Date(message.messageTimestamp * 1000) : new Date(),
-                        isButtonResponse: isButtonResponse,
-                        buttonId: message.message?.listResponseMessage?.singleSelectReply?.selectedRowId ||
-                                 message.message?.templateButtonReplyMessage?.selectedId || 
-                                 message.message?.buttonsResponseMessage?.selectedButtonId || null,
-                        buttonText: messageText,
+                        from: jid,
+                        body,
+                        hasMedia: Boolean(msg.imageMessage || msg.videoMessage || msg.audioMessage || msg.documentMessage),
+                        isGroup: jid.endsWith('@g.us'),
+                        timestamp,
+                        isButtonResponse: Boolean(buttonText),
+                        buttonId: msg?.listResponseMessage?.singleSelectReply?.selectedRowId ||
+                                  msg?.templateButtonReplyMessage?.selectedId ||
+                                  msg?.buttonsResponseMessage?.selectedButtonId || null,
+                        buttonText,
                         raw: message,
-                        reply: async (replyText) => {
-                            try {
-                                return await this.sock.sendMessage(
-                                    message.key.remoteJid,
-                                    { text: replyText },
-                                    { quoted: message }
-                                );
-                            } catch (error) {
-                                console.error('Error sending reply:', error);
-                                throw error;
-                            }
-                        },
+                        reply,
                     });
-                } catch (error) {
-                    console.error('Error processing message:', error);
+                } catch (err) {
+                    console.error('Error processing message:', err);
                 }
             });
-            // Handle incoming calls
+            
+                        // Handle incoming calls
             this.sock.ev.on('call', async (call) => {
                 try {
                     await this.emit('call', call);
@@ -388,7 +320,7 @@ class WhatsAppClient extends EventEmitter {
                     messageContent = {
                         react: {
                             text: message.emoji,
-                            key: message.messageKey
+                            key: message.messageKey || message.message?.key || message.key
                         }
                     };
                     break;
@@ -757,7 +689,13 @@ class WhatsAppClient extends EventEmitter {
             return await this.sock.profilePictureUrl(id);
         } catch (error) {
             // If the error is because the user has no profile picture, return undefined
-            if (error.message && error.message.includes('404')) {
+            const isStatus = (err, code) => (
+                (err && typeof err.message === 'string' && err.message.includes(String(code))) ||
+                (err && (err.status === code || err.code === code || err.data === code)) ||
+                (err && err.response && err.response.status === code) ||
+                (err && err.output && err.output.statusCode === code)
+            );
+            if (isStatus(error, 404) || isStatus(error, 401)) {
                 return undefined;
             }
             console.error('Error getting profile picture:', error);
@@ -791,6 +729,36 @@ class WhatsAppClient extends EventEmitter {
         return this.sock;
     }
 
+    /**
+     * Send typing indicator to a chat
+     * @param {string} jid - The JID of the chat
+     * @returns {Promise<void>}
+     */
+    async sendTypingPresence(jid) {
+        if (!this.sock) throw new Error('Not connected to WhatsApp');
+        await this.sock.sendPresenceUpdate("composing", jid);
+    }
+
+    /**
+     * Send recording indicator to a chat
+     * @param {string} jid - The JID of the chat
+     * @returns {Promise<void>}
+     */
+    async sendRecordingPresence(jid) {
+        if (!this.sock) throw new Error('Not connected to WhatsApp');
+        await this.sock.sendPresenceUpdate("recording", jid);
+    }
+
+    /**
+     * Clear typing/recording indicator from a chat
+     * @param {string} jid - The JID of the chat
+     * @returns {Promise<void>}
+     */
+    async sendPausedPresence(jid) {
+        if (!this.sock) throw new Error('Not connected to WhatsApp');
+        await this.sock.sendPresenceUpdate("paused", jid);
+    }
+
     /**
      * Reinitialize the WhatsApp client by clearing the session and reconnecting
      * @returns {Promise<void>}
@@ -815,7 +783,7 @@ class WhatsAppClient extends EventEmitter {
             if (this.sock) {
                 try {
                     this.sock.ev.removeAllListeners();
-                    await this.sock.end(undefined);
+                    this.sock.end(undefined);
                 } catch (e) {
                     console.error('Error while cleaning up socket:', e);
                 }

package/package.json

@@ -1,20 +1,33 @@
 {
   "name": "innovators-bot2",
-  "version": "1.0.9",
+  "version": "1.1.1",
   "description": "",
   "main": "index.js",
   "scripts": {
     "start": "node example.js",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "keywords": ["whatsapp", "bot", "automation", "baileys", "whatsapp-web.js", "messaging", "chat", "nodejs", "api", "group-management", "qr-code", "client" ],
+  "keywords": [
+    "whatsapp",
+    "bot",
+    "automation",
+    "baileys",
+    "whatsapp-web.js",
+    "messaging",
+    "chat",
+    "nodejs",
+    "api",
+    "group-management",
+    "qr-code",
+    "client"
+  ],
   "author": "Javed Arshad Bhatti",
   "license": "ISC",
   "repository": {
     "type": "git",
-    "url": "https://github.com/innovatorssoft/innovators-bot2.git"
+    "url": "git+https://github.com/innovatorssoft/WhatsAppAPI.git"
   },
-  "homepage": "https://github.com/innovatorssoft/innovators-bot2#readme",
+  "homepage": "https://github.com/innovatorssoft/WhatsAppAPI?tab=readme-ov-file#whatsapp-api",
   "dependencies": {
     "@itsukichan/baileys": "latest",
     "link-preview-js": "^3.0.13",