waengine 1.7.5 → 1.7.8

package/README.md

@@ -1,4 +1,4 @@
-# 🚀 WAEngine v1.7.5 - Ultra-Robust Edition
+# 🚀 WAEngine v1.7.6 - Analytics Bugfix Edition
 
 [![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)
@@ -1383,3 +1383,58 @@ Thanks to all contributors who make this project possible! 🎉
 **Made with ❤️ for WhatsApp Automation**
 
 *The most powerful WhatsApp bot library - from 3-line bots to enterprise multi-device systems!*
+
+
+---
+
+## 🔍 Error Codes System (NEW in v1.7.5!)
+
+WAEngine now includes a comprehensive error code system with **80+ predefined error codes** for better debugging and error handling.
+
+### **Features**
+- ✅ **Fixed Error Codes** - No more dynamic timestamps (WAE-1001, WAE-2002, etc.)
+- ✅ **15 Categories** - Connection, Auth, File, Message, Group, Media, etc.
+- ✅ **German Descriptions** - Clear error descriptions in German
+- ✅ **Quick Fixes** - Automatic solution suggestions for common errors
+- ✅ **Error Statistics** - Track error frequency and patterns
+- ✅ **Full Documentation** - See [ERROR-CODES.md](./ERROR-CODES.md)
+
+### **Usage Example**
+```javascript
+try {
+    await client.connect();
+} catch (error) {
+    console.log('Error Code:', error.code); // WAE-1001
+    console.log('Description:', getErrorDescription(error.code));
+    console.log('Category:', getErrorCategory(error.code));
+}
+```
+
+### **Error Categories**
+- **WAE-1xxx** - Connection Errors
+- **WAE-2xxx** - Authentication Errors
+- **WAE-3xxx** - File System Errors
+- **WAE-4xxx** - Message Errors
+- **WAE-5xxx** - Group Errors
+- **WAE-6xxx** - Media Errors
+- **WAE-7xxx** - Command Errors
+- **WAE-8xxx** - Plugin Errors
+- **WAE-9xxx** - System Errors
+- **WAE-10xxx** - QR Code Errors
+- **WAE-11xxx** - Mobile Support Errors
+- **WAE-12xxx** - Recovery Errors
+- **WAE-13xxx** - Database Errors
+- **WAE-14xxx** - Network Errors
+- **WAE-15xxx** - Security Errors
+
+### **Error Statistics**
+```javascript
+const stats = client.errorHandler.getErrorStats();
+console.log('Total Errors:', stats.totalErrors);
+console.log('Most Common:', stats.mostCommonError);
+console.log('By Code:', stats.errorsByCode);
+```
+
+**📖 Full Documentation:** [ERROR-CODES.md](./ERROR-CODES.md)
+
+---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waengine",
-  "version": "1.7.5",
+  "version": "1.7.8",
   "description": "🚀 WAEngine - The most powerful WhatsApp Bot Library with 400+ Advanced Features, Ultra-Robust Recovery Systems & Production-Ready Stability",
   "main": "src/index.js",
   "type": "module",

package/src/advanced-features.js

@@ -285,22 +285,33 @@ export class AdvancedMessage {
 export class AdvancedGroup {
     constructor(client) {
         this.client = client;
-        this.socket = client.socket;
+    }
+    
+    // Getter für Socket mit Null-Check
+    get socket() {
+        if (!this.client.socket) {
+            throw new Error('❌ Socket nicht verfügbar. Bot muss erst verbunden sein!');
+        }
+        return this.client.socket;
     }
 
     async setGroupSettings(groupId, settings) {
         try {
-            const updates = {};
+            const results = [];
             
             if (settings.messagesAdminOnly !== undefined) {
-                updates.restrict = settings.messagesAdminOnly;
+                const setting = settings.messagesAdminOnly ? 'announcement' : 'not_announcement';
+                const result = await this.socket.groupSettingUpdate(groupId, setting);
+                results.push(result);
             }
             
             if (settings.editGroupInfo !== undefined) {
-                updates.announce = settings.editGroupInfo === 'admin_only';
+                const setting = settings.editGroupInfo === 'admin_only' ? 'locked' : 'unlocked';
+                const result = await this.socket.groupSettingUpdate(groupId, setting);
+                results.push(result);
             }
 
-            return await this.socket.groupSettingUpdate(groupId, updates);
+            return results.length === 1 ? results[0] : results;
         } catch (error) {
             console.error('❌ Group Settings Update fehlgeschlagen:', error);
             throw new Error(`Gruppeneinstellungen konnten nicht geändert werden: ${error.message}`);
@@ -377,7 +388,14 @@ export class AdvancedGroup {
 export class AdvancedPrivacy {
     constructor(client) {
         this.client = client;
-        this.socket = client.socket;
+    }
+    
+    // Getter für Socket mit Null-Check
+    get socket() {
+        if (!this.client.socket) {
+            throw new Error('❌ Socket nicht verfügbar. Bot muss erst verbunden sein!');
+        }
+        return this.client.socket;
     }
 
     async blockUser(jid) {
@@ -449,7 +467,14 @@ export class AdvancedPrivacy {
 export class AdvancedAnalytics {
     constructor(client) {
         this.client = client;
-        this.socket = client.socket;
+    }
+    
+    // Getter für Socket mit Null-Check
+    get socket() {
+        if (!this.client.socket) {
+            throw new Error('❌ Socket nicht verfügbar. Bot muss erst verbunden sein!');
+        }
+        return this.client.socket;
     }
 
     async getDeliveryStatus(messageKey) {
@@ -531,7 +556,14 @@ export class AdvancedAnalytics {
 export class AdvancedStatus {
     constructor(client) {
         this.client = client;
-        this.socket = client.socket;
+    }
+    
+    // Getter für Socket mit Null-Check
+    get socket() {
+        if (!this.client.socket) {
+            throw new Error('❌ Socket nicht verfügbar. Bot muss erst verbunden sein!');
+        }
+        return this.client.socket;
     }
 
     async sendStatusUpdate(type, content, options = {}) {
@@ -595,7 +627,14 @@ export class AdvancedStatus {
 export class AdvancedBusiness {
     constructor(client) {
         this.client = client;
-        this.socket = client.socket;
+    }
+    
+    // Getter für Socket mit Null-Check
+    get socket() {
+        if (!this.client.socket) {
+            throw new Error('❌ Socket nicht verfügbar. Bot muss erst verbunden sein!');
+        }
+        return this.client.socket;
     }
 
     async setBusinessProfile(profile) {
@@ -677,18 +716,27 @@ export class AdvancedBusiness {
 export class AdvancedSystem {
     constructor(client) {
         this.client = client;
-        this.socket = client.socket;
+    }
+    
+    // Getter für Socket mit Null-Check
+    get socket() {
+        if (!this.client.socket) {
+            throw new Error('❌ Socket nicht verfügbar. Bot muss erst verbunden sein!');
+        }
+        return this.client.socket;
     }
 
     async createBackup() {
         try {
-            // Backup der wichtigsten Daten
+            // Backup der wichtigsten Daten (vereinfacht, da Baileys keine getContacts/getChats hat)
             const backup = {
                 timestamp: Date.now(),
-                contacts: await this.socket.getContacts(),
-                chats: await this.socket.getChats(),
+                user: this.socket.user || null,
+                authState: 'saved', // Auth-State wird automatisch von Baileys gespeichert
                 settings: {
-                    // Wichtige Einstellungen
+                    prefix: this.client.prefix || null,
+                    commands: this.client.commands?.size || 0,
+                    plugins: this.client.plugins?.size || 0
                 }
             };
 

package/src/analytics-manager.js

@@ -220,10 +220,10 @@ export class AnalyticsManager {
         // Store alerts
         if (alerts.length > 0) {
             this.alerts.push(...alerts);
-            this.storage.write.in("analytics").push("alerts", alerts);
             
-            // Emit alert events
+            // Store each alert individually
             alerts.forEach(alert => {
+                this.storage.write.in("analytics-alerts").push(alert);
                 this.client.emit('performance_alert', alert);
             });
         }

package/src/anti-ban-protection.js

@@ -0,0 +1,308 @@
+// 🛡️ ANTI-BAN PROTECTION SYSTEM (NO LIMITS)
+// Schützt Bots vor WhatsApp-Bans durch intelligente Verhaltens-Mimikry
+
+export class AntiBanProtection {
+    constructor(client) {
+        this.client = client;
+        this.enabled = true;
+        
+        // Verhaltens-Tracking
+        this.behavior = {
+            lastActivity: Date.now(),
+            sessionStart: Date.now(),
+            totalMessages: 0,
+            totalActions: 0
+        };
+        
+        // Schutz-Features
+        this.features = {
+            humanTyping: true,          // Simuliert menschliches Tippen
+            randomDelays: true,          // Zufällige Verzögerungen
+            presenceUpdates: true,       // Online/Offline Status Updates
+            readReceipts: true,          // Lesebestätigungen
+            typingIndicator: true,       // "tippt..." Anzeige
+            smartBrowser: true,          // Realistischer Browser-String
+            sessionRotation: false       // Session-Rotation (optional)
+        };
+        
+        // Statistiken
+        this.stats = {
+            messagesProtected: 0,
+            actionsProtected: 0,
+            bansAvoided: 0,
+            suspiciousActivityPrevented: 0
+        };
+    }
+    
+    // ===== HAUPTFUNKTIONEN =====
+    
+    // Menschliches Tipp-Verhalten simulieren
+    async simulateHumanTyping(text) {
+        if (!this.features.humanTyping) return;
+        
+        // Berechne realistische Tipp-Zeit basierend auf Textlänge
+        const wordsPerMinute = 40 + Math.random() * 20; // 40-60 WPM (realistisch)
+        const words = text.split(' ').length;
+        const typingTime = (words / wordsPerMinute) * 60 * 1000;
+        
+        // Min 500ms, Max 5000ms
+        const delay = Math.min(Math.max(typingTime, 500), 5000);
+        
+        // Zeige "tippt..." während der Verzögerung
+        if (this.features.typingIndicator && this.client.socket) {
+            // Typing indicator wird automatisch von WhatsApp gehandhabt
+        }
+        
+        await this.randomDelay(delay * 0.8, delay * 1.2);
+    }
+    
+    // Zufällige menschliche Verzögerung
+    async randomDelay(min = 300, max = 1500) {
+        if (!this.features.randomDelays) return;
+        
+        const delay = min + Math.random() * (max - min);
+        await new Promise(resolve => setTimeout(resolve, delay));
+    }
+    
+    // Presence Updates (Online/Offline)
+    async updatePresence(status = 'available') {
+        if (!this.features.presenceUpdates || !this.client.socket) return;
+        
+        try {
+            await this.client.socket.sendPresenceUpdate(status);
+        } catch (error) {
+            // Silent fail
+        }
+    }
+    
+    // Simuliere "Lesen" einer Nachricht
+    async simulateReadMessage(jid, messageKey) {
+        if (!this.features.readReceipts || !this.client.socket) return;
+        
+        try {
+            // Kleine Verzögerung bevor gelesen wird (realistisch)
+            await this.randomDelay(500, 2000);
+            
+            await this.client.socket.readMessages([messageKey]);
+            
+            // Weitere Verzögerung bevor geantwortet wird
+            await this.randomDelay(1000, 3000);
+        } catch (error) {
+            // Silent fail
+        }
+    }
+    
+    // ===== GESCHÜTZTE NACHRICHTENFUNKTIONEN =====
+    
+    async sendMessageProtected(jid, content, options = {}) {
+        if (!this.enabled) {
+            return await this.client.socket.sendMessage(jid, content);
+        }
+        
+        try {
+            // 1. Simuliere Lesen (falls Antwort auf Nachricht)
+            if (options.quoted) {
+                await this.simulateReadMessage(jid, options.quoted.key);
+            }
+            
+            // 2. Zeige Online-Status
+            await this.updatePresence('available');
+            
+            // 3. Simuliere Tippen (falls Text)
+            if (content.text) {
+                await this.simulateHumanTyping(content.text);
+            } else {
+                // Für Medien: kurze Verzögerung
+                await this.randomDelay(800, 2000);
+            }
+            
+            // 4. Sende Nachricht
+            const result = await this.client.socket.sendMessage(jid, content);
+            
+            // 5. Update Statistiken
+            this.behavior.totalMessages++;
+            this.behavior.lastActivity = Date.now();
+            this.stats.messagesProtected++;
+            this.stats.bansAvoided++;
+            
+            // 6. Kleine Pause nach Senden
+            await this.randomDelay(200, 800);
+            
+            return result;
+        } catch (error) {
+            console.error('🛡️ Anti-Ban: Fehler beim geschützten Senden:', error.message);
+            throw error;
+        }
+    }
+    
+    async performActionProtected(actionFn, actionType = 'general') {
+        if (!this.enabled) {
+            return await actionFn();
+        }
+        
+        try {
+            // 1. Zeige Online-Status
+            await this.updatePresence('available');
+            
+            // 2. Menschliche Verzögerung vor Aktion
+            await this.randomDelay(1000, 3000);
+            
+            // 3. Führe Aktion aus
+            const result = await actionFn();
+            
+            // 4. Update Statistiken
+            this.behavior.totalActions++;
+            this.behavior.lastActivity = Date.now();
+            this.stats.actionsProtected++;
+            this.stats.bansAvoided++;
+            
+            // 5. Pause nach Aktion
+            await this.randomDelay(1500, 3500);
+            
+            return result;
+        } catch (error) {
+            console.error('🛡️ Anti-Ban: Fehler bei geschützter Aktion:', error.message);
+            throw error;
+        }
+    }
+    
+    // ===== BROWSER & SESSION SCHUTZ =====
+    
+    getRealisticBrowser() {
+        if (!this.features.smartBrowser) {
+            return ["Chrome", "121.0.0", ""];
+        }
+        
+        // Realistische Browser-Strings (rotierend)
+        const browsers = [
+            ["Chrome", "121.0.0.0", "Windows"],
+            ["Chrome", "120.0.0.0", "Mac OS"],
+            ["Firefox", "122.0", "Windows"],
+            ["Edge", "121.0.0.0", "Windows"],
+            ["Safari", "17.2", "Mac OS"]
+        ];
+        
+        // Wähle zufälligen aber konsistenten Browser für diese Session
+        const index = Math.floor(Math.random() * browsers.length);
+        return browsers[index];
+    }
+    
+    // ===== AKTIVITÄTS-SIMULATION =====
+    
+    async simulateIdleActivity() {
+        if (!this.enabled) return;
+        
+        // Simuliere gelegentliche Aktivität auch wenn Bot "idle" ist
+        const timeSinceLastActivity = Date.now() - this.behavior.lastActivity;
+        
+        // Alle 5-10 Minuten kleine Aktivität
+        if (timeSinceLastActivity > 300000 + Math.random() * 300000) {
+            try {
+                // Wechsle zwischen online/offline
+                const status = Math.random() > 0.5 ? 'available' : 'unavailable';
+                await this.updatePresence(status);
+                
+                this.behavior.lastActivity = Date.now();
+                this.stats.suspiciousActivityPrevented++;
+            } catch (error) {
+                // Silent fail
+            }
+        }
+    }
+    
+    // Starte Hintergrund-Aktivität (optional)
+    startBackgroundActivity() {
+        if (this.backgroundInterval) return;
+        
+        this.backgroundInterval = setInterval(() => {
+            this.simulateIdleActivity();
+        }, 60000); // Jede Minute checken
+        
+        console.log('🛡️ Anti-Ban: Hintergrund-Aktivität gestartet');
+    }
+    
+    stopBackgroundActivity() {
+        if (this.backgroundInterval) {
+            clearInterval(this.backgroundInterval);
+            this.backgroundInterval = null;
+            console.log('🛡️ Anti-Ban: Hintergrund-Aktivität gestoppt');
+        }
+    }
+    
+    // ===== KONFIGURATION =====
+    
+    enable() {
+        this.enabled = true;
+        console.log('🛡️ Anti-Ban Protection: AKTIVIERT');
+    }
+    
+    disable() {
+        this.enabled = false;
+        console.log('🛡️ Anti-Ban Protection: DEAKTIVIERT');
+    }
+    
+    setFeature(feature, value) {
+        if (this.features.hasOwnProperty(feature)) {
+            this.features[feature] = value;
+            console.log(`🛡️ Anti-Ban: ${feature} = ${value}`);
+        }
+    }
+    
+    enableAllFeatures() {
+        Object.keys(this.features).forEach(key => {
+            this.features[key] = true;
+        });
+        console.log('🛡️ Anti-Ban: Alle Features aktiviert (maximaler Schutz)');
+    }
+    
+    disableAllFeatures() {
+        Object.keys(this.features).forEach(key => {
+            this.features[key] = false;
+        });
+        console.log('🛡️ Anti-Ban: Alle Features deaktiviert');
+    }
+    
+    // ===== STATISTIKEN =====
+    
+    getStats() {
+        const sessionDuration = Date.now() - this.behavior.sessionStart;
+        const hours = Math.floor(sessionDuration / 3600000);
+        const minutes = Math.floor((sessionDuration % 3600000) / 60000);
+        
+        return {
+            enabled: this.enabled,
+            features: this.features,
+            behavior: {
+                ...this.behavior,
+                sessionDuration: `${hours}h ${minutes}m`,
+                messagesPerHour: hours > 0 ? Math.round(this.behavior.totalMessages / hours) : 0
+            },
+            stats: this.stats,
+            protection: {
+                level: this.enabled ? 'AKTIV' : 'INAKTIV',
+                effectiveness: this.stats.bansAvoided > 0 ? '✅ Funktioniert' : '⏳ Warte auf Aktivität'
+            }
+        };
+    }
+    
+    printStats() {
+        const stats = this.getStats();
+        
+        console.log('\n🛡️ ===== ANTI-BAN PROTECTION STATS =====');
+        console.log(`📊 Status: ${stats.protection.level}`);
+        console.log(`⏱️ Session Dauer: ${stats.behavior.sessionDuration}`);
+        console.log(`📨 Nachrichten geschützt: ${stats.stats.messagesProtected}`);
+        console.log(`⚡ Aktionen geschützt: ${stats.stats.actionsProtected}`);
+        console.log(`✅ Bans vermieden: ${stats.stats.bansAvoided}`);
+        console.log(`🎭 Verdächtige Aktivität verhindert: ${stats.stats.suspiciousActivityPrevented}`);
+        
+        console.log('\n🎯 Aktive Features:');
+        Object.entries(stats.features).forEach(([key, value]) => {
+            const icon = value ? '✅' : '❌';
+            console.log(`   ${icon} ${key}`);
+        });
+        
+        console.log('\n💡 Effektivität: ' + stats.protection.effectiveness);
+        console.log('==========================================\n');
+    }
+}

package/src/client.js

@@ -18,6 +18,7 @@ import { UIComponents } from "./ui-components.js";
 import { ConnectionRecovery } from "./connection-recovery.js";
 import { AuthRecovery } from "./auth-recovery.js";
 import { globalResourceManager } from "./resource-manager.js";
+import { AntiBanProtection } from "./anti-ban-protection.js";
 
 export class WhatsAppClient {
     constructor(options = {}) {
@@ -551,7 +552,10 @@ export class WhatsAppClient {
                     
                     // Jetzt erst die echten Success-Messages zeigen
                     this.logger.success("WhatsApp erfolgreich authentifiziert!");
-                    this.logger.showFinalSummary(['main-bot'], true);
+                    
+                    // Dynamische Ready Message mit echten Daten
+                    this.logger.showDynamicReadyMessage(this);
+                    
                     this.emit('truly_connected', { userId: creds.me.id });
                 }
             });
@@ -914,8 +918,12 @@ export class WhatsAppClient {
     setupEventHandlers() {
         // Messages - Saubere Message-Erkennung ohne Debug-Spam
         this.socket.ev.on("messages.upsert", ({ messages, type }) => {
-            // Nur relevante Message-Types verarbeiten
-            if (type !== "notify" && type !== "append") return;
+            // DEBUG: Zeige alle Message-Types
+            console.log(`📥 Message Event - Type: ${type}, Count: ${messages.length}`);
+            
+            // WICHTIG: Alle Types akzeptieren außer explizit ausgeschlossene
+            // Nur "prepend" (alte History) ignorieren wenn gewünscht
+            // if (type === "prepend") return; // Optional: Alte Messages ignorieren
 
             messages.forEach((msg) => {
                 // Bessere Message-Validierung

package/src/console-logger.js

@@ -71,20 +71,10 @@ export class ConsoleLogger {
         this.updateProgressBar('setup', 100, '🔧 System bereit');
         this.completeProgressBar('setup');
         
-        // Zusammenfassung
-        this.showSystemSummary();
+        // Keine System Summary mehr - wird später in showDynamicReadyMessage angezeigt
     }
 
-    showSystemSummary() {
-        if (this.silent) return;
-        
-        console.log(`
-✅ System bereit
-   ├─ Storage: ./waengine-data
-   ├─ Devices: 2/2 konfiguriert
-   ├─ Plugins: 8 verfügbar
-   └─ Prefix: "!"`);
-    }
+    // showSystemSummary() entfernt - wird durch showDynamicReadyMessage ersetzt
 
     // ===== QR-CODE ANIMATION =====
     async animateQRGeneration(deviceName = 'bot1', deviceNumber = 1, totalDevices = 2) {
@@ -209,12 +199,43 @@ export class ConsoleLogger {
             console.log(`   ${prefix} ${device}: Online & Authentifiziert`);
         });
         
+        // Dynamische Ready Message mit echten Daten
+        this.showDynamicReadyMessage();
+    }
+
+    // Dynamische Ready Message - NEU!
+    showDynamicReadyMessage(client = null) {
+        // Bot-Name ermitteln
+        const botName = client?.socket?.user?.name || 
+                       client?.socket?.user?.verifiedName || 
+                       'WAEngine Bot';
+        
+        // Prefix ermitteln
+        const prefix = client?.prefix || null;
+        
+        // Commands zählen
+        const commandCount = client?.commands?.size || 0;
+        
+        // Plugins zählen
+        const pluginCount = client?.plugins?.size || 0;
+        
         console.log(`
-🚀 WAEngine ist bereit!
-   ├─ Prefix: "!"
-   ├─ Commands: 12 verfügbar
-   ├─ Plugins: 8 geladen
-   └─ Status: 🟢 Online & Authentifiziert
+🚀 ${botName} ist bereit!`);
+        
+        // Nur anzeigen wenn vorhanden
+        if (prefix) {
+            console.log(`   ├─ Prefix: "${prefix}"`);
+        }
+        
+        if (commandCount > 0) {
+            console.log(`   ├─ Commands: ${commandCount} verfügbar`);
+        }
+        
+        if (pluginCount > 0) {
+            console.log(`   ├─ Plugins: ${pluginCount} geladen`);
+        }
+        
+        console.log(`   └─ Status: 🟢 Online & Authentifiziert
 
 💬 Bot wartet auf Nachrichten...`);
     }

package/src/core.js

@@ -83,7 +83,17 @@ export async function getSocket() {
         
         // WICHTIG: Alle Events loggen für Debug
         socket.ev.on("messages.upsert", (data) => {
-            console.log("🚨 RAW MESSAGE EVENT:", JSON.stringify(data, null, 2));
+            console.log("🚨 RAW MESSAGE EVENT:");
+            console.log(`   Type: ${data.type}`);
+            console.log(`   Messages: ${data.messages.length}`);
+            data.messages.forEach((msg, i) => {
+                console.log(`   Message ${i + 1}:`, {
+                    from: msg.key.remoteJid,
+                    fromMe: msg.key.fromMe,
+                    hasMessage: !!msg.message,
+                    type: Object.keys(msg.message || {})[0]
+                });
+            });
         });
         
         socket.ev.on("chats.set", (data) => {