waengine 1.0.4 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waengine",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "🚀 WAEngine - The most powerful WhatsApp Bot Library with Multi-Device Support & EasyBot API",
   "main": "src/index.js",
   "type": "module",

package/src/client.js

@@ -2,6 +2,7 @@ import { makeWASocket, useMultiFileAuthState, DisconnectReason, fetchLatestBaile
 import pino from "pino";
 import { generateQRCode, closeBrowser } from "./qr.js";
 import { Message } from "./message.js";
+import { SessionManager } from "./session-manager.js";
 
 export class WhatsAppClient {
     constructor(options = {}) {
@@ -10,6 +11,7 @@ export class WhatsAppClient {
             printQR: false,
             browser: options.browser || ["Chrome", "121.0.0", ""], // Aktueller Chrome
             logLevel: options.logLevel || "silent", // Sauber ohne Debug
+            autoCleanup: options.autoCleanup !== false, // Auto-Cleanup bei Logout
             ...options
         };
         
@@ -19,6 +21,9 @@ export class WhatsAppClient {
         this.isConnected = false;
         this.eventHandlers = new Map();
         
+        // Session Manager
+        this.sessionManager = new SessionManager(this.options.authDir);
+        
         // Prefix System
         this.prefix = null;
         this.commands = new Map();
@@ -34,10 +39,27 @@ export class WhatsAppClient {
     // ===== CONNECTION METHODS =====
     
     async connect() {
+        console.log("🔌 WAEngine startet...");
+        
         if (this.socket && this.isConnected) {
             return this.socket;
         }
 
+        // Session-Validierung und Auto-Repair
+        await this.sessionManager.ensureAuthDir();
+        const sessionValidation = await this.sessionManager.validateSession();
+        
+        if (!sessionValidation.valid) {
+            console.log(`📋 Session-Status: ${sessionValidation.reason}`);
+            
+            if (sessionValidation.reason === 'corrupted') {
+                console.log("🔧 Repariere korrupte Session...");
+                await this.sessionManager.repairSession();
+            }
+        } else {
+            console.log(`✅ Gültige Session gefunden (User: ${sessionValidation.userId})`);
+        }
+
         const { state, saveCreds } = await useMultiFileAuthState(this.options.authDir);
         const isLoggedIn = !!state.creds?.me?.id;
 
@@ -87,7 +109,7 @@ export class WhatsAppClient {
             });
         }
 
-        console.log("🔌 Socket erstellt");
+        console.log("🔌 WAEngine startet...");
 
         // QR-Code Browser nur öffnen wenn nicht eingeloggt
         if (!this.options.printQR && !isLoggedIn) {
@@ -99,10 +121,7 @@ export class WhatsAppClient {
             this.setupEventHandlers();
             
             this.socket.ev.on("connection.update", async ({ connection, lastDisconnect, qr }) => {
-                console.log(`🔄 Connection Update: ${connection}`);
-                
                 if (qr) {
-                    console.log("📱 QR-Code empfangen");
                     if (this.options.printQR) {
                         // Terminal QR
                         console.log("\n📱 QR-CODE IM TERMINAL:");
@@ -113,28 +132,37 @@ export class WhatsAppClient {
                         console.log("📲 Scanne den QR-Code mit WhatsApp!");
                     } else {
                         // Browser QR
+                        console.log("📱 QR-Code im Browser angezeigt");
                         await generateQRCode(qr);
                     }
                 }
                 
                 if (connection === "connecting") {
-                    console.log("🔄 Verbinde mit WhatsApp...");
+                    console.log("🔄 Verbinde...");
                 }
                 
                 if (connection === "close") {
-                    console.log("🔴 Verbindung geschlossen");
                     const statusCode = lastDisconnect?.error?.output?.statusCode;
                     const shouldReconnect = statusCode !== DisconnectReason.loggedOut;
                     
                     if (shouldReconnect) {
-                        console.log("🔄 Wiederverbindung in 3 Sekunden...");
+                        console.log("🔄 Wiederverbindung...");
                         this.isConnected = false;
                         this.socket = null;
                         setTimeout(() => this.connect().then(resolve).catch(reject), 3000);
                     } else {
-                        console.log("👋 Ausgeloggt");
+                        console.log("👋 Ausgeloggt - bereinige Session...");
+                        this.isConnected = false;
+                        this.socket = null;
+                        
+                        // Auto-Cleanup bei Logout
+                        if (this.options.autoCleanup) {
+                            await this.sessionManager.cleanupSession();
+                            console.log("🧹 Session automatisch bereinigt");
+                        }
+                        
                         await closeBrowser();
-                        this.emit('disconnected', { reason: 'logged_out' });
+                        this.emit('disconnected', { reason: 'logged_out', cleaned: this.options.autoCleanup });
                         reject(new Error('Logged out'));
                     }
                 } else if (connection === "open") {
@@ -167,6 +195,50 @@ export class WhatsAppClient {
         }
     }
 
+    // ===== SESSION MANAGEMENT =====
+    
+    async getSessionStatus() {
+        return await this.sessionManager.getSessionStatus();
+    }
+
+    async validateSession() {
+        return await this.sessionManager.validateSession();
+    }
+
+    async cleanupSession() {
+        console.log("🧹 Manuelle Session-Bereinigung...");
+        const success = await this.sessionManager.cleanupSession();
+        if (success) {
+            console.log("✅ Session erfolgreich bereinigt");
+        }
+        return success;
+    }
+
+    async repairSession() {
+        console.log("🔧 Session-Reparatur...");
+        return await this.sessionManager.repairSession();
+    }
+
+    async backupSession() {
+        return await this.sessionManager.backupSession();
+    }
+
+    // Logout mit automatischer Bereinigung
+    async logout() {
+        if (this.socket) {
+            console.log("👋 Logout wird durchgeführt...");
+            this.socket.logout();
+            
+            // Warte kurz und bereinige dann
+            setTimeout(async () => {
+                if (this.options.autoCleanup) {
+                    await this.sessionManager.cleanupSession();
+                    console.log("🧹 Session nach Logout bereinigt");
+                }
+            }, 1000);
+        }
+    }
+
     // ===== EVENT SYSTEM =====
     
     on(event, handler) {
@@ -201,49 +273,37 @@ export class WhatsAppClient {
     }
 
     setupEventHandlers() {
-        console.log("🔧 Registriere Event-Handler...");
-        
-        // Messages - Verbesserte Message-Erkennung
+        // Messages - Saubere Message-Erkennung ohne Debug-Spam
         this.socket.ev.on("messages.upsert", ({ messages, type }) => {
-            console.log(`📨 Messages.upsert - Type: ${type}, Count: ${messages.length}`);
-            
-            // Alle Message-Types verarbeiten, nicht nur "notify"
-            if (type !== "notify" && type !== "append") {
-                console.log(`⚠️ Ignoriere Message-Type: ${type}`);
-                return;
-            }
+            // Nur relevante Message-Types verarbeiten
+            if (type !== "notify" && type !== "append") return;
 
-            messages.forEach((msg, index) => {
-                console.log(`🔍 Processing message ${index + 1}/${messages.length}`);
-                console.log(`   - From: ${msg.key.remoteJid}`);
-                console.log(`   - FromMe: ${msg.key.fromMe}`);
-                console.log(`   - Message Keys: ${Object.keys(msg.message || {}).join(', ')}`);
-                
+            messages.forEach((msg) => {
                 // Bessere Message-Validierung
-                if (!msg.message) {
-                    console.log("   ❌ Keine Message-Daten");
-                    return;
-                }
+                if (!msg.message || msg.key.fromMe) return;
                 
-                if (msg.key.fromMe) {
-                    console.log("   ❌ Eigene Nachricht - ignoriert");
-                    return;
+                // Ignoriere System-Messages (protocolMessage, etc.)
+                if (msg.message.protocolMessage || 
+                    msg.message.reactionMessage || 
+                    msg.message.ephemeralMessage ||
+                    msg.message.viewOnceMessage) {
+                    return; // Ignoriere ohne Debug-Output
                 }
                 
                 // Ignoriere Broadcast-Messages
-                if (msg.key.remoteJid && isJidBroadcast(msg.key.remoteJid)) {
-                    console.log("   ❌ Broadcast-Message - ignoriert");
-                    return;
-                }
+                if (msg.key.remoteJid && isJidBroadcast(msg.key.remoteJid)) return;
 
                 const messageData = this.parseMessage(msg);
-                console.log(`   ✅ Text extrahiert: "${messageData.text}"`);
-                console.log(`   ✅ Type: ${messageData.type}`);
                 
-                // Nur verarbeiten wenn Text vorhanden oder andere unterstützte Typen
-                if (!messageData.text && messageData.type === 'unknown') {
-                    console.log("   ❌ Kein Text und unbekannter Typ");
-                    return;
+                // Nur verarbeiten wenn Text vorhanden oder unterstützte Typen
+                if (!messageData.text && 
+                    !['image', 'video', 'audio', 'document', 'sticker', 'location', 'contact'].includes(messageData.type)) {
+                    return; // Ignoriere ohne Debug-Output
+                }
+                
+                // Nur bei echten Nachrichten loggen
+                if (messageData.text || messageData.type !== 'unknown') {
+                    console.log(`📨 ${messageData.type}: "${messageData.text || '[Media]'}" von ${messageData.from}`);
                 }
                 
                 const messageObj = new Message(this, messageData);
@@ -253,7 +313,7 @@ export class WhatsAppClient {
                     const commandText = messageData.text.slice(this.prefix.length).trim();
                     const [command, ...args] = commandText.split(' ');
                     
-                    console.log(`   ⚡ Command erkannt: ${command}`);
+                    console.log(`⚡ Command: ${this.prefix}${command}`);
                     
                     messageObj.isCommand = true;
                     messageObj.command = command.toLowerCase();
@@ -266,59 +326,42 @@ export class WhatsAppClient {
                     // Spezifischen Command Handler aufrufen falls vorhanden
                     if (this.commands.has(command.toLowerCase())) {
                         const handler = this.commands.get(command.toLowerCase());
-                        console.log(`   🎯 Führe Command-Handler aus: ${command}`);
                         try {
                             handler(messageObj, args);
                         } catch (error) {
                             console.error(`❌ Fehler in Command '${command}':`, error);
                         }
-                    } else {
-                        console.log(`   ❓ Kein Handler für Command: ${command}`);
                     }
                 } else {
                     messageObj.isCommand = false;
                     messageObj.command = null;
                     messageObj.args = [];
-                    console.log("   📝 Normale Nachricht");
                 }
                 
-                console.log("   📤 Emittiere Message-Event");
                 this.emit('message', messageObj);
-                console.log("   ✅ Message verarbeitet");
             });
         });
 
-        // Zusätzliche Events für bessere Kompatibilität
+        // Andere Events ohne Debug-Spam
         this.socket.ev.on("messages.update", (updates) => {
-            console.log(`📝 Messages.update - Count: ${updates.length}`);
             this.emit('messages.update', updates);
         });
 
-        // Bessere Presence-Handling
         this.socket.ev.on("presence.update", (update) => {
-            console.log(`👤 Presence.update - ID: ${update.id}`);
             this.emit('presence.update', update);
         });
 
-        // Group updates
         this.socket.ev.on("group-participants.update", (update) => {
-            console.log(`👥 Group-participants.update - Group: ${update.id}`);
             this.emit('group.participants.update', update);
         });
 
-        // Chats updates für bessere Synchronisation
         this.socket.ev.on("chats.upsert", (chats) => {
-            console.log(`💬 Chats.upsert - Count: ${chats.length}`);
             this.emit('chats.upsert', chats);
         });
 
-        // Contacts updates
         this.socket.ev.on("contacts.upsert", (contacts) => {
-            console.log(`📞 Contacts.upsert - Count: ${contacts.length}`);
             this.emit('contacts.upsert', contacts);
         });
-        
-        console.log("✅ Event-Handler registriert!");
     }
 
     parseMessage(msg) {

package/src/session-manager.js

@@ -0,0 +1,154 @@
+// Session Manager für WAEngine v1.0.6
+import fs from 'fs';
+import path from 'path';
+
+export class SessionManager {
+    constructor(authDir) {
+        this.authDir = authDir;
+    }
+
+    // Prüft ob Session existiert und gültig ist
+    async validateSession() {
+        try {
+            if (!fs.existsSync(this.authDir)) {
+                return { valid: false, reason: 'no_auth_dir' };
+            }
+
+            const credsPath = path.join(this.authDir, 'creds.json');
+            if (!fs.existsSync(credsPath)) {
+                return { valid: false, reason: 'no_creds' };
+            }
+
+            const creds = JSON.parse(fs.readFileSync(credsPath, 'utf8'));
+            
+            // Prüfe ob User-ID vorhanden (eingeloggt)
+            if (!creds.me?.id) {
+                return { valid: false, reason: 'not_logged_in' };
+            }
+
+            // Prüfe ob Session nicht zu alt ist (optional)
+            const stats = fs.statSync(credsPath);
+            const ageInDays = (Date.now() - stats.mtime.getTime()) / (1000 * 60 * 60 * 24);
+            
+            if (ageInDays > 30) { // Session älter als 30 Tage
+                return { valid: false, reason: 'session_too_old' };
+            }
+
+            return { 
+                valid: true, 
+                userId: creds.me.id,
+                lastModified: stats.mtime,
+                ageInDays: Math.round(ageInDays)
+            };
+
+        } catch (error) {
+            return { valid: false, reason: 'corrupted', error: error.message };
+        }
+    }
+
+    // Bereinigt Session komplett
+    async cleanupSession() {
+        try {
+            if (fs.existsSync(this.authDir)) {
+                console.log("🧹 Bereinige Session...");
+                
+                // Alle Auth-Dateien löschen
+                const files = fs.readdirSync(this.authDir);
+                for (const file of files) {
+                    const filePath = path.join(this.authDir, file);
+                    fs.unlinkSync(filePath);
+                }
+                
+                // Auth-Ordner löschen
+                fs.rmdirSync(this.authDir);
+                console.log("✅ Session bereinigt");
+                return true;
+            }
+            return true;
+        } catch (error) {
+            console.error("❌ Fehler beim Session-Cleanup:", error);
+            return false;
+        }
+    }
+
+    // Erstellt Auth-Ordner falls nicht vorhanden
+    async ensureAuthDir() {
+        if (!fs.existsSync(this.authDir)) {
+            fs.mkdirSync(this.authDir, { recursive: true });
+            console.log(`📁 Auth-Ordner erstellt: ${this.authDir}`);
+        }
+    }
+
+    // Backup der Session erstellen
+    async backupSession() {
+        try {
+            if (!fs.existsSync(this.authDir)) return false;
+
+            const backupDir = `${this.authDir}_backup_${Date.now()}`;
+            fs.mkdirSync(backupDir, { recursive: true });
+
+            const files = fs.readdirSync(this.authDir);
+            for (const file of files) {
+                const srcPath = path.join(this.authDir, file);
+                const destPath = path.join(backupDir, file);
+                fs.copyFileSync(srcPath, destPath);
+            }
+
+            console.log(`💾 Session-Backup erstellt: ${backupDir}`);
+            return backupDir;
+        } catch (error) {
+            console.error("❌ Backup-Fehler:", error);
+            return false;
+        }
+    }
+
+    // Session-Status für Debugging
+    getSessionStatus() {
+        try {
+            if (!fs.existsSync(this.authDir)) {
+                return { status: 'no_session', files: [] };
+            }
+
+            const files = fs.readdirSync(this.authDir);
+            const fileDetails = files.map(file => {
+                const filePath = path.join(this.authDir, file);
+                const stats = fs.statSync(filePath);
+                return {
+                    name: file,
+                    size: stats.size,
+                    modified: stats.mtime
+                };
+            });
+
+            return {
+                status: 'session_exists',
+                files: fileDetails,
+                totalFiles: files.length,
+                authDir: this.authDir
+            };
+        } catch (error) {
+            return { status: 'error', error: error.message };
+        }
+    }
+
+    // Repariert korrupte Session
+    async repairSession() {
+        console.log("🔧 Versuche Session-Reparatur...");
+        
+        const validation = await this.validateSession();
+        
+        if (validation.reason === 'corrupted') {
+            console.log("🗑️ Korrupte Session erkannt - bereinige...");
+            await this.cleanupSession();
+            return { repaired: true, action: 'cleanup' };
+        }
+
+        if (validation.reason === 'session_too_old') {
+            console.log("⏰ Session zu alt - bereinige...");
+            await this.cleanupSession();
+            return { repaired: true, action: 'cleanup_old' };
+        }
+
+        return { repaired: false, reason: validation.reason };
+    }
+}