waengine 1.7.5 → 1.7.8

package/src/error-handler.js

@@ -1,4 +1,5 @@
 import { ConsoleLogger } from "./console-logger.js";
+import { ERROR_CODES, getErrorDescription, createError, getErrorCategory } from "./error-codes.js";
 
 export class ErrorHandler {
     constructor(options = {}) {
@@ -15,48 +16,124 @@ export class ErrorHandler {
         this.logger = new ConsoleLogger({ silent: false });
         this.errorCount = 0;
         this.lastError = null;
+        this.errorStats = new Map(); // Track error frequency by code
     }
     
     /**
-     * Handle any error with support information
+     * Handle any error with support information and error codes
      */
     handleError(error, context = {}) {
         this.errorCount++;
+        
+        // Extract or assign error code
+        const errorCode = error.code || context.errorCode || this.detectErrorCode(error, context);
+        const errorDescription = getErrorDescription(errorCode);
+        const errorCategory = getErrorCategory(errorCode);
+        
+        // Track error statistics
+        if (!this.errorStats.has(errorCode)) {
+            this.errorStats.set(errorCode, { count: 0, firstSeen: new Date(), lastSeen: null });
+        }
+        const stats = this.errorStats.get(errorCode);
+        stats.count++;
+        stats.lastSeen = new Date();
+        
         this.lastError = {
             error: error,
+            errorCode: errorCode,
+            errorDescription: errorDescription,
+            errorCategory: errorCategory,
             context: context,
             timestamp: new Date(),
-            count: this.errorCount
+            count: this.errorCount,
+            occurrences: stats.count
         };
         
-        // Log error details
+        // Log error details with error code
         if (this.options.logErrors) {
             console.error(`\n❌ WAEngine Error #${this.errorCount}:`);
+            console.error(`   Error Code: ${errorCode}`);
+            console.error(`   Category: ${errorCategory}`);
+            console.error(`   Description: ${errorDescription}`);
             console.error(`   Context: ${context.action || 'Unknown'}`);
             console.error(`   Message: ${error.message}`);
             if (context.details) {
                 console.error(`   Details: ${context.details}`);
             }
             console.error(`   Time: ${new Date().toLocaleString()}`);
+            if (stats.count > 1) {
+                console.error(`   Occurrences: ${stats.count} (First: ${stats.firstSeen.toLocaleString()})`);
+            }
         }
         
         // Show support information
         if (this.options.showSupportInfo) {
-            this.showSupportInfo(error, context);
+            this.showSupportInfo(error, context, errorCode);
         }
         
         // Send error report (if enabled)
         if (this.options.sendErrorReports) {
-            this.sendErrorReport(error, context);
+            this.sendErrorReport(error, context, errorCode);
         }
         
         return this.lastError;
     }
     
     /**
-     * Show support contact information
+     * Detect error code from error message and context
      */
-    showSupportInfo(error, context) {
+    detectErrorCode(error, context) {
+        const message = error.message?.toLowerCase() || '';
+        const action = context.action?.toLowerCase() || '';
+        
+        // Connection errors - check timeout BEFORE general connection
+        if (message.includes('timeout')) {
+            return ERROR_CODES.CONNECTION.TIMEOUT;
+        }
+        if (message.includes('connection') || message.includes('socket') || message.includes('econnrefused')) {
+            return ERROR_CODES.CONNECTION.FAILED;
+        }
+        if (message.includes('disconnected') || message.includes('closed')) {
+            return ERROR_CODES.CONNECTION.LOST;
+        }
+        
+        // Auth errors
+        if (message.includes('auth') || message.includes('creds') || message.includes('credentials')) {
+            return ERROR_CODES.AUTH.FAILED;
+        }
+        if (message.includes('qr') || action.includes('qr')) {
+            return ERROR_CODES.QR.GENERATION_FAILED;
+        }
+        if (message.includes('session') || message.includes('corrupted')) {
+            return ERROR_CODES.AUTH.SESSION_CORRUPTED;
+        }
+        
+        // File errors
+        if (message.includes('enoent') || message.includes('file not found')) {
+            return ERROR_CODES.FILE.NOT_FOUND;
+        }
+        if (message.includes('eperm') || message.includes('permission')) {
+            return ERROR_CODES.FILE.PERMISSION_DENIED;
+        }
+        
+        // Message errors
+        if (action.includes('message') || action.includes('send')) {
+            return ERROR_CODES.MESSAGE.SEND_FAILED;
+        }
+        
+        // Plugin errors
+        if (action.includes('plugin')) {
+            return ERROR_CODES.PLUGIN.LOAD_FAILED;
+        }
+        
+        // Default unknown error
+        return ERROR_CODES.SYSTEM.UNKNOWN_ERROR;
+    }
+    
+    /**
+     * Show support contact information with error code
+     */
+    showSupportInfo(error, context, errorCode) {
         console.log("\n" + "=".repeat(50));
         console.log("❌ FEHLER AUFGETRETEN!");
         console.log("=".repeat(50));
@@ -69,54 +146,131 @@ export class ErrorHandler {
         }
         
         console.log(`\n🔍 Fehler-Details:`);
+        console.log(`   • Error Code: ${errorCode}`);
+        console.log(`   • Beschreibung: ${getErrorDescription(errorCode)}`);
+        console.log(`   • Kategorie: ${getErrorCategory(errorCode)}`);
         console.log(`   • Fehler: ${error.message}`);
         console.log(`   • WAEngine Version: ${this.getWAEngineVersion()}`);
-        console.log(`   • Error ID: WAE-${Date.now()}-${this.errorCount}`);
         
         // Kurze, hilfreiche Lösungsvorschläge
         console.log(`\n💡 Schnelle Lösung:`);
-        this.showQuickFixes(error, context);
+        this.showQuickFixes(error, context, errorCode);
         
+        console.log(`\n📖 Mehr Infos: Siehe ERROR-CODES.md für Details zu ${errorCode}`);
         console.log("=".repeat(50) + "\n");
     }
     
     /**
-     * Show quick fixes for common errors
+     * Show quick fixes for common errors based on error code
      */
-    showQuickFixes(error, context) {
-        const message = error.message.toLowerCase();
+    showQuickFixes(error, context, errorCode) {
+        const fixes = this.getQuickFixForErrorCode(errorCode);
         
-        if (message.includes('qr') || message.includes('auth')) {
-            console.log("   → Lösche 'auth' Ordner und scanne QR neu");
-        }
-        else if (message.includes('connection') || message.includes('socket')) {
-            console.log("   → Prüfe Internetverbindung und starte Bot neu");
-        }
-        else if (message.includes('sharp') || message.includes('sticker')) {
-            console.log("   → Installiere Sharp: npm install sharp");
-        }
-        else if (message.includes('plugin')) {
-            console.log("   → Installiere Dependencies: npm install --force");
-        }
-        else if (message.includes('permission') || message.includes('admin')) {
-            console.log("   → Bot braucht Admin-Rechte in der Gruppe");
-        }
-        else {
-            console.log("   → Starte Bot neu oder kontaktiere Support");
+        if (fixes.length > 0) {
+            fixes.forEach(fix => console.log(`   → ${fix}`));
+        } else {
+            // Fallback to message-based detection
+            const message = error.message.toLowerCase();
+            
+            if (message.includes('qr') || message.includes('auth')) {
+                console.log("   → Lösche 'auth' Ordner und scanne QR neu");
+            }
+            else if (message.includes('connection') || message.includes('socket')) {
+                console.log("   → Prüfe Internetverbindung und starte Bot neu");
+            }
+            else if (message.includes('sharp') || message.includes('sticker')) {
+                console.log("   → Installiere Sharp: npm install sharp");
+            }
+            else if (message.includes('plugin')) {
+                console.log("   → Installiere Dependencies: npm install --force");
+            }
+            else if (message.includes('permission') || message.includes('admin')) {
+                console.log("   → Bot braucht Admin-Rechte in der Gruppe");
+            }
+            else {
+                console.log("   → Starte Bot neu oder kontaktiere Support");
+            }
         }
     }
     
     /**
-     * Send error report to support (if enabled)
+     * Get quick fixes for specific error codes
      */
-    async sendErrorReport(error, context) {
+    getQuickFixForErrorCode(errorCode) {
+        const fixes = {
+            [ERROR_CODES.CONNECTION.FAILED]: [
+                "Prüfe deine Internetverbindung",
+                "Starte den Bot neu",
+                "Prüfe ob WhatsApp Server erreichbar sind"
+            ],
+            [ERROR_CODES.CONNECTION.TIMEOUT]: [
+                "Erhöhe das Connection Timeout in den Optionen",
+                "Prüfe deine Netzwerkgeschwindigkeit",
+                "Versuche es später erneut"
+            ],
+            [ERROR_CODES.AUTH.FAILED]: [
+                "Lösche den 'auth' Ordner",
+                "Scanne den QR-Code erneut",
+                "Stelle sicher dass WhatsApp auf dem Handy aktiv ist"
+            ],
+            [ERROR_CODES.AUTH.SESSION_CORRUPTED]: [
+                "Lösche den 'auth' Ordner komplett",
+                "Starte den Bot neu und scanne QR-Code",
+                "Prüfe ob genug Speicherplatz vorhanden ist"
+            ],
+            [ERROR_CODES.QR.GENERATION_FAILED]: [
+                "Installiere qrcode-terminal: npm install qrcode-terminal",
+                "Vergrößere dein Terminal-Fenster",
+                "Verwende Browser-QR statt Terminal-QR"
+            ],
+            [ERROR_CODES.FILE.NOT_FOUND]: [
+                "Prüfe ob die Datei existiert",
+                "Prüfe den Dateipfad",
+                "Stelle sicher dass die Datei nicht verschoben wurde"
+            ],
+            [ERROR_CODES.FILE.PERMISSION_DENIED]: [
+                "Führe den Bot mit Administrator-Rechten aus",
+                "Prüfe Datei-Berechtigungen",
+                "Schließe andere Programme die die Datei verwenden"
+            ],
+            [ERROR_CODES.MESSAGE.SEND_FAILED]: [
+                "Prüfe ob die Verbindung aktiv ist",
+                "Prüfe ob die Nummer/Gruppe existiert",
+                "Versuche es erneut"
+            ],
+            [ERROR_CODES.PLUGIN.LOAD_FAILED]: [
+                "Installiere Plugin-Dependencies: npm install",
+                "Prüfe Plugin-Konfiguration",
+                "Prüfe Plugin-Kompatibilität mit WAEngine Version"
+            ],
+            [ERROR_CODES.MOBILE.DETECTION_FAILED]: [
+                "Aktualisiere @whiskeysockets/baileys",
+                "Prüfe Mobile-Support Konfiguration",
+                "Verwende Desktop-Modus als Fallback"
+            ]
+        };
+        
+        return fixes[errorCode] || [];
+    }
+    
+    /**
+     * Send error report to support (if enabled) with error code
+     */
+    async sendErrorReport(error, context, errorCode) {
         try {
+            const stats = this.errorStats.get(errorCode);
+            
             const report = {
-                errorId: `WAE-${Date.now()}-${this.errorCount}`,
+                errorCode: errorCode,
+                errorDescription: getErrorDescription(errorCode),
+                errorCategory: getErrorCategory(errorCode),
                 message: error.message,
                 stack: error.stack,
                 context: context,
-                version: this.getWAEngineVersion(),
+                occurrences: stats?.count || 1,
+                firstSeen: stats?.firstSeen?.toISOString(),
+                lastSeen: stats?.lastSeen?.toISOString(),
+                version: await this.getWAEngineVersion(),
                 nodeVersion: process.version,
                 platform: process.platform,
                 timestamp: new Date().toISOString()
@@ -129,7 +283,7 @@ export class ErrorHandler {
             //     body: JSON.stringify(report)
             // });
             
-            console.log("📤 Fehlerbericht automatisch gesendet (Error ID: " + report.errorId + ")");
+            console.log(`📤 Fehlerbericht automatisch gesendet (Error Code: ${errorCode})`);
         } catch (reportError) {
             console.log("⚠️  Fehlerbericht konnte nicht gesendet werden");
         }
@@ -154,8 +308,17 @@ export class ErrorHandler {
      * Handle connection errors specifically
      */
     handleConnectionError(error, reconnectAttempt = 0) {
+        // Assign specific error code based on error type
+        let errorCode = ERROR_CODES.CONNECTION.FAILED;
+        if (error.message?.includes('timeout')) {
+            errorCode = ERROR_CODES.CONNECTION.TIMEOUT;
+        } else if (error.message?.includes('lost') || error.message?.includes('closed')) {
+            errorCode = ERROR_CODES.CONNECTION.LOST;
+        }
+        
         return this.handleError(error, {
             action: 'connection',
+            errorCode: errorCode,
             reconnectAttempt: reconnectAttempt,
             details: `Wiederverbindungsversuch ${reconnectAttempt}`
         });
@@ -165,8 +328,16 @@ export class ErrorHandler {
      * Handle plugin errors specifically
      */
     handlePluginError(error, pluginName) {
+        let errorCode = ERROR_CODES.PLUGIN.LOAD_FAILED;
+        if (error.message?.includes('not found')) {
+            errorCode = ERROR_CODES.PLUGIN.NOT_FOUND;
+        } else if (error.message?.includes('config')) {
+            errorCode = ERROR_CODES.PLUGIN.INVALID_CONFIG;
+        }
+        
         return this.handleError(error, {
             action: 'plugin',
+            errorCode: errorCode,
             plugin: pluginName,
             details: `Plugin '${pluginName}' Fehler`
         });
@@ -178,6 +349,7 @@ export class ErrorHandler {
     handleCommandError(error, command, userId) {
         return this.handleError(error, {
             action: 'command',
+            errorCode: ERROR_CODES.COMMAND.EXECUTION_FAILED,
             command: command,
             user: userId,
             details: `Command '${command}' Fehler`
@@ -188,20 +360,41 @@ export class ErrorHandler {
      * Handle message errors specifically
      */
     handleMessageError(error, messageType) {
+        let errorCode = ERROR_CODES.MESSAGE.SEND_FAILED;
+        if (error.message?.includes('media')) {
+            errorCode = ERROR_CODES.MESSAGE.MEDIA_UPLOAD_FAILED;
+        } else if (error.message?.includes('format')) {
+            errorCode = ERROR_CODES.MESSAGE.INVALID_FORMAT;
+        }
+        
         return this.handleError(error, {
             action: 'message',
+            errorCode: errorCode,
             messageType: messageType,
             details: `${messageType} Nachricht Fehler`
         });
     }
     
     /**
-     * Get error statistics
+     * Get error statistics with error code breakdown
      */
     getErrorStats() {
+        const errorsByCode = {};
+        this.errorStats.forEach((stats, code) => {
+            errorsByCode[code] = {
+                count: stats.count,
+                description: getErrorDescription(code),
+                category: getErrorCategory(code),
+                firstSeen: stats.firstSeen,
+                lastSeen: stats.lastSeen
+            };
+        });
+        
         return {
             totalErrors: this.errorCount,
             lastError: this.lastError,
+            errorsByCode: errorsByCode,
+            mostCommonError: this.getMostCommonError(),
             supportContacts: {
                 email: this.options.supportEmail,
                 discord: this.options.supportDiscord,
@@ -210,6 +403,27 @@ export class ErrorHandler {
         };
     }
     
+    /**
+     * Get most common error code
+     */
+    getMostCommonError() {
+        let maxCount = 0;
+        let mostCommon = null;
+        
+        this.errorStats.forEach((stats, code) => {
+            if (stats.count > maxCount) {
+                maxCount = stats.count;
+                mostCommon = {
+                    code: code,
+                    count: stats.count,
+                    description: getErrorDescription(code)
+                };
+            }
+        });
+        
+        return mostCommon;
+    }
+    
     /**
      * Reset error count
      */

package/src/message.js

@@ -569,6 +569,88 @@ export class Message {
         });
     }
 
+    async deleteFromReply() {
+        // Prüfe ob die Message eine Reply ist
+        const contextInfo = this.raw.message?.extendedTextMessage?.contextInfo;
+        const quotedMessage = contextInfo?.quotedMessage;
+        const quotedKey = contextInfo?.stanzaId;
+        const quotedParticipant = contextInfo?.participant;
+        
+        if (!quotedMessage || !quotedKey) {
+            console.log('❌ Keine Reply-Message gefunden zum Löschen');
+            return { success: false, reason: 'no_reply' };
+        }
+        
+        try {
+            // Bot JID ermitteln
+            const botJid = this.client.socket.user?.id;
+            const botNumber = botJid?.split('@')[0]?.split(':')[0];
+            const quotedNumber = quotedParticipant?.split('@')[0]?.split(':')[0];
+            
+            // Prüfe ob Message vom Bot ist
+            const isFromBot = botNumber === quotedNumber;
+            
+            console.log('🔍 Debug Info:');
+            console.log('   Bot Number:', botNumber);
+            console.log('   Quoted Number:', quotedNumber);
+            console.log('   Is Group:', this.isGroup);
+            console.log('   Is from Bot:', isFromBot);
+            
+            // Erstelle den Key für die quoted Message
+            const messageKey = {
+                remoteJid: this.from,
+                id: quotedKey,
+                fromMe: isFromBot // true wenn vom Bot, false wenn von anderem User
+            };
+            
+            // In Gruppen: participant hinzufügen
+            if (this.isGroup && quotedParticipant) {
+                messageKey.participant = quotedParticipant;
+            }
+            
+            console.log('🗑️ Versuche Message zu löschen:', JSON.stringify(messageKey, null, 2));
+            
+            // Lösche die quoted Message
+            const result = await this.client.socket.sendMessage(this.from, {
+                delete: messageKey
+            });
+            
+            console.log('✅ Lösch-Request gesendet:', result);
+            return { 
+                success: true, 
+                messageId: quotedKey, 
+                wasFromBot: isFromBot,
+                result: result 
+            };
+            
+        } catch (error) {
+            console.error('❌ Fehler beim Löschen:', error.message);
+            
+            // Spezifische Fehlerbehandlung
+            if (error.message?.includes('not-found') || error.message?.includes('404')) {
+                return { 
+                    success: false, 
+                    reason: 'message_not_found', 
+                    error: 'Message zu alt oder bereits gelöscht' 
+                };
+            }
+            
+            if (error.message?.includes('forbidden') || error.message?.includes('403')) {
+                return { 
+                    success: false, 
+                    reason: 'no_permission', 
+                    error: 'WhatsApp erlaubt nur das Löschen eigener Messages!' 
+                };
+            }
+            
+            return { 
+                success: false, 
+                reason: 'unknown_error', 
+                error: error.message
+            };
+        }
+    }
+
     // ===== MENTION HELPERS =====
     
     getMentions() {