waengine 1.1.0 → 1.5.0

package/src/device-manager.js

@@ -117,18 +117,43 @@ export class DeviceManager {
     }
 
     async connectAll() {
-        console.log(`🚀 Verbinde alle ${this.devices.size} Devices...`);
+        console.log(`🚀 Sequenzielle Verbindung aller ${this.devices.size} Devices...`);
+        console.log("📱 QR-Codes werden nacheinander angezeigt!");
         
-        const promises = Array.from(this.devices.keys()).map(deviceId => 
-            this.connectDevice(deviceId).catch(error => {
-                console.error(`❌ Device '${deviceId}' Verbindung fehlgeschlagen:`, error.message);
-                return null;
-            })
-        );
-
-        const results = await Promise.allSettled(promises);
-        const connected = results.filter(r => r.status === 'fulfilled' && r.value).length;
+        const deviceIds = Array.from(this.devices.keys());
+        const results = [];
+        let connected = 0;
+        
+        for (let i = 0; i < deviceIds.length; i++) {
+            const deviceId = deviceIds[i];
+            
+            try {
+                console.log(`\n📱 Device ${i + 1}/${deviceIds.length}: '${deviceId}'`);
+                console.log("⏳ Scanne den QR-Code für dieses Device...");
+                
+                await this.connectDevice(deviceId);
+                connected++;
+                results.push({ deviceId, status: 'connected' });
+                
+                console.log(`✅ Device '${deviceId}' verbunden! Weiter zum nächsten...`);
+                
+                // Kurze Pause zwischen Devices
+                if (i < deviceIds.length - 1) {
+                    console.log("⏸️ 3 Sekunden Pause...");
+                    await new Promise(resolve => setTimeout(resolve, 3000));
+                }
+                
+            } catch (error) {
+                console.error(`❌ Device '${deviceId}' fehlgeschlagen:`, error.message);
+                results.push({ deviceId, status: 'failed', error: error.message });
+                
+                // Weiter mit nächstem Device
+                console.log("➡️ Weiter mit nächstem Device...");
+                await new Promise(resolve => setTimeout(resolve, 2000));
+            }
+        }
         
+        console.log(`\n🎉 Alle Devices verarbeitet!`);
         console.log(`✅ ${connected}/${this.devices.size} Devices erfolgreich verbunden`);
         
         if (connected === 0) {

package/src/easy-bot.js

@@ -28,6 +28,22 @@ export class EasyBot {
         bot.client = new WhatsAppClient({
             authDir: "./auth",
             logLevel: "silent",
+            
+            // CLEAN QR DEFAULTS - NEU!
+            printQR: false,                    // Browser QR bevorzugt
+            qrSpamPrevention: true,           // Anti-Spam aktiviert
+            qrDisplayInterval: 30000,         // 30s zwischen Terminal QR
+            qrMaxDisplays: 3,                 // Max 3 Terminal QR
+            clearTerminalOnQR: true,          // Terminal bei QR leeren
+            
+            // ROBUSTE CONNECTION DEFAULTS - NEU!
+            maxReconnectAttempts: 100, // Viele Versuche für 24/7
+            reconnectInterval: 2000, // Schnellere Wiederverbindung
+            exponentialBackoff: true,
+            maxBackoffDelay: 30000, // Max 30 Sekunden
+            heartbeatInterval: 20000, // 20 Sekunden Heartbeat
+            connectionTimeout: 180000, // 3 Minuten Timeout
+            keepAlive: true,
             ...options
         });
         return bot;
@@ -39,6 +55,14 @@ export class EasyBot {
         bot.multiClient = new MultiWhatsAppClient({
             maxDevices: deviceCount,
             loadBalancing: 'round-robin',
+            // ROBUSTE CONNECTION DEFAULTS - NEU!
+            maxReconnectAttempts: 100,
+            reconnectInterval: 2000,
+            exponentialBackoff: true,
+            maxBackoffDelay: 30000,
+            heartbeatInterval: 20000,
+            connectionTimeout: 180000,
+            keepAlive: true,
             ...options
         });
         return bot;
@@ -48,6 +72,17 @@ export class EasyBot {
         return EasyBot.create().enableDefaults();
     }
 
+    // ROBUSTE CONNECTION FACTORY - NEU!
+    static createRobust(options = {}) {
+        return EasyBot.create({
+            maxReconnectAttempts: 200, // Noch mehr Versuche
+            reconnectInterval: 1000, // Sehr schnelle Wiederverbindung
+            heartbeatInterval: 15000, // 15 Sekunden Heartbeat
+            connectionTimeout: 300000, // 5 Minuten Timeout
+            ...options
+        });
+    }
+
     // ===== SIMPLE RULES =====
     
     when(trigger) {
@@ -289,6 +324,54 @@ export class EasyBot {
         return this;
     }
 
+    // Ignore API für EasyBot - DEINE NEUE FUNKTION!
+    ignoreOfflineMessages(enabled = true) {
+        if (this.client) {
+            this.client.ignore.message.offline(enabled);
+        } else if (this.multiClient) {
+            // Für Multi-Client später implementieren
+            console.log("⚠️ Offline Message Ignore für Multi-Client noch nicht verfügbar");
+        }
+        return this;
+    }
+
+    // ROBUSTE CONNECTION API - NEU!
+    enableRobustConnection(enabled = true) {
+        if (this.client) {
+            // Robuste Einstellungen aktivieren
+            this.client.options.maxReconnectAttempts = enabled ? 200 : 50;
+            this.client.options.reconnectInterval = enabled ? 1000 : 3000;
+            this.client.options.heartbeatInterval = enabled ? 15000 : 30000;
+            this.client.options.connectionTimeout = enabled ? 300000 : 120000;
+            console.log(`💪 Robuste Verbindung ${enabled ? 'AKTIVIERT' : 'DEAKTIVIERT'}`);
+        }
+        return this;
+    }
+
+    setReconnectAttempts(attempts) {
+        if (this.client) {
+            this.client.options.maxReconnectAttempts = attempts;
+            console.log(`🔄 Max Wiederverbindungsversuche: ${attempts}`);
+        }
+        return this;
+    }
+
+    setHeartbeatInterval(interval) {
+        if (this.client) {
+            this.client.options.heartbeatInterval = interval;
+            console.log(`💓 Heartbeat Interval: ${interval / 1000}s`);
+        }
+        return this;
+    }
+
+    enableUltraRobust() {
+        return this
+            .enableRobustConnection(true)
+            .setReconnectAttempts(500) // Sehr viele Versuche
+            .setHeartbeatInterval(10000) // 10 Sekunden Heartbeat
+            .enableAutoRestart(true, 2000); // 2 Sekunden Restart-Delay
+    }
+
     // ===== MULTI-DEVICE SETUP =====
     
     async addDevice(deviceId, options = {}) {
@@ -455,21 +538,29 @@ export class EasyBot {
         }
     }
 
-    async sendReply(msg, text) {
+    async sendReply(msg, text, mentions = []) {
         try {
             if (this.isMultiDevice) {
                 const client = this.multiClient.getNextDevice();
                 if (client && client.socket) {
-                    await client.socket.sendMessage(msg.from, { text: String(text) });
+                    const messageObj = { text: String(text) };
+                    if (mentions.length > 0) {
+                        messageObj.mentions = mentions;
+                    }
+                    await client.socket.sendMessage(msg.from, messageObj);
                 } else {
                     throw new Error('Kein verfügbarer Multi-Device Client');
                 }
             } else {
                 if (msg.reply && typeof msg.reply === 'function') {
-                    await msg.reply(String(text));
+                    await msg.reply(String(text), mentions);
                 } else {
                     // Fallback: Direct client call
-                    await this.client.socket.sendMessage(msg.from, { text: String(text) });
+                    const messageObj = { text: String(text) };
+                    if (mentions.length > 0) {
+                        messageObj.mentions = mentions;
+                    }
+                    await this.client.socket.sendMessage(msg.from, messageObj);
                 }
             }
         } catch (error) {
@@ -477,7 +568,11 @@ export class EasyBot {
             // Fallback attempt
             try {
                 if (this.client && this.client.socket) {
-                    await this.client.socket.sendMessage(msg.from, { text: String(text) });
+                    const messageObj = { text: String(text) };
+                    if (mentions.length > 0) {
+                        messageObj.mentions = mentions;
+                    }
+                    await this.client.socket.sendMessage(msg.from, messageObj);
                 }
             } catch (fallbackError) {
                 console.error("❌ Auch Fallback fehlgeschlagen:", fallbackError.message);
@@ -771,6 +866,22 @@ class EasyRule {
         return this;
     }
 
+    // Neue Mention + Typing Kombinationen
+    slowTypeWithMention(text) {
+        this.actions.push({ type: 'slowTypeWithMention', value: text });
+        return this;
+    }
+
+    quickTypeWithMention(text) {
+        this.actions.push({ type: 'quickTypeWithMention', value: text });
+        return this;
+    }
+
+    normalTypeWithMention(text) {
+        this.actions.push({ type: 'normalTypeWithMention', value: text });
+        return this;
+    }
+
     // Delete actions
     deleteMessage() {
         this.actions.push({ type: 'delete' });
@@ -1046,13 +1157,99 @@ class EasyRule {
                         break;
                         
                     case 'mentionSender':
-                        // Implementierung für mentionSender
-                        await this.bot.sendReply(msg, action.value);
+                        // Verbesserte Implementierung für mentionSender
+                        try {
+                            if (msg.replyWithMention && typeof msg.replyWithMention === 'function') {
+                                await msg.replyWithMention(action.value, msg.getSender());
+                            } else {
+                                // Fallback
+                                const senderName = msg.getSender().split('@')[0];
+                                const mentionText = action.value.replace('@user', `@${senderName}`);
+                                await this.bot.sendReply(msg, mentionText, [msg.getSender()]);
+                            }
+                        } catch (error) {
+                            console.error('❌ Fehler bei mentionSender:', error.message);
+                            await this.bot.sendReply(msg, action.value);
+                        }
                         break;
                         
                     case 'mentionAll':
-                        // Implementierung für mentionAll
-                        await this.bot.sendReply(msg, action.value);
+                        // Verbesserte Implementierung für mentionAll
+                        try {
+                            if (msg.mentionAll && typeof msg.mentionAll === 'function') {
+                                await msg.mentionAll(action.value);
+                            } else {
+                                await this.bot.sendReply(msg, action.value);
+                            }
+                        } catch (error) {
+                            console.error('❌ Fehler bei mentionAll:', error.message);
+                            await this.bot.sendReply(msg, action.value);
+                        }
+                        break;
+                        
+                    case 'mentionUser':
+                        // Implementierung für mentionUser
+                        try {
+                            if (msg.replyWithMention && typeof msg.replyWithMention === 'function') {
+                                await msg.replyWithMention(action.value.text, action.value.userJid);
+                            } else {
+                                await this.bot.sendReply(msg, action.value.text);
+                            }
+                        } catch (error) {
+                            console.error('❌ Fehler bei mentionUser:', error.message);
+                            await this.bot.sendReply(msg, action.value.text);
+                        }
+                        break;
+                        
+                    case 'slowTypeWithMention':
+                        // Neue Funktion: Slow Type mit Mention
+                        try {
+                            if (msg.slowTypeWithMention && typeof msg.slowTypeWithMention === 'function') {
+                                await msg.slowTypeWithMention(action.value, msg.getSender());
+                            } else {
+                                // Fallback
+                                const senderName = msg.getSender().split('@')[0];
+                                const mentionText = action.value.replace('@user', `@${senderName}`);
+                                await this.bot.typeMessage(msg, 4000);
+                                await this.bot.sendReply(msg, mentionText, [msg.getSender()]);
+                            }
+                        } catch (error) {
+                            console.error('❌ Fehler bei slowTypeWithMention:', error.message);
+                        }
+                        break;
+                        
+                    case 'quickTypeWithMention':
+                        // Neue Funktion: Quick Type mit Mention
+                        try {
+                            if (msg.quickTypeWithMention && typeof msg.quickTypeWithMention === 'function') {
+                                await msg.quickTypeWithMention(action.value, msg.getSender());
+                            } else {
+                                // Fallback
+                                const senderName = msg.getSender().split('@')[0];
+                                const mentionText = action.value.replace('@user', `@${senderName}`);
+                                await this.bot.typeMessage(msg, 1000);
+                                await this.bot.sendReply(msg, mentionText, [msg.getSender()]);
+                            }
+                        } catch (error) {
+                            console.error('❌ Fehler bei quickTypeWithMention:', error.message);
+                        }
+                        break;
+                        
+                    case 'normalTypeWithMention':
+                        // Neue Funktion: Normal Type mit Mention
+                        try {
+                            if (msg.normalTypeWithMention && typeof msg.normalTypeWithMention === 'function') {
+                                await msg.normalTypeWithMention(action.value, msg.getSender());
+                            } else {
+                                // Fallback
+                                const senderName = msg.getSender().split('@')[0];
+                                const mentionText = action.value.replace('@user', `@${senderName}`);
+                                await this.bot.typeMessage(msg, 2000);
+                                await this.bot.sendReply(msg, mentionText, [msg.getSender()]);
+                            }
+                        } catch (error) {
+                            console.error('❌ Fehler bei normalTypeWithMention:', error.message);
+                        }
                         break;
                         
                     case 'mentionUser':

package/src/index.js

@@ -11,3 +11,7 @@ export { PluginManager } from "./plugin-manager-fixed.js";
 export { EasyBot, createBot, createMultiBot, quickBot, bot, multiBot } from "./easy-bot.js";
 export { generateQRCode } from "./qr.js";
 export { Message } from "./message.js";
+
+// NEUE ROBUSTE FACTORY METHODS - NEU!
+export const createRobustBot = () => EasyBot.createRobust();
+export const createUltraRobustBot = () => EasyBot.createRobust().enableUltraRobust();

package/src/message.js

@@ -301,6 +301,25 @@ export class Message {
         return await this.reply(mentionText, allMembers);
     }
 
+    // Mention mit Typing - Neue Funktion für bessere UX
+    async slowTypeWithMention(text, userJid) {
+        const senderName = userJid.split('@')[0];
+        const mentionText = text.replace('@user', `@${senderName}`);
+        return await this.slowType(mentionText, [userJid]);
+    }
+
+    async quickTypeWithMention(text, userJid) {
+        const senderName = userJid.split('@')[0];
+        const mentionText = text.replace('@user', `@${senderName}`);
+        return await this.quickType(mentionText, [userJid]);
+    }
+
+    async normalTypeWithMention(text, userJid) {
+        const senderName = userJid.split('@')[0];
+        const mentionText = text.replace('@user', `@${senderName}`);
+        return await this.normalType(mentionText, [userJid]);
+    }
+
     // ===== PERMISSION SYSTEM =====
 
     async isAdmin() {

package/src/multi-client.js

@@ -7,6 +7,15 @@ export class MultiWhatsAppClient {
             maxDevices: options.maxDevices || 3,
             loadBalancing: options.loadBalancing || 'round-robin',
             syncEvents: options.syncEvents !== false,
+            
+            // ROBUSTE CONNECTION DEFAULTS - NEU!
+            maxReconnectAttempts: options.maxReconnectAttempts || 100,
+            reconnectInterval: options.reconnectInterval || 2000,
+            exponentialBackoff: options.exponentialBackoff !== false,
+            maxBackoffDelay: options.maxBackoffDelay || 30000,
+            heartbeatInterval: options.heartbeatInterval || 20000,
+            connectionTimeout: options.connectionTimeout || 180000,
+            keepAlive: options.keepAlive !== false,
             ...options
         });
         
@@ -17,7 +26,7 @@ export class MultiWhatsAppClient {
         // Device Manager Events weiterleiten
         this.setupDeviceManagerEvents();
         
-        console.log("🚀 MultiWhatsAppClient initialisiert");
+        console.log("🚀 MultiWhatsAppClient mit robusten Verbindungen initialisiert");
     }
 
     // ===== DEVICE MANAGEMENT =====
@@ -46,13 +55,61 @@ export class MultiWhatsAppClient {
     
     async connect(deviceIds = null) {
         if (deviceIds) {
-            // Spezifische Devices verbinden
-            const promises = deviceIds.map(id => this.deviceManager.connectDevice(id));
-            return await Promise.allSettled(promises);
+            // Spezifische Devices sequenziell verbinden
+            return await this.connectDevicesSequentially(deviceIds);
         } else {
-            // Alle Devices verbinden
-            return await this.deviceManager.connectAll();
+            // Alle Devices sequenziell verbinden
+            const allDeviceIds = Array.from(this.deviceManager.devices.keys());
+            return await this.connectDevicesSequentially(allDeviceIds);
+        }
+    }
+
+    // NEUE SEQUENZIELLE VERBINDUNG - Ein QR nach dem anderen!
+    async connectDevicesSequentially(deviceIds) {
+        console.log(`🔄 Sequenzielle Verbindung von ${deviceIds.length} Devices...`);
+        console.log("📱 QR-Codes werden nacheinander angezeigt - scanne einen nach dem anderen!");
+        
+        const results = [];
+        let connectedCount = 0;
+        
+        for (let i = 0; i < deviceIds.length; i++) {
+            const deviceId = deviceIds[i];
+            
+            try {
+                console.log(`\n📱 Device ${i + 1}/${deviceIds.length}: '${deviceId}'`);
+                console.log("⏳ Warte auf QR-Scan für dieses Device...");
+                
+                // Verbinde ein Device und warte bis es fertig ist
+                const client = await this.deviceManager.connectDevice(deviceId);
+                
+                console.log(`✅ Device '${deviceId}' erfolgreich verbunden!`);
+                connectedCount++;
+                results.push({ deviceId, status: 'connected', client });
+                
+                // Kurze Pause zwischen Devices
+                if (i < deviceIds.length - 1) {
+                    console.log("⏸️ Kurze Pause vor nächstem Device...");
+                    await new Promise(resolve => setTimeout(resolve, 2000));
+                }
+                
+            } catch (error) {
+                console.error(`❌ Device '${deviceId}' Verbindung fehlgeschlagen:`, error.message);
+                results.push({ deviceId, status: 'failed', error: error.message });
+                
+                // Frage ob weiter machen
+                console.log("❓ Soll mit dem nächsten Device fortgefahren werden? (Automatisch ja in 5s)");
+                await new Promise(resolve => setTimeout(resolve, 5000));
+            }
         }
+        
+        console.log(`\n🎉 Sequenzielle Verbindung abgeschlossen!`);
+        console.log(`✅ ${connectedCount}/${deviceIds.length} Devices erfolgreich verbunden`);
+        
+        if (connectedCount === 0) {
+            throw new Error("❌ Keine Devices konnten verbunden werden!");
+        }
+        
+        return results;
     }
 
     async disconnect(deviceIds = null) {