waengine 1.1.2 → 1.7.3

package/src/client.js

@@ -9,6 +9,7 @@ import { AIIntegration } from "./ai-integration.js";
 import { HTTPClient } from "./http-client.js";
 import { Scheduler } from "./scheduler.js";
 import { PluginManager } from "./plugin-manager-fixed.js";
+import { AdvancedGroup, AdvancedPrivacy, AdvancedAnalytics, AdvancedStatus, AdvancedBusiness, AdvancedSystem } from "./advanced-features.js";
 
 export class WhatsAppClient {
     constructor(options = {}) {
@@ -20,15 +21,43 @@ 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
+            quietHeartbeat: options.quietHeartbeat !== false, // Heartbeat-Logging deaktivieren
             ...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 +84,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,12 +105,84 @@ 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);
         this.kick = new KickAPI(this);
         this.promote = new PromoteAPI(this);
         this.demote = new DemoteAPI(this);
+
+        // ===== ADVANCED FEATURES INTEGRATION - NEU! =====
+        this.advancedGroup = new AdvancedGroup(this);
+        this.advancedPrivacy = new AdvancedPrivacy(this);
+        this.advancedAnalytics = new AdvancedAnalytics(this);
+        this.advancedStatus = new AdvancedStatus(this);
+        this.advancedBusiness = new AdvancedBusiness(this);
+        this.advancedSystem = new AdvancedSystem(this);
+
+        // Convenience Methods für Advanced Features
+        this.group = {
+            setSettings: this.advancedGroup.setGroupSettings.bind(this.advancedGroup),
+            setDescription: this.advancedGroup.setGroupDescription.bind(this.advancedGroup),
+            setSubject: this.advancedGroup.setGroupSubject.bind(this.advancedGroup),
+            getInviteLink: this.advancedGroup.getGroupInviteLink.bind(this.advancedGroup),
+            revokeInviteLink: this.advancedGroup.revokeGroupInviteLink.bind(this.advancedGroup),
+            join: this.advancedGroup.joinGroupViaLink.bind(this.advancedGroup),
+            leave: this.advancedGroup.leaveGroup.bind(this.advancedGroup),
+            updatePicture: this.advancedGroup.updateGroupPicture.bind(this.advancedGroup)
+        };
+
+        this.privacy = {
+            block: this.advancedPrivacy.blockUser.bind(this.advancedPrivacy),
+            unblock: this.advancedPrivacy.unblockUser.bind(this.advancedPrivacy),
+            setSettings: this.advancedPrivacy.setPrivacySettings.bind(this.advancedPrivacy),
+            markRead: this.advancedPrivacy.markAsRead.bind(this.advancedPrivacy),
+            markUnread: this.advancedPrivacy.markAsUnread.bind(this.advancedPrivacy)
+        };
+
+        this.analytics = {
+            getDeliveryStatus: this.advancedAnalytics.getDeliveryStatus.bind(this.advancedAnalytics),
+            isOnline: this.advancedAnalytics.isUserOnline.bind(this.advancedAnalytics),
+            getLastSeen: this.advancedAnalytics.getLastSeen.bind(this.advancedAnalytics),
+            archiveChat: this.advancedAnalytics.archiveChat.bind(this.advancedAnalytics),
+            unarchiveChat: this.advancedAnalytics.unarchiveChat.bind(this.advancedAnalytics),
+            muteChat: this.advancedAnalytics.muteChat.bind(this.advancedAnalytics),
+            unmuteChat: this.advancedAnalytics.unmuteChat.bind(this.advancedAnalytics)
+        };
+
+        this.status = {
+            send: this.advancedStatus.sendStatusUpdate.bind(this.advancedStatus),
+            getViews: this.advancedStatus.getStatusViews.bind(this.advancedStatus),
+            getUserStatus: this.advancedStatus.getUserStatus.bind(this.advancedStatus)
+        };
+
+        this.business = {
+            setProfile: this.advancedBusiness.setBusinessProfile.bind(this.advancedBusiness),
+            sendProduct: this.advancedBusiness.sendProductMessage.bind(this.advancedBusiness),
+            createProduct: this.advancedBusiness.createProduct.bind(this.advancedBusiness),
+            requestPayment: this.advancedBusiness.sendPaymentRequest.bind(this.advancedBusiness)
+        };
+
+        this.system = {
+            backup: this.advancedSystem.createBackup.bind(this.advancedSystem),
+            restore: this.advancedSystem.restoreFromBackup.bind(this.advancedSystem),
+            exportChat: this.advancedSystem.exportChat.bind(this.advancedSystem),
+            importContacts: this.advancedSystem.importContacts.bind(this.advancedSystem),
+            sync: this.advancedSystem.syncWithPhone.bind(this.advancedSystem),
+            getDevices: this.advancedSystem.getLinkedDevices.bind(this.advancedSystem),
+            unlinkDevice: this.advancedSystem.unlinkDevice.bind(this.advancedSystem)
+        };
     }
 
     // ===== CONNECTION METHODS =====
@@ -154,6 +262,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 +273,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 +301,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 +327,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 +345,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 +372,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 +401,218 @@ 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;
+                    
+                    // Nur bei Debug-Modus, langsamen Pings oder wenn quietHeartbeat deaktiviert ist
+                    if (!this.options.quietHeartbeat || this.options.logLevel === 'debug' || responseTime > 5000) {
+                        console.log(`💓 Heartbeat OK (${responseTime}ms)`);
+                    }
+                    
+                } catch (error) {
+                    this.connectionHealth.failedPings++;
+                    
+                    // Nur bei mehreren Fehlern, Debug-Modus oder wenn quietHeartbeat deaktiviert ist
+                    if (!this.options.quietHeartbeat || this.options.logLevel === 'debug' || this.connectionHealth.failedPings >= 2) {
+                        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 +719,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 || 
@@ -630,6 +1003,16 @@ class GetAPI {
         const participants = await this.GroupParticipants(groupId);
         return participants.filter(p => p.admin === 'admin' || p.admin === 'superadmin');
     }
+
+    // ===== PROFILE PICTURE API - NEU! =====
+    
+    async ProfilePicture(jid) {
+        try {
+            return await this.client.socket.profilePictureUrl(jid, 'image');
+        } catch (error) {
+            return null; // Kein Profilbild verfügbar
+        }
+    }
 }
 
 class AddAPI {

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