waengine 2.4.9 → 2.5.0

package/README.md

@@ -1,4 +1,84 @@
-# 🚀 WAEngine v1.7.6 - Analytics Bugfix Edition
+# 🚀 WAEngine v2.5.0 - Ultra-Robust Internet Retry-Logig and new message types
+
+---
+
+## 🆕 What's new in v2.5.0
+
+### 🔧 Fixed
+- **Connection recovery** — bot now retries every 5s indefinitely until internet is restored (no more "Recovery already in progress" deadlock)
+
+### ➕ Added — Send Methods
+- **`msg.sendPTV(path)`** — send round video bubble (PTV)
+  ```js
+  await msg.sendPTV('./video.mp4');
+  ```
+- **`msg.sendAll(text)`** — native @everyone mention in groups
+  ```js
+  await msg.sendAll('Hey everyone!');
+  ```
+- **`msg.sendViewOnce(path, type)`** — view-once image, video or audio
+  ```js
+  await msg.sendViewOnce('./img.jpg', 'image');
+  await msg.sendViewOnce('./clip.mp4', 'video');
+  await msg.sendViewOnce('./voice.ogg', 'audio');
+  ```
+- **`msg.remReact()`** — remove your reaction from a message
+  ```js
+  await msg.remReact();
+  ```
+
+### ➕ Added — Message Properties
+- **`msg.isReply`** / **`msg.quotedMessage`** — detect & read replied messages
+  ```js
+  if (msg.isReply) console.log(msg.quotedMessage.text);
+  ```
+- **`msg.isForwarded`** / **`msg.forwardingScore`** — detect forwarded messages
+  ```js
+  if (msg.isForwarded) console.log('Forwarded', msg.forwardingScore, 'times');
+  ```
+- **`msg.isMedia`** / **`msg.mediaType`** — quick media type check
+  ```js
+  if (msg.isMedia) console.log(msg.mediaType); // 'image' | 'video' | 'audio' | ...
+  ```
+- **`msg.isEveryoneMention`** — detect incoming @everyone
+  ```js
+  if (msg.isEveryoneMention) await msg.reply('Everyone was mentioned!');
+  ```
+
+### ➕ Added — Events
+- **`reaction`** — someone reacted to a message
+  ```js
+  bot.on('reaction', (r) => console.log(r.from, r.emoji, r.removed));
+  ```
+- **`call`** — incoming call detected
+  ```js
+  bot.on('call', (call) => console.log(call.from, call.isVideo, call.status));
+  ```
+- **`typing`** — someone is typing
+  ```js
+  bot.on('typing', ({ from, isTyping }) => console.log(from, isTyping));
+  ```
+- **`recording`** — someone is recording audio
+  ```js
+  bot.on('recording', ({ from }) => console.log(from + ' is recording...'));
+  ```
+- **`message.delete`** — a message was deleted
+  ```js
+  bot.on('message.delete', (item) => console.log('deleted:', item));
+  ```
+- **`group.update`** — group name/description changed
+  ```js
+  bot.on('group.update', (u) => console.log(u.subject, u.desc));
+  ```
+- **`labels.association`** / **`labels.edit`** — WhatsApp Business label events
+  ```js
+  bot.on('labels.association', (a) => console.log(a));
+  bot.on('labels.edit', (l) => console.log(l));
+  ```
+
+---
+
+
 
 [![NPM Version](https://img.shields.io/npm/v/waengine)](https://www.npmjs.com/package/waengine)
 [![Downloads](https://img.shields.io/npm/dm/waengine)](https://www.npmjs.com/package/waengine)
@@ -1569,6 +1649,6 @@ console.log('Most Common:', stats.mostCommonError);
 console.log('By Code:', stats.errorsByCode);
 ```
 
-**📖 Full Documentation:** [ERROR-CODES.md](./ERROR-CODES.md)
+**📖 Full Documentation:** [FEATURES.md](./FEATURES.md)
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waengine",
-  "version": "2.4.9",
+  "version": "2.5.0",
   "description": "🚀 WAEngine - The most powerful WhatsApp Bot Library with 860+ Working Features, Complete Baileys Integration & Production-Ready Stability",
   "main": "src/index.js",
   "type": "module",

package/src/client.js

@@ -1141,6 +1141,32 @@ export class WhatsAppClient {
 
         this.socket.ev.on("presence.update", (update) => {
             this.emit('presence.update', update);
+            
+            // Tippen / Aufnehmen erkennen - sauber extrahiert
+            if (update.presences) {
+                Object.entries(update.presences).forEach(([jid, presence]) => {
+                    if (presence.lastKnownPresence === 'composing') {
+                        this.emit('typing', {
+                            from: jid,
+                            chat: update.id,
+                            isTyping: true
+                        });
+                    } else if (presence.lastKnownPresence === 'recording') {
+                        this.emit('recording', {
+                            from: jid,
+                            chat: update.id,
+                            isRecording: true
+                        });
+                    } else if (presence.lastKnownPresence === 'paused') {
+                        // Hat aufgehört zu tippen
+                        this.emit('typing', {
+                            from: jid,
+                            chat: update.id,
+                            isTyping: false
+                        });
+                    }
+                });
+            }
         });
 
         this.socket.ev.on("group-participants.update", (update) => {
@@ -1154,6 +1180,67 @@ export class WhatsAppClient {
         this.socket.ev.on("contacts.upsert", (contacts) => {
             this.emit('contacts.upsert', contacts);
         });
+
+        // Reaktionen auf Nachrichten erkennen
+        this.socket.ev.on("messages.upsert", ({ messages }) => {
+            messages.forEach(msg => {
+                if (msg.message?.reactionMessage) {
+                    const reaction = msg.message.reactionMessage;
+                    this.emit('reaction', {
+                        from: msg.key.participant || msg.key.remoteJid,
+                        chat: msg.key.remoteJid,
+                        messageId: reaction.key?.id,
+                        emoji: reaction.text,           // leer = Reaktion entfernt
+                        removed: reaction.text === '',
+                        timestamp: msg.messageTimestamp,
+                        raw: msg
+                    });
+                }
+            });
+        });
+
+        // Eingehende Anrufe erkennen
+        this.socket.ev.on("call", (calls) => {
+            calls.forEach(call => {
+                this.emit('call', {
+                    id: call.id,
+                    from: call.chatId,
+                    isVideo: call.isVideo,
+                    isGroup: call.isGroup,
+                    status: call.status, // 'offer' | 'ringing' | 'accept' | 'timeout' | 'reject'
+                    timestamp: call.date,
+                    raw: call
+                });
+            });
+        });
+
+        // Nachrichten gelöscht erkennen
+        this.socket.ev.on("messages.delete", (item) => {
+            this.emit('message.delete', item);
+        });
+
+        // Gruppen-Info geändert (Name, Beschreibung, Bild)
+        this.socket.ev.on("groups.update", (updates) => {
+            updates.forEach(update => {
+                this.emit('group.update', {
+                    id: update.id,
+                    subject: update.subject,         // neuer Gruppenname
+                    desc: update.desc,               // neue Beschreibung
+                    announce: update.announce,       // nur Admins können schreiben
+                    restrict: update.restrict,
+                    raw: update
+                });
+            });
+        });
+
+        // WhatsApp Business Labels
+        this.socket.ev.on("labels.association", (association) => {
+            this.emit('labels.association', association);
+        });
+
+        this.socket.ev.on("labels.edit", (label) => {
+            this.emit('labels.edit', label);
+        });
     }
 
     parseMessage(msg) {
@@ -1178,15 +1265,57 @@ export class WhatsAppClient {
             text = msg.message.templateButtonReplyMessage.selectedId;
         }
 
+        // @everyone / @all Erkennung (neue Baileys-Funktion)
+        const mentionedJids = msg.message?.extendedTextMessage?.contextInfo?.mentionedJid || [];
+        const isEveryoneMention = mentionedJids.includes('0@s.whatsapp.net') ||
+            msg.message?.extendedTextMessage?.contextInfo?.mentionedJid?.some(j => j === '0@s.whatsapp.net') ||
+            text?.includes('@everyone') ||
+            text?.includes('@all');
+
+        // Reply / Zitat erkennen
+        const contextInfo = msg.message?.extendedTextMessage?.contextInfo ||
+            msg.message?.imageMessage?.contextInfo ||
+            msg.message?.videoMessage?.contextInfo ||
+            msg.message?.audioMessage?.contextInfo ||
+            msg.message?.documentMessage?.contextInfo ||
+            msg.message?.stickerMessage?.contextInfo || null;
+
+        const isReply = !!(contextInfo?.quotedMessage);
+        const quotedMessage = isReply ? {
+            id: contextInfo.stanzaId,
+            from: contextInfo.participant || contextInfo.remoteJid,
+            message: contextInfo.quotedMessage,
+            text: contextInfo.quotedMessage?.conversation ||
+                  contextInfo.quotedMessage?.extendedTextMessage?.text ||
+                  contextInfo.quotedMessage?.imageMessage?.caption ||
+                  contextInfo.quotedMessage?.videoMessage?.caption || null
+        } : null;
+
+        // Weitergeleitet erkennen
+        const isForwarded = !!(contextInfo?.isForwarded);
+        const forwardingScore = contextInfo?.forwardingScore || 0;
+
+        // Medientyp
+        const mediaTypes = ['image', 'video', 'audio', 'document', 'sticker'];
+        const msgType = this.getMessageType(msg.message);
+        const isMedia = mediaTypes.includes(msgType);
+
         return {
             id: msg.key.id,
             from: msg.key.remoteJid,
             fromMe: msg.key.fromMe,
             text: text,
             timestamp: msg.messageTimestamp,
-            type: this.getMessageType(msg.message),
+            type: msgType,
             isGroup: msg.key.remoteJid?.includes("@g.us"),
-            participant: msg.key.participant, // Wichtig für Gruppen
+            participant: msg.key.participant,
+            isEveryoneMention,
+            isReply,
+            quotedMessage,
+            isForwarded,
+            forwardingScore,
+            isMedia,
+            mediaType: isMedia ? msgType : null,
             raw: msg
         };
     }

package/src/connection-recovery.js

@@ -128,12 +128,20 @@ export class ConnectionRecovery {
         
         console.log('🛡️ Initiating connection recovery...');
         
-        try {
-            await this.executeRecoveryStrategies();
-        } catch (recoveryError) {
-            console.error('❌ Recovery failed:', recoveryError.message);
-        } finally {
-            this.state.isRecovering = false;
+        // Endlose Retry-Schleife: läuft so lange bis Verbindung wieder steht
+        while (this.state.isRecovering) {
+            try {
+                await this.executeRecoveryStrategies();
+                // Erfolgreich verbunden
+                this.state.isRecovering = false;
+                return;
+            } catch (recoveryError) {
+                console.log(`❌ Recovery attempt failed: ${recoveryError.message}`);
+                console.log('🌐 Waiting for internet... retrying in 5s');
+                // Retrycount zurücksetzen damit nächste Runde wieder alle Strategien versucht
+                this.state.retryCount = 0;
+                await new Promise(resolve => setTimeout(resolve, 5000));
+            }
         }
     }
     
@@ -147,10 +155,6 @@ export class ConnectionRecovery {
         ];
         
         for (const strategy of strategies) {
-            if (this.state.retryCount >= this.options.maxRetries) {
-                throw new Error('Max retries exceeded');
-            }
-            
             try {
                 console.log(`🔧 Trying strategy: ${strategy.name}`);
                 await strategy.fn();
@@ -281,7 +285,7 @@ export class ConnectionRecovery {
         console.log('🔄 Recovery state reset');
     }
     
-    // Cleanup
+    // Cleanup - setzt isRecovering auf false, damit die Retry-Schleife stoppt
     cleanup() {
         this.stopHealthMonitoring();
         this.state.isRecovering = false;

package/src/message.js

@@ -13,6 +13,13 @@ export class Message {
         this.timestamp = data.timestamp;
         this.type = data.type;
         this.isGroup = data.isGroup;
+        this.isEveryoneMention = data.isEveryoneMention || false;
+        this.isReply = data.isReply || false;
+        this.quotedMessage = data.quotedMessage || null;
+        this.isForwarded = data.isForwarded || false;
+        this.forwardingScore = data.forwardingScore || 0;
+        this.isMedia = data.isMedia || false;
+        this.mediaType = data.mediaType || null;
         this.raw = data.raw;
         
         // Command Properties (werden vom Client gesetzt)
@@ -336,6 +343,38 @@ export class Message {
         }
         return results;
     }
+    // PTV = Personal/Private To View - runde Video-Bubble im Chat
+    async sendPTV(videoSource, mentions = []) {
+        try {
+            // Unterstützt: Dateipfad (string), URL (string), Buffer, Base64-String
+            let videoData;
+            if (Buffer.isBuffer(videoSource)) {
+                videoData = videoSource;
+            } else if (typeof videoSource === 'string' && videoSource.startsWith('data:')) {
+                // Base64 data URL: "data:video/mp4;base64,..."
+                const base64 = videoSource.split(',')[1];
+                videoData = Buffer.from(base64, 'base64');
+            } else {
+                // Dateipfad oder URL
+                videoData = { url: videoSource };
+            }
+
+            const message = {
+                video: videoData,
+                ptv: true,
+                mimetype: 'video/mp4'
+            };
+
+            if (mentions.length > 0) {
+                message.mentions = mentions;
+            }
+
+            return await this.client.socket.sendMessage(this.from, message);
+        } catch (error) {
+            console.error('❌ Fehler beim Senden des PTV:', error);
+            throw error;
+        }
+    }
 
     async sendGif(gifPath, caption = "", mentions = []) {
         const message = {
@@ -951,6 +990,61 @@ export class Message {
         return await this.reply(mentionText, allMembers);
     }
 
+    // @everyone / @all - neue native WhatsApp Funktion (Baileys: mention 0@s.whatsapp.net)
+    async sendAll(text) {
+        if (!this.isGroup) {
+            throw new Error('sendAll funktioniert nur in Gruppen');
+        }
+
+        return await this.client.socket.sendMessage(this.from, {
+            text: text,
+            mentions: ['0@s.whatsapp.net']
+        });
+    }
+
+    // Reaktion entfernen
+    async remReact() {
+        return await this.client.socket.sendMessage(this.from, {
+            react: { text: '', key: this.raw.key }
+        });
+    }
+
+    // View-Once senden (Bild, Video oder Audio das sich nach einmaligem Ansehen löscht)
+    async sendViewOnce(mediaSource, type = 'image', caption = '') {
+        try {
+            let mediaData;
+            if (Buffer.isBuffer(mediaSource)) {
+                mediaData = mediaSource;
+            } else {
+                mediaData = { url: mediaSource };
+            }
+
+            const message = {};
+            if (type === 'image') {
+                message.image = mediaData;
+                message.caption = caption;
+                message.viewOnce = true;
+            } else if (type === 'video') {
+                message.video = mediaData;
+                message.caption = caption;
+                message.viewOnce = true;
+                message.mimetype = 'video/mp4';
+            } else if (type === 'audio') {
+                message.audio = mediaData;
+                message.viewOnce = true;
+                message.mimetype = 'audio/ogg; codecs=opus';
+                message.ptt = true;
+            } else {
+                throw new Error('sendViewOnce: type muss "image", "video" oder "audio" sein');
+            }
+
+            return await this.client.socket.sendMessage(this.from, message);
+        } catch (error) {
+            console.error('❌ Fehler beim Senden der View-Once Nachricht:', error);
+            throw error;
+        }
+    }
+
     // Mention mit Typing - Neue Funktion für bessere UX
     async slowTypeWithMention(text, userJid) {
         const senderName = userJid.split('@')[0];