waengine 1.8.9 → 1.9.4

package/FEATURES.md

@@ -458,6 +458,217 @@ msg.raw         // Raw Baileys Object
 
 ---
 
+## 📥 Media Download System **NEU in v1.7.9!**
+
+### **Download Media von Nachrichten**
+
+```javascript
+// Media von Message herunterladen
+const result = await msg.downloadMedia();
+
+if (result.success) {
+    console.log(`Downloaded: ${result.info.type}`);
+    console.log(`Size: ${result.info.fileSize} bytes`);
+    console.log(`Mimetype: ${result.info.mimetype}`);
+    
+    // Buffer verwenden
+    const buffer = result.buffer;
+    
+    // Oder direkt speichern
+    const saved = await msg.downloadMedia({
+        savePath: './downloads',
+        fileName: 'custom_name.jpg'
+    });
+    
+    console.log(`Saved to: ${saved.savedPath}`);
+}
+```
+
+**Download Features:**
+- ✅ **Alle Media-Typen** - Bilder, Videos, Audio, Dokumente, Sticker
+- ✅ **Buffer Return** - Direkter Zugriff auf Media-Buffer
+- ✅ **Auto-Save** - Optional direkt speichern
+- ✅ **Media Info** - Typ, Größe, Mimetype, Dateiname
+- ✅ **Caption Support** - Caption wird mit zurückgegeben
+- ✅ **Error Handling** - Detaillierte Fehlerbehandlung
+
+**Praktische Anwendungen:**
+```javascript
+// Auto-Sticker aus Bildern
+client.on('message', async (msg) => {
+    if (msg.type === 'imageMessage' && msg.text?.toLowerCase() === 'sticker') {
+        const media = await msg.downloadMedia();
+        
+        if (media.success) {
+            await msg.create.sticker.fromMedia(media.buffer, {
+                pack: 'Auto Stickers',
+                author: 'Bot'
+            });
+        }
+    }
+});
+
+// Media-Backup System
+client.on('message', async (msg) => {
+    const mediaTypes = ['imageMessage', 'videoMessage', 'audioMessage'];
+    
+    if (mediaTypes.includes(msg.type)) {
+        await msg.downloadMedia({
+            savePath: './media_backup',
+            fileName: `${msg.id}_${Date.now()}`
+        });
+    }
+});
+
+// Media-Weiterleitung
+client.addCommand('forward-media', async (msg) => {
+    const media = await msg.downloadMedia();
+    
+    if (media.success) {
+        // An anderen Chat senden
+        await client.socket.sendMessage(targetJid, {
+            [media.info.type]: media.buffer,
+            caption: media.info.caption
+        });
+    }
+});
+```
+
+---
+
+## 🎤 Enhanced Recording System
+
+### **Erweiterte Recording-Funktionen**
+
+```javascript
+// Recording starten/stoppen
+await msg.startRecording();
+await msg.stopRecording();
+
+// Recording für bestimmte Zeit
+await msg.simulateRecording(3000); // 3 Sekunden
+
+// Recording + Custom Function
+await msg.recordAndSend(async () => {
+    await msg.sendImage('photo.jpg', 'Nach Recording!');
+}, 3000);
+
+// Recording + Reply
+await msg.recordAndReply('Sprachnachricht!', 2500);
+
+// Visual Record (unified)
+await msg.visualRecord(true);  // Start
+await msg.visualRecord(false); // Stop
+```
+
+**Recording Features:**
+- ✅ **Start/Stop Control** - Manuelles Recording-Control
+- ✅ **Timed Recording** - Automatisches Stoppen nach Zeit
+- ✅ **Record & Send** - Recording + Custom Function
+- ✅ **Record & Reply** - Recording + Antwort
+- ✅ **Realistic Timing** - Basierend auf Nachrichtenlänge
+
+---
+
+## ⌨️ Enhanced Typing System
+
+### **Erweiterte Typing-Funktionen**
+
+```javascript
+// Typing starten/stoppen
+await msg.startTyping();
+await msg.stopTyping();
+
+// Typing für bestimmte Zeit
+await msg.typeFor(3000); // 3 Sekunden
+
+// Typing mit Auto-Stop
+await msg.visualWrite(true, 2000); // Stoppt automatisch nach 2s
+
+// Typing + Custom Function
+await msg.typeAndSend(async () => {
+    await msg.sendImage('photo.jpg');
+}, 2000);
+
+// Convenience Methods
+await msg.quickType('Text');      // 1 Sekunde
+await msg.normalType('Text');     // 2 Sekunden
+await msg.slowType('Text');       // 4 Sekunden
+await msg.realisticType('Text');  // Basierend auf Textlänge
+
+// Typing mit Mentions
+await msg.quickTypeWithMention('Hello @user!', userJid);
+await msg.normalTypeWithMention('Hi @user!', userJid);
+await msg.slowTypeWithMention('Hey @user!', userJid);
+```
+
+**Enhanced Typing Features:**
+- ✅ **Start/Stop Control** - Manuelles Typing-Control
+- ✅ **Timed Typing** - Automatisches Stoppen
+- ✅ **Auto-Stop** - Mit Duration-Parameter
+- ✅ **Type & Send** - Typing + Custom Function
+- ✅ **Convenience Methods** - Quick/Normal/Slow/Realistic
+- ✅ **Mention Support** - Typing mit Mentions kombiniert
+
+---
+
+## 📝 Enhanced Mention System
+
+### **Erweiterte Mention-Funktionen**
+
+```javascript
+// Mention mit Typing
+await msg.slowTypeWithMention('Hello @user!', userJid);
+await msg.quickTypeWithMention('Hi @user!', userJid);
+await msg.normalTypeWithMention('Hey @user!', userJid);
+
+// Mention All
+await msg.mentionAll('Important announcement!');
+
+// Reply mit Mention
+await msg.replyWithMention('Thanks @user!', userJid);
+
+// Check if mentioned
+const isMentioned = msg.isMentioned(userJid);
+
+// Get all mentions
+const mentions = msg.getMentions();
+```
+
+**Enhanced Mention Features:**
+- ✅ **Typing + Mention** - Kombiniert Typing mit Mentions
+- ✅ **Mention All** - Alle Gruppenmitglieder erwähnen
+- ✅ **Reply with Mention** - Antwort mit Mention
+- ✅ **Mention Check** - Prüfen ob User erwähnt wurde
+- ✅ **Get Mentions** - Alle Mentions aus Message
+
+---
+
+## 🔧 Enhanced Message Editing
+
+### **Erweiterte Edit-Funktionen**
+
+```javascript
+// Gesendete Nachricht bearbeiten
+const sentMsg = await msg.reply('Original text');
+await msg.editSent(sentMsg, 'Edited text');
+
+// Mit Error Handling
+try {
+    await msg.editSent(sentMsg, 'New text');
+    console.log('✅ Message edited');
+} catch (error) {
+    console.log('❌ Edit failed:', error.message);
+}
+```
+
+**Edit Features:**
+- ✅ **Edit Sent Messages** - Gesendete Nachrichten bearbeiten
+- ✅ **Error Handling** - Graceful Fehlerbehandlung
+- ✅ **Validation** - Prüft ob Message editierbar ist
+
+---
+
 ## 🎭 Typing Indicator
 
 ### **Manual Control**
@@ -3265,7 +3476,377 @@ const progress = ui.createProgress({
 - 📢 **Advanced Status Features** - Status Updates, Views
 - 💼 **Business Features** - Business Profile, Products, Payments
 - ⚙️ **System Features** - Backup, Restore, Export, Sync
-- 🖼️ **Profile Picture Features** - Get/Send Profile Pictures
+- 🖼️ **Profile Picture Features** - Get/Send Profile Picture
+
+---
+
+## 🛡️ Ultra-Robust Recovery Systems **NEU in v2.0.0!**
+
+### **Connection Recovery System**
+
+Automatische Wiederherstellung bei allen Verbindungsproblemen mit intelligenten Recovery-Strategien.
+
+```javascript
+// Connection Recovery aktivieren
+const recovery = client.connectionRecovery;
+
+// Health Monitoring starten
+recovery.startHealthMonitoring();
+
+// Recovery-Statistiken abrufen
+const stats = recovery.getStats();
+console.log(`Retry Count: ${stats.retryCount}`);
+console.log(`Last Error: ${stats.lastError}`);
+console.log(`Failure Count: ${stats.failureCount}`);
+
+// Recovery manuell initiieren
+await recovery.initiateRecovery(error);
+
+// Recovery-Status zurücksetzen
+recovery.reset();
+```
+
+**Recovery-Strategien (automatisch):**
+1. **Quick Reconnect** - Schnelle Wiederverbindung
+2. **Socket Reset** - Socket neu initialisieren
+3. **Session Repair** - Session reparieren
+4. **Full Restart** - Kompletter Neustart
+
+**Recovery Features:**
+- ✅ **Exponential Backoff** - Intelligente Wartezeiten
+- ✅ **Jitter Factor** - Verhindert Thundering Herd
+- ✅ **Health Checks** - Automatische Verbindungsprüfung
+- ✅ **Max Retries** - Konfigurierbare Retry-Limits
+- ✅ **Failure History** - Vollständige Fehlerhistorie
+- ✅ **Auto-Recovery** - Automatische Wiederherstellung
+
+**Konfiguration:**
+```javascript
+const client = new WhatsAppClient({
+    connectionRecovery: {
+        maxRetries: 10,
+        baseDelay: 2000,
+        maxDelay: 60000,
+        exponentialBackoff: true,
+        jitterFactor: 0.1,
+        healthCheckInterval: 30000
+    }
+});
+```
+
+---
+
+### **Auth Recovery System**
+
+Automatische Wiederherstellung bei Authentifizierungs-Problemen mit Smart Backup System.
+
+```javascript
+// Auth Recovery verwenden
+const authRecovery = client.authRecovery;
+
+// Auto-Backup starten (jede Stunde)
+authRecovery.startAutoBackup();
+
+// Smart Backup erstellen (nur wenn Session valid)
+await authRecovery.createSmartBackup();
+
+// Session-Korruption erkennen
+const issues = await authRecovery.detectCorruption();
+console.log(`Gefundene Probleme: ${issues.length}`);
+
+// Auto-Repair durchführen
+const result = await authRecovery.autoRepair();
+if (result.repaired) {
+    console.log(`✅ Repariert mit: ${result.method}`);
+}
+
+// Von bestem Backup wiederherstellen
+const recovered = await authRecovery.recoverFromBestBackup();
+
+// Recovery-Statistiken
+const stats = authRecovery.getStats();
+console.log(`Backups: ${stats.backupCount}`);
+console.log(`Auto-Backup: ${stats.autoBackupEnabled ? 'AN' : 'AUS'}`);
+```
+
+**Auth Recovery Features:**
+- ✅ **Smart Backups** - Nur valide Sessions werden gesichert
+- ✅ **Auto-Backup** - Stündliche automatische Backups
+- ✅ **Corruption Detection** - Erkennt beschädigte Sessions
+- ✅ **Auto-Repair** - Automatische Reparatur
+- ✅ **Backup History** - Mehrere Backup-Versionen
+- ✅ **Best Backup Recovery** - Wählt bestes Backup automatisch
+- ✅ **Max Backups** - Automatisches Cleanup alter Backups
+
+**Erkannte Probleme:**
+- Missing Auth Directory
+- Missing/Empty creds.json
+- Corrupted JSON
+- Invalid Structure
+- Temp Files
+- Permission Errors
+
+---
+
+### **Resource Manager**
+
+Verhindert Memory Leaks und verwaltet alle Ressourcen automatisch.
+
+```javascript
+// Resource Manager verwenden
+import { globalResourceManager } from 'waengine';
+
+// Ressource registrieren
+const resourceId = globalResourceManager.register('connection', socket, {
+    cleanup: async () => await socket.end(),
+    type: 'socket'
+});
+
+// Ressource freigeben
+await globalResourceManager.release(resourceId);
+
+// Alle Ressourcen eines Typs freigeben
+await globalResourceManager.releaseByType('socket');
+
+// Alle Ressourcen freigeben
+await globalResourceManager.releaseAll();
+
+// Statistiken abrufen
+const stats = globalResourceManager.getStats();
+console.log(`Aktive Ressourcen: ${stats.active}`);
+console.log(`Memory Usage: ${stats.memoryUsage}MB`);
+
+// Memory Leak Detection
+const leaks = globalResourceManager.detectLeaks();
+if (leaks.length > 0) {
+    console.log(`⚠️ ${leaks.length} potenzielle Memory Leaks gefunden`);
+}
+```
+
+**Resource Manager Features:**
+- ✅ **Automatic Cleanup** - Automatische Ressourcen-Freigabe
+- ✅ **Memory Leak Detection** - Erkennt Memory Leaks
+- ✅ **Resource Tracking** - Vollständiges Tracking
+- ✅ **Type-based Management** - Nach Typ verwalten
+- ✅ **Statistics** - Detaillierte Statistiken
+- ✅ **Health Monitoring** - Ressourcen-Gesundheit
+
+---
+
+## 🛡️ Anti-Ban Protection System
+
+Schützt Bots vor WhatsApp-Bans durch intelligente Verhaltens-Mimikry.
+
+```javascript
+// Anti-Ban Protection verwenden
+const antiBan = client.antiBan;
+
+// Geschützte Nachricht senden
+await antiBan.sendMessageProtected(jid, { text: 'Hello!' });
+
+// Geschützte Aktion ausführen
+await antiBan.performActionProtected(async () => {
+    await client.socket.groupSettingUpdate(groupId, 'announcement');
+}, 'group_settings');
+
+// Menschliches Tippen simulieren
+await antiBan.simulateHumanTyping('Lange Nachricht...');
+
+// Presence Updates
+await antiBan.updatePresence('available'); // online
+await antiBan.updatePresence('unavailable'); // offline
+
+// Nachricht "lesen" simulieren
+await antiBan.simulateReadMessage(jid, messageKey);
+
+// Hintergrund-Aktivität starten
+antiBan.startBackgroundActivity();
+
+// Features konfigurieren
+antiBan.setFeature('humanTyping', true);
+antiBan.setFeature('randomDelays', true);
+antiBan.setFeature('presenceUpdates', true);
+
+// Alle Features aktivieren (maximaler Schutz)
+antiBan.enableAllFeatures();
+
+// Statistiken anzeigen
+antiBan.printStats();
+const stats = antiBan.getStats();
+```
+
+**Anti-Ban Features:**
+- ✅ **Human Typing** - Simuliert menschliches Tippen (40-60 WPM)
+- ✅ **Random Delays** - Zufällige menschliche Verzögerungen
+- ✅ **Presence Updates** - Realistische Online/Offline Status
+- ✅ **Read Receipts** - Simuliert Lesen von Nachrichten
+- ✅ **Typing Indicator** - "tippt..." Anzeige
+- ✅ **Smart Browser** - Realistische Browser-Strings
+- ✅ **Background Activity** - Gelegentliche Idle-Aktivität
+- ✅ **Session Rotation** - Optional: Session-Rotation
+
+**Schutz-Level:**
+```javascript
+// Minimaler Schutz (schnell)
+antiBan.disable();
+
+// Standard Schutz (empfohlen)
+antiBan.enable();
+
+// Maximaler Schutz (sicher)
+antiBan.enableAllFeatures();
+antiBan.startBackgroundActivity();
+```
+
+**Statistiken:**
+- Messages Protected
+- Actions Protected
+- Bans Avoided
+- Suspicious Activity Prevented
+- Session Duration
+- Messages per Hour
+
+---
+
+## 🎨 Console Logger System
+
+Schöne animierte Console-Ausgabe ohne Spam.
+
+```javascript
+// Console Logger verwenden
+import { logger } from 'waengine';
+
+// Banner anzeigen
+logger.showBanner();
+
+// Setup Animation
+await logger.animateSetup();
+
+// QR-Code Animation
+await logger.animateQRGeneration('bot1', 1, 2);
+
+// Connection Animation
+await logger.animateConnection('bot1', true);
+
+// Device Pause
+await logger.showDevicePause(3);
+
+// Finale Zusammenfassung
+logger.showFinalSummary(['bot1', 'bot2'], true);
+
+// Dynamische Ready Message
+logger.showDynamicReadyMessage(client);
+
+// Progress Bar erstellen
+const bar = logger.createProgressBar('download', 'Downloading', 100);
+logger.updateProgressBar('download', 50);
+logger.completeProgressBar('download', '✅ Done');
+
+// Simple Logs
+logger.info('Information');
+logger.success('Erfolg!');
+logger.warning('Warnung!');
+logger.error('Fehler!');
+
+// Console leeren
+logger.clear();
+```
+
+**Console Logger Features:**
+- ✅ **Animated Banner** - Schöner Startup-Banner
+- ✅ **Progress Bars** - Animierte Fortschrittsbalken
+- ✅ **Setup Animation** - Schöne Setup-Sequenz
+- ✅ **QR Animation** - QR-Code Box mit Animation
+- ✅ **Connection Animation** - Verbindungs-Animation
+- ✅ **Device Status** - Schöne Device-Anzeige
+- ✅ **Dynamic Messages** - Dynamische Ready-Messages
+- ✅ **Color Support** - Farbige Ausgabe
+- ✅ **Silent Mode** - Komplett deaktivierbar
+
+---
+
+## 🔧 Device Manager
+
+Professionelles Multi-Device Management mit Load Balancing.
+
+```javascript
+// Device Manager verwenden
+import { DeviceManager } from 'waengine';
+
+const deviceManager = new DeviceManager({
+    maxDevices: 3,
+    loadBalancing: 'round-robin', // round-robin, random, least-used
+    syncEvents: true
+});
+
+// Devices hinzufügen
+await deviceManager.addDevice('bot1');
+await deviceManager.addDevice('bot2');
+await deviceManager.addDevice('bot3');
+
+// Einzelnes Device verbinden
+await deviceManager.connectDevice('bot1');
+
+// Alle Devices verbinden (sequenziell)
+await deviceManager.connectAll();
+
+// Device abrufen
+const client = deviceManager.getDevice('bot1');
+
+// Nächstes Device (Load Balancing)
+const nextClient = deviceManager.getNextDevice();
+
+// Smart Send (mit Load Balancing)
+await deviceManager.smartSend(chatId, { text: 'Hello!' }, {
+    strategy: 'load-balance' // load-balance, broadcast, failover
+});
+
+// Broadcast an alle Devices
+const results = await deviceManager.broadcast.sendMessage(chatId, {
+    text: 'Broadcast Message!'
+});
+
+// Send mit Failover
+await deviceManager.sendWithFailover(chatId, { text: 'Important!' });
+
+// Device Status
+const status = deviceManager.getStatus();
+console.log(`Active: ${status.activeDevices}/${status.totalDevices}`);
+
+// Health Check
+const health = deviceManager.getHealthCheck();
+console.log(`Health: ${health.healthPercentage}%`);
+
+// Events
+deviceManager.on('message', (data) => {
+    console.log(`Message from ${data.deviceId}`);
+});
+
+deviceManager.on('device.connected', ({ deviceId }) => {
+    console.log(`Device ${deviceId} connected`);
+});
+
+// Cleanup
+await deviceManager.cleanup();
+```
+
+**Device Manager Features:**
+- ✅ **Multi-Device Support** - Bis zu 3 Devices gleichzeitig
+- ✅ **Load Balancing** - Round-Robin, Random, Least-Used
+- ✅ **Smart Routing** - Intelligentes Message-Routing
+- ✅ **Broadcast System** - An alle Devices senden
+- ✅ **Failover** - Automatisches Failover bei Fehlern
+- ✅ **Event Sync** - Events von allen Devices
+- ✅ **Health Monitoring** - Device-Gesundheit überwachen
+- ✅ **Sequential Connect** - QR-Codes nacheinander
+- ✅ **Statistics** - Detaillierte Device-Statistiken
+
+**Load Balancing Strategien:**
+- **round-robin**: Gleichmäßige Verteilung
+- **random**: Zufällige Auswahl
+- **least-used**: Am wenigsten genutztes Device
+
+---s
 - 🤖 **EasyBot Integration** - Alle Features in EasyBot verfügbar
 
 ### **🎵 Advanced Media Features**

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 WhatsApp Multi Client
+Copyright © 2026 WAengine
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waengine",
-  "version": "1.8.9",
+  "version": "1.9.4",
   "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

@@ -937,13 +937,6 @@ export class WhatsAppClient {
                     if (messageTimestamp < this.connectionStartTime) {
                         this.ignoredMessagesCount++;
                         
-                        // Nur alle 10 Messages oder bei der ersten Message loggen
-                        if (this.ignoredMessagesCount === 1) {
-                            console.log(`📵 Offline Messages werden ignoriert...`);
-                        } else if (this.ignoredMessagesCount % 10 === 0) {
-                            console.log(`📵 ${this.ignoredMessagesCount} Offline Messages ignoriert...`);
-                        }
-                        
                         // Timer für finale Zusammenfassung zurücksetzen
                         if (this.offlineMessageTimer) {
                             clearTimeout(this.offlineMessageTimer);

package/src/message.js

@@ -587,6 +587,55 @@ export class Message {
         });
     }
 
+    // ===== DELETE MESSAGE - Auto-Delete System =====
+    async deleteMessage() {
+        try {
+            // Lösche die aktuelle Message
+            // Erstelle den richtigen Key basierend auf dem Sender
+            const sender = this.getSender();
+            const botJid = this.client.socket.user?.id;
+            const botNumber = botJid?.split('@')[0]?.split(':')[0];
+            const senderNumber = sender?.split('@')[0]?.split(':')[0];
+            const isFromBot = botNumber === senderNumber;
+            
+            const messageKey = {
+                remoteJid: this.from,
+                id: this.id,
+                fromMe: isFromBot
+            };
+            
+            // In Gruppen: participant hinzufügen wenn nicht vom Bot
+            if (this.isGroup && !isFromBot) {
+                messageKey.participant = sender;
+            }
+            
+            console.log('🗑️ Lösche Message:', {
+                id: this.id,
+                from: sender,
+                isFromBot: isFromBot,
+                isGroup: this.isGroup
+            });
+            
+            const result = await this.client.socket.sendMessage(this.from, {
+                delete: messageKey
+            });
+            
+            return { 
+                success: true, 
+                messageId: this.id,
+                sender: sender,
+                wasFromBot: isFromBot,
+                result: result 
+            };
+        } catch (error) {
+            console.error('❌ Fehler beim Löschen der Message:', error.message);
+            return { 
+                success: false, 
+                error: error.message 
+            };
+        }
+    }
+
     async deleteFromReply() {
         // Prüfe ob die Message eine Reply ist
         const contextInfo = this.raw.message?.extendedTextMessage?.contextInfo;