waengine 2.4.6 → 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.6",
+  "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/box-console.js

@@ -0,0 +1,347 @@
+// ===== BOX CONSOLE - Schöne detaillierte Message Boxes =====
+
+export class BoxConsole {
+    constructor(client) {
+        this.client = client;
+        this.enabled = false;
+        
+        // Speichere originale Console-Funktionen
+        this.originalLog = console.log.bind(console);
+        this.originalWarn = console.warn.bind(console);
+        this.originalError = console.error.bind(console);
+        
+        // Flag ob Console bereits gepatcht wurde
+        this.isPatched = false;
+    }
+
+    // Aktiviere/Deaktiviere Box Console
+    enable(enabled = true) {
+        this.enabled = enabled;
+        
+        if (enabled && !this.isPatched) {
+            // Patche Console-Funktionen
+            this.patchConsole();
+            this.originalLog('\n✅ Box Console aktiviert - Normale Message-Logs deaktiviert\n');
+        } else if (!enabled && this.isPatched) {
+            // Stelle originale Console wieder her
+            this.unpatchConsole();
+            this.originalLog('\n❌ Box Console deaktiviert - Normale Logs reaktiviert\n');
+        }
+    }
+
+    patchConsole() {
+        const self = this;
+        
+        // Patche console.warn
+        console.warn = function(...args) {
+            if (self.enabled) {
+                // Zeige Warning in Box
+                const warningText = args.join(' ');
+                self.showWarningBox(warningText);
+            } else {
+                self.originalWarn(...args);
+            }
+        };
+        
+        // Patche console.error
+        console.error = function(...args) {
+            if (self.enabled) {
+                // Zeige Error in Box
+                const errorText = args.join(' ');
+                const error = args[0] instanceof Error ? args[0] : new Error(errorText);
+                self.showErrorBox(error);
+            } else {
+                self.originalError(...args);
+            }
+        };
+        
+        this.isPatched = true;
+    }
+
+    unpatchConsole() {
+        // Stelle originale Funktionen wieder her
+        console.warn = this.originalWarn;
+        console.error = this.originalError;
+        
+        this.isPatched = false;
+    }
+
+    // Zeige Message Box
+    showMessageBox(msg) {
+        if (!this.enabled) return;
+
+        const box = this.createMessageBox(msg);
+        this.originalLog(box);
+    }
+
+    // Erstelle Message Box
+    createMessageBox(msg) {
+        // Extrahiere alle Infos
+        const name = msg.pushName || msg.verifiedBizName || 'Unbekannt';
+        const text = msg.body || msg.text || msg.message?.conversation || '[Keine Text-Nachricht]';
+        const device = this.detectDevice(msg);
+        const jid = msg.from || msg.key?.remoteJid || 'N/A';
+        const lid = msg.key?.participant?.split('@')[0] || jid.split('@')[0] || 'N/A';
+        const phone = this.extractPhoneNumber(jid);
+        const isCommand = this.isCommand(text);
+        const chatType = this.getChatType(jid);
+        const messageType = this.getMessageType(msg);
+        const userRole = this.getUserRole(msg, jid);
+
+        // Erstelle Box
+        const width = 70;
+        const line = '═'.repeat(width);
+        
+        let box = `\n╔${line}╗\n`;
+        box += this.boxLine('📨 NEUE NACHRICHT', width, 'center');
+        box += `╠${line}╣\n`;
+        
+        // User Info
+        box += this.boxLine(`👤 Name: ${name}`, width);
+        box += this.boxLine(`📱 Telefon: ${phone}`, width);
+        box += this.boxLine(`🆔 JID: ${jid}`, width);
+        box += this.boxLine(`🔢 LID: ${lid}`, width);
+        
+        box += `╠${line}╣\n`;
+        
+        // Message Info
+        box += this.boxLine(`💬 Nachricht: ${this.truncate(text, 50)}`, width);
+        box += this.boxLine(`📝 Typ: ${messageType}`, width);
+        box += this.boxLine(`💻 Gerät: ${device}`, width);
+        box += this.boxLine(`⚡ Command: ${isCommand ? 'Ja ✅' : 'Nein ❌'}`, width);
+        
+        box += `╠${line}╣\n`;
+        
+        // Chat Info
+        box += this.boxLine(`💭 Chat-Typ: ${chatType}`, width);
+        if (chatType === 'Gruppe') {
+            box += this.boxLine(`👑 Rolle: ${userRole}`, width);
+        }
+        
+        box += `╚${line}╝\n`;
+        
+        return box;
+    }
+
+    // Zeige Error Box
+    showErrorBox(error, context = '') {
+        const box = this.createErrorBox(error, context);
+        this.originalError(box);
+    }
+
+    createErrorBox(error, context) {
+        const width = 70;
+        const line = '═'.repeat(width);
+        
+        let box = `\n╔${line}╗\n`;
+        box += this.boxLine('❌ FEHLER', width, 'center');
+        box += `╠${line}╣\n`;
+        
+        const errorMsg = error.message || String(error);
+        box += this.boxLine(`🔴 Fehler: ${this.truncate(errorMsg, 60)}`, width);
+        
+        if (context) {
+            box += this.boxLine(`📍 Kontext: ${this.truncate(context, 60)}`, width);
+        }
+        
+        if (error.stack) {
+            const stackLines = error.stack.split('\n').slice(0, 3);
+            box += `╠${line}╣\n`;
+            box += this.boxLine('📚 Stack Trace:', width);
+            stackLines.forEach(line => {
+                box += this.boxLine(`  ${this.truncate(line.trim(), 65)}`, width);
+            });
+        }
+        
+        box += `╚${line}╝\n`;
+        
+        return box;
+    }
+
+    // Zeige Warning Box
+    showWarningBox(warning, context = '') {
+        const box = this.createWarningBox(warning, context);
+        this.originalWarn(box);
+    }
+
+    createWarningBox(warning, context) {
+        const width = 70;
+        const line = '═'.repeat(width);
+        
+        let box = `\n╔${line}╗\n`;
+        box += this.boxLine('⚠️  WARNUNG', width, 'center');
+        box += `╠${line}╣\n`;
+        
+        box += this.boxLine(`🟡 Warnung: ${this.truncate(String(warning), 60)}`, width);
+        
+        if (context) {
+            box += this.boxLine(`📍 Kontext: ${this.truncate(context, 60)}`, width);
+        }
+        
+        box += `╚${line}╝\n`;
+        
+        return box;
+    }
+
+    // Helper: Box Line
+    boxLine(text, width, align = 'left') {
+        const maxTextWidth = width - 4;
+        const truncated = this.truncate(text, maxTextWidth);
+        
+        let line = '║ ';
+        
+        if (align === 'center') {
+            const padding = Math.floor((maxTextWidth - truncated.length) / 2);
+            line += ' '.repeat(padding) + truncated + ' '.repeat(maxTextWidth - truncated.length - padding);
+        } else {
+            line += truncated + ' '.repeat(maxTextWidth - truncated.length);
+        }
+        
+        line += ' ║\n';
+        return line;
+    }
+
+    // Helper: Truncate Text
+    truncate(text, maxLength) {
+        if (!text) return '';
+        text = String(text);
+        if (text.length <= maxLength) return text;
+        return text.substring(0, maxLength - 3) + '...';
+    }
+
+    // Detect Device
+    detectDevice(msg) {
+        // Nutze device-detector falls verfügbar
+        try {
+            const messageId = msg.key?.id || msg.id;
+            if (messageId) {
+                const { DeviceDetector } = require('./device-detector.js');
+                const detector = new DeviceDetector();
+                const detection = detector.detectDevice(messageId);
+                
+                const deviceNames = {
+                    'web': '🌐 WhatsApp Web',
+                    'iphone': '📱 iPhone',
+                    'android': '🤖 Android',
+                    'desktop': '💻 Desktop',
+                    'business': '💼 Business',
+                    'unknown': '❓ Unbekannt'
+                };
+                
+                return deviceNames[detection.deviceType] || '❓ Unbekannt';
+            }
+        } catch (error) {
+            // Fallback
+        }
+        
+        return '❓ Unbekannt';
+    }
+
+    // Extract Phone Number
+    extractPhoneNumber(jid) {
+        if (!jid) return 'N/A';
+        
+        // Format: 491234567890@s.whatsapp.net
+        const match = jid.match(/^(\d+)@/);
+        if (match) {
+            const number = match[1];
+            // Formatiere: +49 123 4567890
+            if (number.length > 10) {
+                return `+${number.substring(0, 2)} ${number.substring(2, 5)} ${number.substring(5)}`;
+            }
+            return `+${number}`;
+        }
+        
+        return jid.split('@')[0] || 'N/A';
+    }
+
+    // Check if Command
+    isCommand(text) {
+        if (!text) return false;
+        
+        // Prüfe ob Text mit Prefix startet
+        const prefix = this.client.prefix || '!';
+        return text.trim().startsWith(prefix);
+    }
+
+    // Get Chat Type
+    getChatType(jid) {
+        if (!jid) return 'Unbekannt';
+        
+        if (jid.endsWith('@g.us')) return 'Gruppe';
+        if (jid.endsWith('@s.whatsapp.net')) return 'Privat';
+        if (jid.endsWith('@broadcast')) return 'Broadcast';
+        if (jid === 'status@broadcast') return 'Status';
+        
+        return 'Unbekannt';
+    }
+
+    // Get Message Type
+    getMessageType(msg) {
+        const message = msg.message;
+        if (!message) return 'Text';
+        
+        if (message.conversation) return 'Text';
+        if (message.extendedTextMessage) return 'Text (Extended)';
+        if (message.imageMessage) return 'Bild �️';
+        if (message.videoMessage) return 'Video 🎥';
+        if (message.audioMessage) return 'Audio 🎵';
+        if (message.documentMessage) return 'Dokument �';
+        if (message.stickerMessage) return 'Sticker 😀';
+        if (message.locationMessage) return 'Standort 📍';
+        if (message.contactMessage) return 'Kontakt 👤';
+        if (message.pollCreationMessage) return 'Umfrage 📊';
+        if (message.reactionMessage) return 'Reaktion ❤️';
+        if (message.viewOnceMessage) return 'View Once 👁️';
+        
+        return 'Text';
+    }
+
+    // Get User Role (in Groups)
+    async getUserRole(msg, jid) {
+        // Nur für Gruppen
+        if (!jid || !jid.endsWith('@g.us')) {
+            return 'N/A';
+        }
+        
+        try {
+            const participant = msg.key?.participant;
+            if (!participant || !this.client.socket) {
+                return 'Mitglied �';
+            }
+            
+            // Hole Gruppen-Metadaten
+            const groupMetadata = await this.client.socket.groupMetadata(jid);
+            
+            if (!groupMetadata || !groupMetadata.participants) {
+                return 'Mitglied �';
+            }
+            
+            // Finde Participant
+            const participantData = groupMetadata.participants.find(p => p.id === participant);
+            
+            if (!participantData) {
+                return 'Mitglied 👤';
+            }
+            
+            // Prüfe Rolle
+            if (participantData.admin === 'superadmin') {
+                return 'Superadmin 👑 (Ersteller)';
+            }
+            
+            if (participantData.admin === 'admin') {
+                return 'Admin 🛡️';
+            }
+            
+            return 'Mitglied 👤';
+            
+        } catch (error) {
+            return 'Mitglied 👤';
+        }
+    }
+}
+
+// Export für einfache Nutzung
+export function createBoxConsole(client) {
+    return new BoxConsole(client);
+}

package/src/client.js

@@ -152,12 +152,6 @@ export class WhatsAppClient {
         // FromMe Ignore System - NEUE GLOBALE API!
         this.ignoreFromMe = true; // Standard: Bot ignoriert sich selbst
         
-        // Log wenn automatisch aktiviert
-        if (this.ignoreOfflineMessages) {
-            console.log('\n📵 Offline Message Ignore: AUTOMATISCH AKTIVIERT');
-            console.log('   └─ Grund: Session über Session Menu gestartet\n');
-        }
-        
         // ===== GLOBAL VISUAL TYPING/RECORDING SYSTEM - NEU! =====
         this.globalVisualTyping = false; // Global aktiviert/deaktiviert
         this.globalVisualRecord = false; // Global aktiviert/deaktiviert
@@ -168,11 +162,8 @@ export class WhatsAppClient {
         this.load = {
             Plugins: async (pluginName) => {
                 if (pluginName === 'all') {
-                    console.log('🔌 Lade alle Plugins...');
                     await this.plugins.loadAllPlugins();
-                    console.log('✅ Alle Plugins geladen!');
                 } else {
-                    console.log(`🔌 Lade Plugin: ${pluginName}`);
                     await this.plugins.load(pluginName);
                 }
             }
@@ -183,12 +174,10 @@ export class WhatsAppClient {
             message: {
                 offline: (enabled = true) => {
                     this.ignoreOfflineMessages = enabled;
-                    console.log(`📵 Offline Message Ignore: ${enabled ? 'AKTIVIERT' : 'DEAKTIVIERT'}`);
                     return this;
                 },
                 FromMe: (enabled = true) => {
                     this.ignoreFromMe = enabled;
-                    console.log(`🤖 FromMe Ignore: ${enabled ? 'AKTIVIERT (Bot ignoriert sich selbst)' : 'DEAKTIVIERT (Bot reagiert auf eigene Messages)'}`);
                     return this;
                 }
             }
@@ -198,7 +187,6 @@ export class WhatsAppClient {
         this.info = {
             Console: (enabled = true) => {
                 this.consoleVerbose = enabled;
-                console.log(`📊 Console Info Mode: ${enabled ? 'VERBOSE (Alle Details)' : 'NORMAL (Nur wichtige Infos)'}`);
                 return this;
             }
         };
@@ -206,7 +194,6 @@ export class WhatsAppClient {
         this.silent = {
             Console: (enabled = true) => {
                 this.consoleSilent = enabled;
-                console.log(`🔇 Console Silent Mode: ${enabled ? 'AKTIVIERT (Nur gesendete Messages)' : 'DEAKTIVIERT (Normal)'}`);
                 return this;
             }
         };
@@ -216,12 +203,10 @@ export class WhatsAppClient {
         this.set = {
             Visualtyping: (ms) => {
                 this.visualTypingDuration = ms;
-                console.log(`⌨️ Visual Typing Dauer: ${ms}ms`);
                 return this;
             },
             Visualrecord: (ms) => {
                 this.visualRecordDuration = ms;
-                console.log(`🎤 Visual Record Dauer: ${ms}ms`);
                 return this;
             }
         };
@@ -1156,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) => {
@@ -1169,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) {
@@ -1193,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/console-renderer.js

@@ -1,5 +1,8 @@
 // ===== CONSOLE RENDERER - Schöne Console Outputs mit Prefix & Farben =====
 
+// Prüfe ob wir im Session Menu sind (kein Prefix) oder im Bot-Terminal (mit Prefix)
+const isSessionMenu = !process.env.__WAENGINE_SKIP_SESSION_MENU__;
+
 // ANSI Color Codes
 const colors = {
     // Basic Colors
@@ -89,6 +92,11 @@ console.log = function(...args) {
         return originalConsole.log(...args);
     }
     
+    // WICHTIG: Kein Prefix im Session Menu!
+    if (isSessionMenu) {
+        return originalConsole.log(...args);
+    }
+    
     const prefix = formatPrefix(globalConfig.prefix, globalConfig.prefixColor);
     const colorCode = getColor(globalConfig.defaultColor);
     
@@ -105,6 +113,11 @@ console.error = function(...args) {
         return originalConsole.error(...args);
     }
     
+    // WICHTIG: Kein Prefix im Session Menu!
+    if (isSessionMenu) {
+        return originalConsole.error(...args);
+    }
+    
     const prefix = formatPrefix(globalConfig.prefix, globalConfig.prefixColor);
     const colorCode = getColor(globalConfig.errorColor);
     
@@ -121,6 +134,11 @@ console.warn = function(...args) {
         return originalConsole.warn(...args);
     }
     
+    // WICHTIG: Kein Prefix im Session Menu!
+    if (isSessionMenu) {
+        return originalConsole.warn(...args);
+    }
+    
     const prefix = formatPrefix(globalConfig.prefix, globalConfig.prefixColor);
     const colorCode = getColor(globalConfig.warnColor);
     
@@ -137,6 +155,11 @@ console.info = function(...args) {
         return originalConsole.info(...args);
     }
     
+    // WICHTIG: Kein Prefix im Session Menu!
+    if (isSessionMenu) {
+        return originalConsole.info(...args);
+    }
+    
     const prefix = formatPrefix(globalConfig.prefix, globalConfig.prefixColor);
     const colorCode = getColor(globalConfig.infoColor);
     
@@ -153,68 +176,55 @@ export const render = {
     // Set prefix name
     consolePrefix(name) {
         globalConfig.prefix = name;
-        console.log(`✅ Console Prefix gesetzt: [${name}]`);
     },
     
     // Set prefix color
     consolePrefixColor(color) {
         if (!colors[color]) {
-            console.warn(`⚠️ Unbekannte Farbe: ${color}`);
             return;
         }
         globalConfig.prefixColor = color;
-        console.log(`🎨 Prefix Farbe gesetzt: ${color}`);
     },
     
     // Set default console.log color
     consoleColor(color) {
         if (!colors[color]) {
-            console.warn(`⚠️ Unbekannte Farbe: ${color}`);
             return;
         }
         globalConfig.defaultColor = color;
-        console.log(`🎨 Console Farbe gesetzt: ${color}`);
     },
     
     // Set console.error color
     consoleError(color) {
         if (!colors[color]) {
-            console.warn(`⚠️ Unbekannte Farbe: ${color}`);
             return;
         }
         globalConfig.errorColor = color;
-        console.log(`🎨 Error Farbe gesetzt: ${color}`);
     },
     
     // Set console.warn color
     consoleWarn(color) {
         if (!colors[color]) {
-            console.warn(`⚠️ Unbekannte Farbe: ${color}`);
             return;
         }
         globalConfig.warnColor = color;
-        console.log(`🎨 Warn Farbe gesetzt: ${color}`);
     },
     
     // Set console.info color
     consoleInfo(color) {
         if (!colors[color]) {
-            console.warn(`⚠️ Unbekannte Farbe: ${color}`);
             return;
         }
         globalConfig.infoColor = color;
-        console.log(`🎨 Info Farbe gesetzt: ${color}`);
     },
     
     // Enable/Disable rendering
     enable() {
         globalConfig.enabled = true;
-        console.log('✅ Console Rendering aktiviert');
     },
     
     disable() {
         globalConfig.enabled = false;
-        originalConsole.log('⚠️ Console Rendering deaktiviert');
     },
     
     // Reset to defaults
@@ -229,7 +239,6 @@ export const render = {
             successColor: 'green',
             enabled: true
         };
-        console.log('🔄 Console Rendering zurückgesetzt');
     },
     
     // Get current config
@@ -271,12 +280,3 @@ export const render = {
 
 // Export colors for direct use
 export { colors };
-
-// Auto-initialize message
-if (globalConfig.enabled) {
-    originalConsole.log(
-        `${colors.brightCyan}╔════════════════════════════════════════╗${colors.reset}\n` +
-        `${colors.brightCyan}║  🎨 Console Renderer aktiviert!       ║${colors.reset}\n` +
-        `${colors.brightCyan}╚════════════════════════════════════════╝${colors.reset}`
-    );
-}

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];

package/src/storage.js

@@ -165,15 +165,45 @@ export class WAStorage {
             // Schreibe in temporäre Datei
             fs.writeFileSync(tempFilePath, jsonData);
             
-            // Atomare Umbenennung (verhindert korrupte Dateien)
-            fs.renameSync(tempFilePath, filePath);
+            // Atomare Umbenennung mit Retry für Windows EPERM
+            let renamed = false;
+            let lastError = null;
+            const maxRetries = 3;
+            const retryDelays = [50, 100, 150]; // ms
+            
+            for (let attempt = 0; attempt < maxRetries; attempt++) {
+                try {
+                    fs.renameSync(tempFilePath, filePath);
+                    renamed = true;
+                    break;
+                } catch (error) {
+                    lastError = error;
+                    if (error.code === 'EPERM' && attempt < maxRetries - 1) {
+                        // Wait before retry (Windows file lock issue)
+                        const delay = retryDelays[attempt];
+                        const start = Date.now();
+                        while (Date.now() - start < delay) {
+                            // Busy wait
+                        }
+                    } else {
+                        throw error;
+                    }
+                }
+            }
+            
+            if (!renamed) {
+                throw lastError || new Error('Rename failed');
+            }
             
             // Cache mit Größenlimit aktualisieren
             this.updateCache(fileName, data);
             
             return true;
         } catch (error) {
-            console.error(`❌ Fehler beim Schreiben in ${fileName}:`, error);
+            // Suppress EPERM error logging (too noisy on Windows)
+            if (error.code !== 'EPERM') {
+                console.error(`❌ Fehler beim Schreiben in ${fileName}:`, error);
+            }
             
             // Cleanup temporäre Datei
             try {