waengine 1.1.2 → 1.5.0

package/README.md

@@ -1,17 +1,18 @@
-# 🚀 WAEngine v1.1.0
+# 🚀 WAEngine v1.5.0
 
 [![NPM Version](https://img.shields.io/npm/v/waengine)](https://www.npmjs.com/package/waengine)
 [![Downloads](https://img.shields.io/npm/dm/waengine)](https://www.npmjs.com/package/waengine)
 [![License](https://img.shields.io/npm/l/waengine)](https://github.com/neotreydel-lab/waengine/blob/main/LICENSE)
 [![Node.js](https://img.shields.io/node/v/waengine)](https://nodejs.org/)
 
-**The most powerful WhatsApp Bot Library with Multi-Device Support & EasyBot API**
+**The most powerful WhatsApp Bot Library with Universal Cross-Platform Support**
 
-🎯 **Perfect for beginners AND professionals**  
-🔧 **Multi-Device Load Balancing**  
-⚡ **3-Line Bot Creation**  
-🚀 **150+ Features Built-in** ⬆️ **NEW in v1.1.0**  
-🔌 **Plugin System 2.0** ⬆️ **NEW in v1.1.0**
+🌍 **Universal Cross-Platform** - Works on ALL devices and platforms  
+🎯 **Sequential Multi-Device** - Professional QR scanning, one at a time  
+🧹 **Clean Terminal** - Anti-spam QR system, professional output  
+⚡ **3-Line Bot Creation** - From beginners to enterprise  
+🚀 **200+ Features Built-in** ⬆️ **NEW in v1.5.0**  
+🔌 **Plugin System 2.0** - 8 built-in plugins with hot-loading
 
 ---
 
@@ -41,32 +42,35 @@ npm install waengine
 
 ---
 
-## 🆕 What's New in v1.1.0
+## 🆕 What's New in v1.5.0
 
-### 🔌 **Plugin System 2.0**
-- **8 Built-in Plugins** - Economy, Games, Music, Travel, Analytics, Creative, Moderation, Education
-- **Hot-Loading** - Load/unload plugins at runtime
-- **Auto-Dependencies** - Automatic plugin dependency management
+### 🌍 **Universal Cross-Platform QR System**
+- **Works everywhere** - Windows, macOS, Linux, Docker, Raspberry Pi, Android
+- **Intelligent browser detection** - Edge, Chrome, Firefox, Safari auto-detection
+- **Smart fallback system** - Playwright → HTTP Server → Terminal QR
+- **ES Module fixes** - No more `require is not defined` errors
 
-### 🤖 **Enhanced EasyBot API**
-- **Action Chaining 2.0** - Media, AI, Storage, Scheduler actions
-- **150+ Functions** (was 125+)
-- **Advanced Media Support** - Images, videos, audio, stickers, documents
+### 🎯 **Sequential Multi-Device Setup**
+- **One QR at a time** - No more confusion with multiple QR codes
+- **Progress indicators** - Clear 1/3, 2/3, 3/3 progress
+- **Smart pauses** - 3 seconds between devices for preparation
+- **Error handling** - Continue on failure, robust setup
 
-### 🌐 **HTTP Client**
-- **Weather API** - Real-time weather data
-- **News API** - Latest news from multiple sources
-- **Crypto API** - Cryptocurrency prices
-- **25+ Endpoints** - URL shortener, QR codes, random facts
+### 🧹 **Clean QR System (Anti-Spam)**
+- **No terminal spam** - Max 3 QR displays, 30s intervals
+- **Multiple modes** - Clean, Terminal Only, Browser Only, Silent
+- **Professional output** - Terminal clearing, clean display
+- **Configurable** - Customize intervals, max displays, modes
 
-### 📅 **Scheduler System**
-- **Cron-based Scheduling** - Complex time patterns
-- **Template Variables** - Dynamic content in scheduled messages
-- **Persistent Jobs** - Survive bot restarts
+```javascript
+// v1.5.0 - Works on ALL platforms!
+import { quickBot } from "waengine";
 
-### ⏰ **Waiting System**
-- **msg.waiting.after.message()** - Realistic bot pauses
-- **Natural Conversations** - Human-like interaction timing
+quickBot()
+    .when("hello").reply("Hi! 👋")
+    .start();
+// ✅ QR-Code automatically optimized for your platform!
+```
 
 ---
 
@@ -85,7 +89,7 @@ createBot()
     .start();
 ```
 
-### 🔵 **Advanced API** - For Professionals
+### 🔧 **Advanced API** - For Professionals
 Full control and customization:
 
 ```javascript
@@ -94,6 +98,9 @@ import { WhatsAppClient } from "waengine";
 const client = new WhatsAppClient();
 client.setPrefix('!');
 
+// NEW: Ignore offline messages to prevent spam
+client.ignore.message.offline(true);
+
 client.on('message', async (msg) => {
     if (msg.text === 'hello') {
         await msg.simulateTyping('Hello! How can I help?');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waengine",
-  "version": "1.1.2",
+  "version": "1.5.0",
   "description": "🚀 WAEngine - The most powerful WhatsApp Bot Library with Multi-Device Support & EasyBot API",
   "main": "src/index.js",
   "type": "module",
@@ -60,11 +60,13 @@
     "axios": "^1.13.4",
     "node-cron": "^3.0.3",
     "pino": "^8.0.0",
-    "playwright": "^1.58.1",
     "qrcode": "^1.5.4",
     "qrcode-terminal": "^0.12.0",
     "sharp": "^0.33.5"
   },
+  "optionalDependencies": {
+    "playwright": "^1.58.1"
+  },
   "devDependencies": {
     "@types/node": "^20.0.0"
   },

package/src/client.js

@@ -20,15 +20,42 @@ export class WhatsAppClient {
             autoCleanup: options.autoCleanup !== false, // Auto-Cleanup bei Logout
             autoRestart: options.autoRestart !== false, // Auto-Restart nach Logout
             restartDelay: options.restartDelay || 5000, // 5 Sekunden Wartezeit
+            
+            // QR-SPAM PREVENTION - NEU!
+            qrSpamPrevention: options.qrSpamPrevention !== false, // Anti-Spam aktiviert
+            qrDisplayInterval: options.qrDisplayInterval || 30000, // 30 Sekunden zwischen QR-Anzeigen
+            qrMaxDisplays: options.qrMaxDisplays || 5, // Max 5 QR-Anzeigen im Terminal
+            clearTerminalOnQR: options.clearTerminalOnQR !== false, // Terminal bei QR leeren
+            
+            // ROBUSTE CONNECTION SETTINGS - NEU!
+            maxReconnectAttempts: options.maxReconnectAttempts || 50, // Viele Versuche
+            reconnectInterval: options.reconnectInterval || 3000, // 3 Sekunden zwischen Versuchen
+            exponentialBackoff: options.exponentialBackoff !== false, // Exponential backoff
+            maxBackoffDelay: options.maxBackoffDelay || 60000, // Max 1 Minute Wartezeit
+            heartbeatInterval: options.heartbeatInterval || 30000, // 30 Sekunden Heartbeat
+            connectionTimeout: options.connectionTimeout || 120000, // 2 Minuten Timeout (war 60s)
+            keepAlive: options.keepAlive !== false, // Keep-Alive aktiviert
             ...options
         };
         
         // Clean initialization
-        
         this.socket = null;
         this.isConnected = false;
         this.eventHandlers = new Map();
         
+        // ROBUSTE CONNECTION TRACKING - NEU!
+        this.reconnectAttempts = 0;
+        this.lastConnectionTime = null;
+        this.heartbeatTimer = null;
+        this.connectionWatchdog = null;
+        this.isReconnecting = false;
+        this.connectionHealth = {
+            lastPing: null,
+            pingCount: 0,
+            failedPings: 0,
+            avgResponseTime: 0
+        };
+        
         // Session Manager
         this.sessionManager = new SessionManager(this.options.authDir);
         
@@ -55,6 +82,13 @@ export class WhatsAppClient {
         // Plugin System
         this.plugins = new PluginManager(this);
         
+        // Offline Message Ignore System - NEU!
+        this.ignoreOfflineMessages = false;
+        this.lastOnlineTimestamp = Date.now();
+        this.connectionStartTime = null;
+        this.ignoredMessagesCount = 0; // Counter für ignorierte Messages
+        this.offlineMessageTimer = null; // Timer für finale Zusammenfassung
+        
         // Load API für Plugins
         this.load = {
             Plugins: async (pluginName) => {
@@ -69,6 +103,17 @@ export class WhatsAppClient {
             }
         };
         
+        // Ignore API für Offline Messages - DEINE COOLE API!
+        this.ignore = {
+            message: {
+                offline: (enabled = true) => {
+                    this.ignoreOfflineMessages = enabled;
+                    console.log(`📵 Offline Message Ignore: ${enabled ? 'AKTIVIERT' : 'DEAKTIVIERT'}`);
+                    return this;
+                }
+            }
+        };
+        
         // Deine eigenen API-Objekte
         this.get = new GetAPI(this);
         this.add = new AddAPI(this);
@@ -154,6 +199,7 @@ export class WhatsAppClient {
 
         // QR-Code Browser nur öffnen wenn nicht eingeloggt
         if (!this.options.printQR && !isLoggedIn) {
+            console.log("🌍 Starte universelles QR-System...");
             await generateQRCode();
         }
 
@@ -164,16 +210,22 @@ export class WhatsAppClient {
             this.socket.ev.on("connection.update", async ({ connection, lastDisconnect, qr }) => {
                 if (qr) {
                     if (this.options.printQR) {
-                        // Terminal QR
-                        console.log("\n📱 QR-CODE IM TERMINAL:");
-                        console.log("─".repeat(50));
+                        // Terminal QR (mit Anti-Spam)
+                        if (this.options.clearTerminalOnQR) {
+                            console.clear();
+                        }
+                        console.log("\n" + "=".repeat(60));
+                        console.log("📱 TERMINAL QR-CODE - SAUBER UND SPAM-FREI");
+                        console.log("=".repeat(60));
                         const qrcode = await import("qrcode-terminal");
                         qrcode.default.generate(qr, { small: true });
-                        console.log("─".repeat(50));
+                        console.log("=".repeat(60));
                         console.log("📲 Scanne den QR-Code mit WhatsApp!");
+                        console.log("💡 QR wird nur einmal angezeigt - kein Spam!");
+                        console.log("=".repeat(60));
                     } else {
-                        // Browser QR
-                        console.log("📱 QR-Code im Browser angezeigt");
+                        // Cross-Platform Browser QR (mit Anti-Spam)
+                        console.log("🌍 QR-Code wird intelligent angezeigt (Anti-Spam aktiv)...");
                         await generateQRCode(qr);
                     }
                 }
@@ -186,15 +238,22 @@ export class WhatsAppClient {
                     const statusCode = lastDisconnect?.error?.output?.statusCode;
                     const shouldReconnect = statusCode !== DisconnectReason.loggedOut;
                     
+                    // Cleanup timers
+                    this.stopHeartbeat();
+                    this.stopConnectionWatchdog();
+                    
                     if (shouldReconnect) {
-                        console.log("🔄 Wiederverbindung...");
+                        console.log(`🔄 Verbindung verloren (Code: ${statusCode}) - Starte robuste Wiederverbindung...`);
                         this.isConnected = false;
                         this.socket = null;
-                        setTimeout(() => this.connect().then(resolve).catch(reject), 3000);
+                        
+                        // Robuste Wiederverbindung mit exponential backoff
+                        this.startRobustReconnection(resolve, reject);
                     } else {
                         console.log("👋 Ausgeloggt - bereinige Session...");
                         this.isConnected = false;
                         this.socket = null;
+                        this.reconnectAttempts = 0;
                         
                         // Auto-Cleanup bei Logout
                         if (this.options.autoCleanup) {
@@ -205,31 +264,13 @@ export class WhatsAppClient {
                         await closeBrowser();
                         this.emit('disconnected', { reason: 'logged_out', cleaned: this.options.autoCleanup });
                         
-                        // Auto-Restart Feature
+                        // Auto-Restart Feature mit robuster Logik
                         if (this.options.autoRestart) {
                             console.log(`🔄 Auto-Restart in ${this.options.restartDelay / 1000} Sekunden...`);
                             console.log("📱 Neuer QR-Code wird generiert...");
                             
                             setTimeout(async () => {
-                                try {
-                                    console.log("🚀 Starte neue Session...");
-                                    await this.connect();
-                                    console.log("✅ Auto-Restart erfolgreich!");
-                                } catch (restartError) {
-                                    console.error("❌ Auto-Restart fehlgeschlagen:", restartError.message);
-                                    console.log("🔄 Versuche erneut in 10 Sekunden...");
-                                    
-                                    // Retry nach 10 Sekunden
-                                    setTimeout(async () => {
-                                        try {
-                                            await this.connect();
-                                            console.log("✅ Auto-Restart Retry erfolgreich!");
-                                        } catch (retryError) {
-                                            console.error("❌ Auto-Restart Retry fehlgeschlagen:", retryError.message);
-                                            console.log("⚠️ Manuelle Neustart erforderlich");
-                                        }
-                                    }, 10000);
-                                }
+                                await this.startRobustRestart(resolve, reject);
                             }, this.options.restartDelay);
                             
                             // Nicht rejecten bei Auto-Restart
@@ -241,7 +282,22 @@ export class WhatsAppClient {
                 } else if (connection === "open") {
                     console.log("✅ WhatsApp verbunden!");
                     this.isConnected = true;
+                    this.lastConnectionTime = Date.now();
+                    this.reconnectAttempts = 0; // Reset counter bei erfolgreicher Verbindung
+                    
+                    // Connection Start Time für Offline Message Ignore setzen
+                    this.connectionStartTime = Date.now();
+                    if (this.ignoreOfflineMessages) {
+                        console.log(`📵 Offline Messages werden ignoriert (seit ${new Date(this.connectionStartTime).toLocaleString()})`);
+                    }
+                    
                     await closeBrowser(); // QR Browser schließen
+                    
+                    // ROBUSTE CONNECTION FEATURES - NEU!
+                    this.startHeartbeat(); // Heartbeat starten
+                    this.startConnectionWatchdog(); // Connection Watchdog starten
+                    
+                    console.log("💪 Robuste Verbindung etabliert - 24/7 bereit!");
                     this.emit('connected');
                     
                     // 🔌 Plugins werden NICHT automatisch geladen
@@ -253,16 +309,26 @@ export class WhatsAppClient {
 
             this.socket.ev.on("creds.update", saveCreds);
             
+            // ROBUSTES TIMEOUT SYSTEM - NEU!
             setTimeout(() => {
                 if (!this.isConnected) {
-                    console.log("⏰ Verbindungs-Timeout");
-                    reject(new Error("Connection timeout"));
+                    console.log(`⏰ Verbindungs-Timeout nach ${this.options.connectionTimeout / 1000} Sekunden`);
+                    console.log("🔄 Starte robuste Wiederverbindung...");
+                    
+                    // Nicht sofort rejecten, sondern robuste Wiederverbindung versuchen
+                    this.startRobustReconnection(resolve, reject);
                 }
-            }, 60000);
+            }, this.options.connectionTimeout); // Längeres Timeout (2 Minuten statt 1)
         });
     }
 
     async disconnect() {
+        console.log("🔌 Trenne Verbindung...");
+        
+        // Cleanup timers
+        this.stopHeartbeat();
+        this.stopConnectionWatchdog();
+        
         if (this.socket) {
             this.socket.end();
             this.socket = null;
@@ -272,6 +338,211 @@ export class WhatsAppClient {
         }
     }
 
+    // ===== ROBUSTE CONNECTION METHODS - NEU! =====
+    
+    startHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+        }
+        
+        this.heartbeatTimer = setInterval(async () => {
+            if (this.isConnected && this.socket) {
+                try {
+                    const startTime = Date.now();
+                    
+                    // Ping WhatsApp Server
+                    await this.socket.query({
+                        tag: 'iq',
+                        attrs: { type: 'get', xmlns: 'w:p', id: 'ping' + Date.now() },
+                        content: [{ tag: 'ping' }]
+                    });
+                    
+                    const responseTime = Date.now() - startTime;
+                    this.connectionHealth.lastPing = Date.now();
+                    this.connectionHealth.pingCount++;
+                    this.connectionHealth.avgResponseTime = 
+                        (this.connectionHealth.avgResponseTime + responseTime) / 2;
+                    
+                    console.log(`💓 Heartbeat OK (${responseTime}ms)`);
+                    
+                } catch (error) {
+                    this.connectionHealth.failedPings++;
+                    console.log(`💔 Heartbeat failed (${this.connectionHealth.failedPings} failures)`);
+                    
+                    // Bei 3 fehlgeschlagenen Pings Wiederverbindung
+                    if (this.connectionHealth.failedPings >= 3) {
+                        console.log("🚨 Verbindung instabil - starte Wiederverbindung...");
+                        this.forceReconnect();
+                    }
+                }
+            }
+        }, this.options.heartbeatInterval);
+    }
+    
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    
+    startConnectionWatchdog() {
+        if (this.connectionWatchdog) {
+            clearInterval(this.connectionWatchdog);
+        }
+        
+        this.connectionWatchdog = setInterval(() => {
+            if (this.isConnected) {
+                const timeSinceLastPing = Date.now() - (this.connectionHealth.lastPing || 0);
+                
+                // Wenn länger als 2 Minuten kein Ping, Verbindung prüfen
+                if (timeSinceLastPing > 120000) {
+                    console.log("🔍 Connection Watchdog: Verbindung prüfen...");
+                    this.checkConnectionHealth();
+                }
+            }
+        }, 60000); // Jede Minute prüfen
+    }
+    
+    stopConnectionWatchdog() {
+        if (this.connectionWatchdog) {
+            clearInterval(this.connectionWatchdog);
+            this.connectionWatchdog = null;
+        }
+    }
+    
+    async checkConnectionHealth() {
+        try {
+            if (!this.socket || !this.isConnected) {
+                throw new Error("Socket not connected");
+            }
+            
+            // Test-Query senden
+            await this.socket.query({
+                tag: 'iq',
+                attrs: { type: 'get', xmlns: 'w:p', id: 'health' + Date.now() },
+                content: [{ tag: 'ping' }]
+            });
+            
+            console.log("✅ Connection Health Check OK");
+            this.connectionHealth.failedPings = 0; // Reset failures
+            
+        } catch (error) {
+            console.log("❌ Connection Health Check failed - starte Wiederverbindung...");
+            this.forceReconnect();
+        }
+    }
+    
+    async forceReconnect() {
+        if (this.isReconnecting) {
+            console.log("🔄 Wiederverbindung bereits aktiv...");
+            return;
+        }
+        
+        console.log("🔄 Erzwinge Wiederverbindung...");
+        this.isReconnecting = true;
+        this.isConnected = false;
+        
+        // Socket schließen
+        if (this.socket) {
+            try {
+                this.socket.end();
+            } catch (error) {
+                // Ignoriere Fehler beim Schließen
+            }
+            this.socket = null;
+        }
+        
+        // Robuste Wiederverbindung starten
+        setTimeout(async () => {
+            try {
+                await this.connect();
+                console.log("✅ Erzwungene Wiederverbindung erfolgreich!");
+            } catch (error) {
+                console.error("❌ Erzwungene Wiederverbindung fehlgeschlagen:", error.message);
+                this.startRobustReconnection();
+            } finally {
+                this.isReconnecting = false;
+            }
+        }, 2000);
+    }
+    
+    async startRobustReconnection(resolve = null, reject = null) {
+        if (this.isReconnecting) {
+            console.log("🔄 Robuste Wiederverbindung bereits aktiv...");
+            return;
+        }
+        
+        this.isReconnecting = true;
+        
+        const attemptReconnection = async () => {
+            if (this.reconnectAttempts >= this.options.maxReconnectAttempts) {
+                console.error(`❌ Maximale Wiederverbindungsversuche erreicht (${this.options.maxReconnectAttempts})`);
+                this.isReconnecting = false;
+                if (reject) reject(new Error('Max reconnection attempts reached'));
+                return;
+            }
+            
+            this.reconnectAttempts++;
+            
+            // Exponential backoff berechnen
+            let delay = this.options.reconnectInterval;
+            if (this.options.exponentialBackoff) {
+                delay = Math.min(
+                    this.options.reconnectInterval * Math.pow(2, this.reconnectAttempts - 1),
+                    this.options.maxBackoffDelay
+                );
+            }
+            
+            console.log(`🔄 Wiederverbindungsversuch ${this.reconnectAttempts}/${this.options.maxReconnectAttempts} in ${delay / 1000}s...`);
+            
+            setTimeout(async () => {
+                try {
+                    await this.connect();
+                    console.log(`✅ Robuste Wiederverbindung erfolgreich nach ${this.reconnectAttempts} Versuchen!`);
+                    this.isReconnecting = false;
+                    if (resolve) resolve(this);
+                } catch (error) {
+                    console.log(`❌ Wiederverbindungsversuch ${this.reconnectAttempts} fehlgeschlagen: ${error.message}`);
+                    attemptReconnection(); // Nächster Versuch
+                }
+            }, delay);
+        };
+        
+        attemptReconnection();
+    }
+    
+    async startRobustRestart(resolve = null, reject = null) {
+        const maxRestartAttempts = 5;
+        let restartAttempts = 0;
+        
+        const attemptRestart = async () => {
+            if (restartAttempts >= maxRestartAttempts) {
+                console.error(`❌ Maximale Restart-Versuche erreicht (${maxRestartAttempts})`);
+                if (reject) reject(new Error('Max restart attempts reached'));
+                return;
+            }
+            
+            restartAttempts++;
+            console.log(`🚀 Restart-Versuch ${restartAttempts}/${maxRestartAttempts}...`);
+            
+            try {
+                await this.connect();
+                console.log(`✅ Robuster Restart erfolgreich nach ${restartAttempts} Versuchen!`);
+                if (resolve) resolve(this);
+            } catch (restartError) {
+                console.error(`❌ Restart-Versuch ${restartAttempts} fehlgeschlagen:`, restartError.message);
+                
+                const delay = 10000 * restartAttempts; // Längere Wartezeit bei jedem Versuch
+                console.log(`🔄 Nächster Restart-Versuch in ${delay / 1000} Sekunden...`);
+                
+                setTimeout(attemptRestart, delay);
+            }
+        };
+        
+        attemptRestart();
+    }
+
     // ===== AUTO-RESTART SYSTEM =====
     
     enableAutoRestart(enabled = true, delay = 5000) {
@@ -378,6 +649,38 @@ export class WhatsAppClient {
                 // Bessere Message-Validierung
                 if (!msg.message || msg.key.fromMe) return;
                 
+                // OFFLINE MESSAGE IGNORE - DEINE NEUE FUNKTION!
+                if (this.ignoreOfflineMessages && this.connectionStartTime) {
+                    const messageTimestamp = msg.messageTimestamp * 1000; // Convert to milliseconds
+                    
+                    // Ignoriere Messages die vor der Verbindung gesendet wurden
+                    if (messageTimestamp < this.connectionStartTime) {
+                        this.ignoredMessagesCount++;
+                        
+                        // Nur alle 10 Messages oder bei der ersten Message loggen
+                        if (this.ignoredMessagesCount === 1) {
+                            console.log(`📵 Offline Messages werden ignoriert...`);
+                        } else if (this.ignoredMessagesCount % 10 === 0) {
+                            console.log(`📵 ${this.ignoredMessagesCount} Offline Messages ignoriert...`);
+                        }
+                        
+                        // Timer für finale Zusammenfassung zurücksetzen
+                        if (this.offlineMessageTimer) {
+                            clearTimeout(this.offlineMessageTimer);
+                        }
+                        
+                        // Nach 3 Sekunden ohne neue Offline Messages finale Zusammenfassung
+                        this.offlineMessageTimer = setTimeout(() => {
+                            if (this.ignoredMessagesCount > 0) {
+                                console.log(`✅ Insgesamt ${this.ignoredMessagesCount} Offline Messages ignoriert`);
+                                this.ignoredMessagesCount = 0; // Reset counter
+                            }
+                        }, 3000);
+                        
+                        return;
+                    }
+                }
+                
                 // Ignoriere System-Messages (protocolMessage, etc.)
                 if (msg.message.protocolMessage || 
                     msg.message.reactionMessage || 

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) {