waengine 1.0.5 → 1.0.7

package/README.md

@@ -496,20 +496,52 @@ const messageTypes = await msg.stats.getMessagesByType()
 
 ### **Prefix Setup**
 ```javascript
-// Set prefix
+// Global Prefix (Fallback)
 const prefix = "!"
 client.setPrefix(prefix)
 
-// Register commands
+// Chat-spezifische Prefixes (NEU in v1.0.7!)
+client.setChatPrefix(chatId, "#")  // Für spezifischen Chat
+client.getChatPrefix(chatId)       // Prefix abrufen
+client.removeChatPrefix(chatId)    // Prefix entfernen
+
+// Commands registrieren
 client.addCommand('help', async (msg, args) => {
     await msg.reply('Help text')
 })
+```
 
-client.addCommand('ping', async (msg, args) => {
-    await msg.reply('Pong! 🏓')
-})
+### **Chat-spezifische Prefixes (v1.0.7)**
+Jeder Chat/Gruppe kann einen eigenen Prefix haben:
+
+```javascript
+// Setprefix Command (Admin only)
+client.addCommand('setprefix', async (msg, args) => {
+    if (msg.isGroup && !(await msg.isAdmin())) {
+        return msg.reply('❌ Nur Admins können den Prefix ändern!');
+    }
+    
+    const newPrefix = args[0];
+    client.setChatPrefix(msg.from, newPrefix);
+    await msg.reply(`✅ Prefix geändert zu: "${newPrefix}"`);
+});
+
+// Prefix Info Command
+client.addCommand('prefixinfo', async (msg) => {
+    const chatPrefix = client.getChatPrefix(msg.from);
+    const stats = client.getPrefixStats();
+    
+    await msg.reply(`🎯 Aktueller Prefix: "${chatPrefix}"\n📊 Gesamt Chats: ${stats.totalChats}`);
+});
 ```
 
+**Features:**
+- ✅ **Persistent Storage** - Prefixes werden automatisch gespeichert
+- ✅ **Admin-only** - Nur Admins können Prefixes in Gruppen ändern
+- ✅ **Validierung** - Max 5 Zeichen, keine Leerzeichen
+- ✅ **Statistics** - Übersicht über alle verwendeten Prefixes
+- ✅ **Fallback** - Global Prefix als Standard
+
 ### **Command Properties**
 ```javascript
 // In message events

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waengine",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "🚀 WAEngine - The most powerful WhatsApp Bot Library with Multi-Device Support & EasyBot API",
   "main": "src/index.js",
   "type": "module",
@@ -24,6 +24,9 @@
     "messaging",
     "multi-account",
     "load-balancing",
+    "prefix-system",
+    "chat-specific",
+    "group-management",
     "typescript",
     "javascript",
     "nodejs"

package/src/client.js

@@ -2,6 +2,8 @@ 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";
+import { PrefixManager } from "./prefix-manager.js";
 
 export class WhatsAppClient {
     constructor(options = {}) {
@@ -10,6 +12,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,8 +22,12 @@ export class WhatsAppClient {
         this.isConnected = false;
         this.eventHandlers = new Map();
         
-        // Prefix System
-        this.prefix = null;
+        // Session Manager
+        this.sessionManager = new SessionManager(this.options.authDir);
+        
+        // Prefix System (erweitert für gruppen-spezifische Prefixes)
+        this.prefix = null; // Global fallback
+        this.prefixManager = new PrefixManager('./data');
         this.commands = new Map();
         
         // Deine eigenen API-Objekte
@@ -34,10 +41,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 +153,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 +197,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) {
@@ -233,28 +310,32 @@ export class WhatsAppClient {
                 
                 const messageObj = new Message(this, messageData);
                 
-                // Prefix System - Command Check
-                if (this.prefix && messageData.text && messageData.text.startsWith(this.prefix)) {
-                    const commandText = messageData.text.slice(this.prefix.length).trim();
-                    const [command, ...args] = commandText.split(' ');
-                    
-                    console.log(`⚡ Command: ${this.prefix}${command}`);
-                    
-                    messageObj.isCommand = true;
-                    messageObj.command = command.toLowerCase();
-                    messageObj.args = args;
-                    messageObj.commandText = commandText;
-                    
-                    // Command Event emittieren
-                    this.emit('command', messageObj);
+                // Prefix System - Command Check (erweitert für Chat-spezifische Prefixes)
+                const chatPrefix = this.prefixManager.getPrefix(messageData.from);
+                
+                if (messageData.text && messageData.text.startsWith(chatPrefix)) {
+                    const commandData = this.prefixManager.parseCommand(messageData.text, messageData.from);
                     
-                    // Spezifischen Command Handler aufrufen falls vorhanden
-                    if (this.commands.has(command.toLowerCase())) {
-                        const handler = this.commands.get(command.toLowerCase());
-                        try {
-                            handler(messageObj, args);
-                        } catch (error) {
-                            console.error(`❌ Fehler in Command '${command}':`, error);
+                    if (commandData) {
+                        console.log(`⚡ Command in ${messageData.from}: ${commandData.prefix}${commandData.command}`);
+                        
+                        messageObj.isCommand = true;
+                        messageObj.command = commandData.command;
+                        messageObj.args = commandData.args;
+                        messageObj.commandText = commandData.commandText;
+                        messageObj.prefix = commandData.prefix;
+                        
+                        // Command Event emittieren
+                        this.emit('command', messageObj);
+                        
+                        // Spezifischen Command Handler aufrufen falls vorhanden
+                        if (this.commands.has(commandData.command)) {
+                            const handler = this.commands.get(commandData.command);
+                            try {
+                                handler(messageObj, commandData.args);
+                            } catch (error) {
+                                console.error(`❌ Fehler in Command '${commandData.command}':`, error);
+                            }
                         }
                     }
                 } else {
@@ -349,15 +430,43 @@ export class WhatsAppClient {
         };
     }
 
-    // ===== PREFIX SYSTEM =====
+    // ===== PREFIX SYSTEM (ERWEITERT) =====
     
+    // Global Prefix (Fallback)
     setPrefix(prefix) {
         this.prefix = prefix;
+        this.prefixManager.defaultPrefix = prefix;
+        console.log(`🌐 Global Prefix gesetzt: "${prefix}"`);
         return this;
     }
 
-    getPrefix() {
-        return this.prefix;
+    getPrefix(chatId = null) {
+        if (chatId) {
+            return this.prefixManager.getPrefix(chatId);
+        }
+        return this.prefix || this.prefixManager.defaultPrefix;
+    }
+
+    // Chat-spezifische Prefixes
+    setChatPrefix(chatId, prefix) {
+        return this.prefixManager.setPrefix(chatId, prefix);
+    }
+
+    getChatPrefix(chatId) {
+        return this.prefixManager.getPrefix(chatId);
+    }
+
+    removeChatPrefix(chatId) {
+        return this.prefixManager.removePrefix(chatId);
+    }
+
+    // Prefix Statistics
+    getPrefixStats() {
+        return this.prefixManager.getStats();
+    }
+
+    getAllPrefixes() {
+        return this.prefixManager.getAllPrefixes();
     }
 
     addCommand(command, handler) {

package/src/index.js

@@ -1,6 +1,7 @@
 export { WhatsAppClient } from "./client.js";
 export { MultiWhatsAppClient } from "./multi-client.js";
 export { DeviceManager } from "./device-manager.js";
+export { PrefixManager } from "./prefix-manager.js";
 export { EasyBot, createBot, createMultiBot, quickBot, bot, multiBot } from "./easy-bot.js";
 export { generateQRCode } from "./qr.js";
 export { Message } from "./message.js";

package/src/prefix-manager.js

@@ -0,0 +1,158 @@
+// Prefix Manager für gruppen-spezifische Prefixes
+import fs from 'fs';
+import path from 'path';
+
+export class PrefixManager {
+    constructor(dataDir = './data') {
+        this.dataDir = dataDir;
+        this.prefixFile = path.join(dataDir, 'prefixes.json');
+        this.defaultPrefix = '!';
+        this.prefixes = new Map();
+        
+        this.ensureDataDir();
+        this.loadPrefixes();
+    }
+
+    // ===== SETUP =====
+    
+    ensureDataDir() {
+        if (!fs.existsSync(this.dataDir)) {
+            fs.mkdirSync(this.dataDir, { recursive: true });
+            console.log(`📁 Prefix Data Directory erstellt: ${this.dataDir}`);
+        }
+    }
+
+    // ===== LOAD/SAVE =====
+    
+    loadPrefixes() {
+        try {
+            if (fs.existsSync(this.prefixFile)) {
+                const data = JSON.parse(fs.readFileSync(this.prefixFile, 'utf8'));
+                this.prefixes = new Map(Object.entries(data));
+                console.log(`📋 ${this.prefixes.size} Prefixes geladen`);
+            }
+        } catch (error) {
+            console.error('❌ Fehler beim Laden der Prefixes:', error);
+            this.prefixes = new Map();
+        }
+    }
+
+    savePrefixes() {
+        try {
+            const data = Object.fromEntries(this.prefixes);
+            fs.writeFileSync(this.prefixFile, JSON.stringify(data, null, 2));
+            console.log(`💾 Prefixes gespeichert (${this.prefixes.size} Einträge)`);
+            return true;
+        } catch (error) {
+            console.error('❌ Fehler beim Speichern der Prefixes:', error);
+            return false;
+        }
+    }
+
+    // ===== PREFIX MANAGEMENT =====
+    
+    setPrefix(chatId, prefix) {
+        if (!chatId) {
+            throw new Error('❌ Chat ID ist erforderlich!');
+        }
+        
+        if (!prefix || prefix.length === 0) {
+            throw new Error('❌ Prefix darf nicht leer sein!');
+        }
+        
+        // Validierung: Prefix sollte nicht zu lang sein
+        if (prefix.length > 5) {
+            throw new Error('❌ Prefix darf maximal 5 Zeichen lang sein!');
+        }
+        
+        this.prefixes.set(chatId, prefix);
+        this.savePrefixes();
+        
+        console.log(`🎯 Prefix für ${chatId} gesetzt: "${prefix}"`);
+        return true;
+    }
+
+    getPrefix(chatId) {
+        if (!chatId) return this.defaultPrefix;
+        
+        return this.prefixes.get(chatId) || this.defaultPrefix;
+    }
+
+    removePrefix(chatId) {
+        if (!chatId) return false;
+        
+        const removed = this.prefixes.delete(chatId);
+        if (removed) {
+            this.savePrefixes();
+            console.log(`🗑️ Prefix für ${chatId} entfernt`);
+        }
+        return removed;
+    }
+
+    // ===== UTILITY =====
+    
+    getAllPrefixes() {
+        return Object.fromEntries(this.prefixes);
+    }
+
+    getPrefixCount() {
+        return this.prefixes.size;
+    }
+
+    // Prüft ob Text mit dem Chat-spezifischen Prefix beginnt
+    isCommand(text, chatId) {
+        if (!text) return false;
+        
+        const prefix = this.getPrefix(chatId);
+        return text.startsWith(prefix);
+    }
+
+    // Extrahiert Command und Args basierend auf Chat-spezifischem Prefix
+    parseCommand(text, chatId) {
+        if (!this.isCommand(text, chatId)) {
+            return null;
+        }
+        
+        const prefix = this.getPrefix(chatId);
+        const commandText = text.slice(prefix.length).trim();
+        const [command, ...args] = commandText.split(' ');
+        
+        return {
+            prefix,
+            command: command.toLowerCase(),
+            args,
+            commandText,
+            fullText: text
+        };
+    }
+
+    // ===== STATISTICS =====
+    
+    getStats() {
+        const prefixCounts = {};
+        
+        for (const prefix of this.prefixes.values()) {
+            prefixCounts[prefix] = (prefixCounts[prefix] || 0) + 1;
+        }
+        
+        return {
+            totalChats: this.prefixes.size,
+            defaultPrefix: this.defaultPrefix,
+            prefixDistribution: prefixCounts,
+            mostUsedPrefix: Object.keys(prefixCounts).reduce((a, b) => 
+                prefixCounts[a] > prefixCounts[b] ? a : b, this.defaultPrefix)
+        };
+    }
+
+    // ===== RESET =====
+    
+    resetAllPrefixes() {
+        this.prefixes.clear();
+        this.savePrefixes();
+        console.log('🔄 Alle Prefixes zurückgesetzt');
+    }
+
+    resetToDefault(chatId) {
+        return this.removePrefix(chatId);
+    }
+}

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