waengine 1.0.5 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waengine",
-  "version": "1.0.5",
+  "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;
 
@@ -129,9 +151,18 @@ export class WhatsAppClient {
                         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") {
@@ -164,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) {

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 };
+    }
+}