waengine 1.7.3 → 1.7.4

package/src/client.js

@@ -10,22 +10,49 @@ 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";
+import { ConsoleLogger } from "./console-logger.js";
+import { ErrorHandler } from "./error-handler.js";
+import { BusinessManager } from "./business-manager.js";
+import { AnalyticsManager } from "./analytics-manager.js";
+import { UIComponents } from "./ui-components.js";
 
 export class WhatsAppClient {
     constructor(options = {}) {
+        // SCHÖNE CONSOLE LOGGER - IMMER AKTIV!
+        this.logger = new ConsoleLogger({
+            verbose: options.verbose || false,
+            silent: options.silent || false
+        });
+        
+        // ERROR HANDLER SYSTEM - IMMER AKTIV MIT DEINER EMAIL!
+        this.errorHandler = new ErrorHandler({
+            supportEmail: "Liaia@outlook.de", // DEINE EMAIL - IMMER ANGEZEIGT
+            supportDiscord: "https://discord.gg/waengine",
+            supportGitHub: "https://github.com/neotreydel-lab/waengine/issues",
+            showSupportInfo: true, // IMMER Support-Info anzeigen
+            logErrors: true,       // IMMER Fehler loggen
+            sendErrorReports: false,
+            // User kann nur zusätzliche Kontakte hinzufügen, nicht deine ersetzen
+            ...options.errorHandler
+        });
+        
         this.options = {
             authDir: "./auth",
-            printQR: false,
+            printQR: true,  // Terminal QR als Standard (einfacher)
             browser: options.browser || ["Chrome", "121.0.0", ""], // Aktueller Chrome
             logLevel: options.logLevel || "silent", // Sauber ohne Debug
             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!
+            // SINGLE DEVICE MODE - NEU! (Multi-Device nur bei expliziter Aktivierung)
+            singleDeviceMode: options.singleDeviceMode !== false, // Single Device als Standard
+            disableMultiDevice: options.disableMultiDevice !== false, // Multi-Device deaktiviert
+            
+            // QR-SPAM PREVENTION - VERBESSERT!
             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
+            qrMaxDisplays: options.qrMaxDisplays || 1, // NUR 1 QR-Anzeige im Terminal (Standard)
             clearTerminalOnQR: options.clearTerminalOnQR !== false, // Terminal bei QR leeren
             
             // ROBUSTE CONNECTION SETTINGS - NEU!
@@ -40,6 +67,9 @@ export class WhatsAppClient {
             ...options
         };
         
+        // SCHÖNER BANNER FÜR ALLE USER!
+        this.logger.showBanner();
+        
         // Clean initialization
         this.socket = null;
         this.isConnected = false;
@@ -51,6 +81,7 @@ export class WhatsAppClient {
         this.heartbeatTimer = null;
         this.connectionWatchdog = null;
         this.isReconnecting = false;
+        this.hasShownAuthSuccess = false; // Verhindere mehrfache Success-Messages
         this.connectionHealth = {
             lastPing: null,
             pingCount: 0,
@@ -84,6 +115,11 @@ export class WhatsAppClient {
         // Plugin System
         this.plugins = new PluginManager(this);
         
+        // NEW ADVANCED SYSTEMS - v1.8.0!
+        this.business = new BusinessManager(this);
+        this.analyticsManager = new AnalyticsManager(this);  // Umbenennen um Konflikt zu vermeiden
+        this.ui = new UIComponents(this);
+        
         // Offline Message Ignore System - NEU!
         this.ignoreOfflineMessages = false;
         this.lastOnlineTimestamp = Date.now();
@@ -188,30 +224,77 @@ export class WhatsAppClient {
     // ===== CONNECTION METHODS =====
     
     async connect() {
-        console.log("🔌 WAEngine startet...");
-        
         if (this.socket && this.isConnected) {
             return this.socket;
         }
 
-        // Session-Validierung und Auto-Repair
+        // Reset Auth Success Flag für neue Verbindung
+        this.hasShownAuthSuccess = false;
+
+        // SCHNELLE SETUP ANIMATION - PARALLEL STATT SEQUENZIELL!
+        const setupPromise = this.logger.animateSetup();
+
+        // Session-Validierung und Auto-Repair mit robuster Windows-Behandlung
         await this.sessionManager.ensureAuthDir();
         const sessionValidation = await this.sessionManager.validateSession();
         
+        // WICHTIGER SESSION-CHECK für QR-Code Prevention
+        const hasValidSession = sessionValidation.valid && sessionValidation.userId;
+        
+        if (hasValidSession) {
+            this.logger.success(`✅ Gültige Session gefunden (User: ${sessionValidation.userId})`);
+            this.logger.info("🔄 Verbinde direkt ohne QR-Code...");
+        } else {
+            this.logger.info("📱 Keine gültige Session - QR-Code wird benötigt");
+        }
+        
         if (!sessionValidation.valid) {
-            console.log(`📋 Session-Status: ${sessionValidation.reason}`);
+            this.logger.warning(`⚠️ Session-Status: ${sessionValidation.reason}`);
             
-            if (sessionValidation.reason === 'corrupted') {
-                console.log("🔧 Repariere korrupte Session...");
-                await this.sessionManager.repairSession();
+            // Erweiterte Session-Reparatur mit besserer Fehlerbehandlung
+            if (['corrupted_creds', 'empty_creds', 'incomplete_creds', 'corrupted', 'validation_error'].includes(sessionValidation.reason)) {
+                this.logger.info("🔧 Repariere korrupte Session...");
+                
+                try {
+                    const repairResult = await this.sessionManager.autoRepairSession();
+                    
+                    if (repairResult.repaired) {
+                        this.logger.success(`✅ Session repariert: ${repairResult.action}`);
+                        
+                        // Nach erfolgreicher Reparatur kurz warten
+                        await new Promise(resolve => setTimeout(resolve, 1000));
+                    } else {
+                        this.logger.warning(`⚠️ Session-Reparatur fehlgeschlagen: ${repairResult.reason || 'Unbekannt'}`);
+                        
+                        // Fallback: Smart Cleanup
+                        this.logger.info("🧹 Versuche intelligente Bereinigung...");
+                        const cleanupResult = await this.sessionManager.smartCleanup();
+                        
+                        if (cleanupResult.cleaned) {
+                            this.logger.success("✅ Session bereinigt - neuer QR-Code wird generiert");
+                        }
+                    }
+                } catch (repairError) {
+                    this.logger.error(`❌ Session-Reparatur Fehler: ${repairError.message}`);
+                    this.logger.info("🔄 Fahre mit neuer Session fort...");
+                }
             }
-        } else {
-            console.log(`✅ Gültige Session gefunden (User: ${sessionValidation.userId})`);
         }
 
         const { state, saveCreds } = await useMultiFileAuthState(this.options.authDir);
         const isLoggedIn = !!state.creds?.me?.id;
 
+        // WICHTIG: Session-Check BEVOR QR-Code angezeigt wird
+        if (isLoggedIn) {
+            this.logger.success(`✅ Bestehende Session gefunden - überspringe QR-Code`);
+            this.logger.info("🔄 Verbinde direkt mit bestehender Session...");
+        } else {
+            this.logger.info("📱 Keine Session gefunden - QR-Code wird benötigt");
+        }
+        
+        // Session-Status für QR-Check speichern
+        this.hasExistingSession = isLoggedIn;
+
         // Fetch latest Baileys version for compatibility
         try {
             const { version, isLatest } = await fetchLatestBaileysVersion();
@@ -258,13 +341,13 @@ export class WhatsAppClient {
             });
         }
 
-        console.log("🔌 WAEngine startet...");
+        // Setup Animation abwarten (läuft parallel)
+        await setupPromise;
 
-        // QR-Code Browser nur öffnen wenn nicht eingeloggt
-        if (!this.options.printQR && !isLoggedIn) {
-            console.log("🌍 Starte universelles QR-System...");
-            await generateQRCode();
-        }
+        // QR-Code Browser NICHT automatisch öffnen - nur bei expliziter Anfrage
+        // if (!this.options.printQR && !isLoggedIn) {
+        //     await generateQRCode();
+        // }
 
         return new Promise((resolve, reject) => {
             // Event-Handler SOFORT registrieren, nicht erst bei "open"
@@ -272,29 +355,66 @@ export class WhatsAppClient {
             
             this.socket.ev.on("connection.update", async ({ connection, lastDisconnect, qr }) => {
                 if (qr) {
-                    if (this.options.printQR) {
-                        // 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));
+                    // WICHTIGER CHECK: Nur QR-Code anzeigen wenn KEINE Session existiert
+                    if (this.hasExistingSession) {
+                        console.log("✅ Session bereits vorhanden - überspringe QR-Code");
+                        return; // KEIN QR-Code bei bestehender Session!
+                    }
+                    
+                    // SINGLE QR-CODE DISPLAY - NUR BEI NEUER SESSION!
+                    console.clear();
+                    console.log("\n" + "=".repeat(50));
+                    console.log("📱 WAEngine QR-Code - Einmal scannen und fertig!");
+                    console.log("=".repeat(50));
+                    
+                    // Terminal-Größe prüfen
+                    const terminalWidth = process.stdout.columns || 80;
+                    const terminalHeight = process.stdout.rows || 24;
+                    console.log(`🖥️ Terminal: ${terminalWidth}x${terminalHeight}`);
+                    
+                    if (terminalWidth < 60) {
+                        console.log("⚠️ Terminal zu schmal - verwende extra kleinen QR!");
+                    }
+                    
+                    console.log("");
+                    
+                    // QR-Code IMMER KLEIN anzeigen (wegen "zu groß" Problem)
+                    try {
                         const qrcode = await import("qrcode-terminal");
+                        // IMMER small: true verwenden - auch bei großen Terminals
                         qrcode.default.generate(qr, { small: true });
-                        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 {
-                        // Cross-Platform Browser QR (mit Anti-Spam)
-                        console.log("🌍 QR-Code wird intelligent angezeigt (Anti-Spam aktiv)...");
-                        await generateQRCode(qr);
+                    } catch (error) {
+                        console.log("❌ QR-Terminal Fehler:", error.message);
+                        console.log("📱 QR-Data für externe App:");
+                        console.log(qr);
+                    }
+                    
+                    console.log("");
+                    console.log("=".repeat(50));
+                    console.log("📲 WhatsApp Anleitung:");
+                    console.log("1. WhatsApp öffnen");
+                    console.log("2. Einstellungen → Verknüpfte Geräte");
+                    console.log("3. Gerät verknüpfen → QR scannen");
+                    console.log("=".repeat(50));
+                    console.log("⏳ Warte auf QR-Scan...");
+                    console.log("");
+                    
+                    // Browser QR nur wenn explizit gewünscht (nicht automatisch)
+                    if (!this.options.printQR && this.options.enableBrowserQR) {
+                        await generateQRCode(qr, { skipBrowser: false });
                     }
+                    
+                    // QR Event emittieren für externe Handler
+                    this.emit('qr', qr);
                 }
                 
                 if (connection === "connecting") {
-                    console.log("🔄 Verbinde...");
+                    // Nur Status-Info, KEINE Animation bei connecting (zu früh!)
+                    if (!this.hasExistingSession) {
+                        console.log("🔄 Verbindung wird hergestellt...");
+                    } else {
+                        console.log("🔄 Verbinde mit bestehender Session...");
+                    }
                 }
                 
                 if (connection === "close") {
@@ -343,7 +463,33 @@ export class WhatsAppClient {
                         }
                     }
                 } else if (connection === "open") {
-                    console.log("✅ WhatsApp verbunden!");
+                    // ROBUSTE SESSION-VALIDIERUNG: Prüfe ECHTE Authentifizierung!
+                    const isAuthenticated = !!state.creds?.me?.id;
+                    
+                    if (!isAuthenticated) {
+                        // Socket ist offen, aber KEINE Authentifizierung - warte auf QR-Scan
+                        console.log("🔌 Socket verbunden - warte auf Authentifizierung...");
+                        
+                        // Prüfe ob auth-Ordner existiert
+                        const authExists = this.sessionManager.hasAuthFolder();
+                        if (!authExists) {
+                            console.log("📁 Kein Auth-Ordner gefunden - neue Session wird erstellt");
+                            console.log("📱 Bereit für QR-Code Scan...");
+                        } else {
+                            console.log("📁 Auth-Ordner existiert - prüfe Credentials...");
+                        }
+                        
+                        // Zeige Socket-Status aber KEINE Success-Messages oder Animations
+                        this.logger.showDeviceConnected('main-bot', false);
+                        this.logger.showFinalSummary(['main-bot'], false);
+                        
+                        // KEINE Success-Messages bei nicht-authentifizierter Verbindung!
+                        return;
+                    }
+                    
+                    // NUR BEI ECHTER AUTHENTIFIZIERUNG: Success Messages!
+                    // ABER: Animation und Summary werden jetzt im creds.update Handler gemacht
+                    this.logger.success("WhatsApp erfolgreich authentifiziert!");
                     this.isConnected = true;
                     this.lastConnectionTime = Date.now();
                     this.reconnectAttempts = 0; // Reset counter bei erfolgreicher Verbindung
@@ -351,7 +497,7 @@ export class WhatsAppClient {
                     // 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()})`);
+                        this.logger.info(`Offline Messages werden ignoriert (seit ${new Date(this.connectionStartTime).toLocaleString()})`);
                     }
                     
                     await closeBrowser(); // QR Browser schließen
@@ -360,7 +506,7 @@ export class WhatsAppClient {
                     this.startHeartbeat(); // Heartbeat starten
                     this.startConnectionWatchdog(); // Connection Watchdog starten
                     
-                    console.log("💪 Robuste Verbindung etabliert - 24/7 bereit!");
+                    // Animation und Summary werden im creds.update Handler gemacht!
                     this.emit('connected');
                     
                     // 🔌 Plugins werden NICHT automatisch geladen
@@ -370,7 +516,25 @@ export class WhatsAppClient {
                 }
             });
 
-            this.socket.ev.on("creds.update", saveCreds);
+            this.socket.ev.on("creds.update", async (creds) => {
+                await saveCreds();
+                
+                // WICHTIG: Prüfe ob User jetzt authentifiziert ist (QR-Code gescannt)
+                if (creds?.me?.id && this.isConnected && !this.hasShownAuthSuccess) {
+                    this.hasShownAuthSuccess = true; // Verhindere mehrfache Success-Messages
+                    
+                    console.log("🎉 QR-Code erfolgreich gescannt!");
+                    console.log(`👤 Authentifiziert als: ${creds.me.id}`);
+                    
+                    // JETZT erst die Connection Animation - nach echter Authentifizierung!
+                    await this.logger.animateConnection('main-bot', true);
+                    
+                    // Jetzt erst die echten Success-Messages zeigen
+                    this.logger.success("WhatsApp erfolgreich authentifiziert!");
+                    this.logger.showFinalSummary(['main-bot'], true);
+                    this.emit('truly_connected', { userId: creds.me.id });
+                }
+            });
             
             // ROBUSTES TIMEOUT SYSTEM - NEU!
             setTimeout(() => {
@@ -498,6 +662,7 @@ export class WhatsAppClient {
             this.connectionHealth.failedPings = 0; // Reset failures
             
         } catch (error) {
+            this.errorHandler.handleConnectionError(error, this.reconnectAttempts);
             console.log("❌ Connection Health Check failed - starte Wiederverbindung...");
             this.forceReconnect();
         }
@@ -529,6 +694,7 @@ export class WhatsAppClient {
                 await this.connect();
                 console.log("✅ Erzwungene Wiederverbindung erfolgreich!");
             } catch (error) {
+                this.errorHandler.handleConnectionError(error, this.reconnectAttempts);
                 console.error("❌ Erzwungene Wiederverbindung fehlgeschlagen:", error.message);
                 this.startRobustReconnection();
             } finally {
@@ -573,6 +739,7 @@ export class WhatsAppClient {
                     this.isReconnecting = false;
                     if (resolve) resolve(this);
                 } catch (error) {
+                    this.errorHandler.handleConnectionError(error, this.reconnectAttempts);
                     console.log(`❌ Wiederverbindungsversuch ${this.reconnectAttempts} fehlgeschlagen: ${error.message}`);
                     attemptReconnection(); // Nächster Versuch
                 }
@@ -703,6 +870,11 @@ export class WhatsAppClient {
                 try {
                     handler(data);
                 } catch (error) {
+                    this.errorHandler.handleError(error, {
+                        action: 'event_handler',
+                        event: event,
+                        details: `Event '${event}' Handler Fehler`
+                    });
                     console.error(`❌ Error in event handler for '${event}':`, error);
                 }
             });
@@ -801,6 +973,7 @@ export class WhatsAppClient {
                             try {
                                 handler(messageObj, commandData.args);
                             } catch (error) {
+                                this.errorHandler.handleCommandError(error, commandData.command, messageObj.getSender());
                                 console.error(`❌ Fehler in Command '${commandData.command}':`, error);
                             }
                         }
@@ -957,6 +1130,12 @@ export class WhatsAppClient {
             await this.socket.sendPresenceUpdate(presence, chatId);
             return true;
         } catch (error) {
+            this.errorHandler.handleError(error, {
+                action: 'presence_update',
+                presence: presence,
+                chatId: chatId,
+                details: `Presence '${presence}' setzen fehlgeschlagen`
+            });
             console.error(`❌ Fehler beim Setzen der Presence '${presence}':`, error);
             return false;
         }
@@ -1093,4 +1272,233 @@ class DemoteAPI {
 
         return result;
     }
+
+    // ===== HEARTBEAT SYSTEM =====
+    
+    startHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+        }
+        
+        this.heartbeatTimer = setInterval(async () => {
+            try {
+                if (this.socket && this.socket.ws && this.socket.ws.readyState === 1) {
+                    // Sende Ping
+                    await this.socket.query({
+                        tag: 'iq',
+                        attrs: { type: 'get', to: 's.whatsapp.net' },
+                        content: [{ tag: 'ping', attrs: {} }]
+                    });
+                }
+            } catch (error) {
+                console.log('⚠️ Heartbeat fehlgeschlagen:', error.message);
+                if (this.options.autoReconnect) {
+                    this.startRobustReconnection();
+                }
+            }
+        }, this.options.heartbeatInterval);
+    }
+
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+
+    // ===== CLEANUP METHODS =====
+    
+    async cleanup() {
+        try {
+            console.log('🧹 Bereinige Client-Ressourcen...');
+            
+            // Timer stoppen
+            this.stopHeartbeat();
+            
+            // Socket schließen
+            if (this.socket) {
+                try {
+                    await this.socket.logout();
+                } catch (logoutError) {
+                    // Stille Behandlung
+                }
+                this.socket = null;
+            }
+            
+            // Event-Listener entfernen
+            this.removeAllListeners();
+            
+            // Flags zurücksetzen
+            this.isConnected = false;
+            this.isReconnecting = false;
+            this.reconnectAttempts = 0;
+            
+            console.log('✅ Client-Ressourcen bereinigt');
+        } catch (error) {
+            console.error('❌ Fehler beim Bereinigen:', error);
+        }
+    }
+
+    // ===== UTILITY METHODS =====
+    
+    getConnectionStatus() {
+        return {
+            connected: this.isConnected,
+            reconnecting: this.isReconnecting,
+            attempts: this.reconnectAttempts,
+            userId: this.userId,
+            uptime: this.startTime ? Date.now() - this.startTime : 0
+        };
+    }
+
+    async waitForConnection(timeout = 30000) {
+        return new Promise((resolve, reject) => {
+            if (this.isConnected) {
+                resolve(this);
+                return;
+            }
+            
+            const timeoutId = setTimeout(() => {
+                reject(new Error('Connection timeout'));
+            }, timeout);
+            
+            const checkConnection = () => {
+                if (this.isConnected) {
+                    clearTimeout(timeoutId);
+                    resolve(this);
+                } else {
+                    setTimeout(checkConnection, 100);
+                }
+            };
+            
+            checkConnection();
+        });
+    }
+
+    // ===== ERROR RECOVERY =====
+    
+    async recoverFromError(error) {
+        console.log('🔧 Versuche Fehler-Recovery...');
+        
+        try {
+            // Session-Probleme
+            if (error.message.includes('creds') || error.message.includes('session')) {
+                console.log('🔄 Session-Recovery...');
+                const repairResult = await this.sessionManager.autoRepairSession();
+                if (repairResult.repaired) {
+                    return await this.connect();
+                }
+            }
+            
+            // Verbindungsprobleme
+            if (error.message.includes('connection') || error.message.includes('socket')) {
+                console.log('🔄 Verbindungs-Recovery...');
+                if (this.options.autoReconnect) {
+                    return this.startRobustReconnection();
+                }
+            }
+            
+            // QR-Code-Probleme
+            if (error.message.includes('qr') || error.message.includes('QR')) {
+                console.log('🔄 QR-Code-Recovery...');
+                await this.sessionManager.cleanupSession();
+                return await this.connect();
+            }
+            
+            throw error; // Unbekannter Fehler
+            
+        } catch (recoveryError) {
+            console.error('❌ Fehler-Recovery fehlgeschlagen:', recoveryError);
+            throw recoveryError;
+        }
+    }
+
+    // ===== GRACEFUL SHUTDOWN =====
+    
+    async gracefulShutdown() {
+        console.log('🛑 Starte graceful shutdown...');
+        
+        try {
+            // Stoppe neue Verbindungen
+            this.options.autoReconnect = false;
+            this.options.autoRestart = false;
+            
+            // Bereinige Ressourcen
+            await this.cleanup();
+            
+            console.log('✅ Graceful shutdown abgeschlossen');
+        } catch (error) {
+            console.error('❌ Fehler beim graceful shutdown:', error);
+        }
+    }
 }
+
+// ===== PROCESS EVENT HANDLERS =====
+
+// Graceful shutdown bei SIGINT/SIGTERM
+process.on('SIGINT', async () => {
+    console.log('\n🛑 SIGINT empfangen - starte graceful shutdown...');
+    if (global.waengineClient) {
+        await global.waengineClient.gracefulShutdown();
+    }
+    process.exit(0);
+});
+
+process.on('SIGTERM', async () => {
+    console.log('\n🛑 SIGTERM empfangen - starte graceful shutdown...');
+    if (global.waengineClient) {
+        await global.waengineClient.gracefulShutdown();
+    }
+    process.exit(0);
+});
+
+// Unhandled Promise Rejections
+process.on('unhandledRejection', (reason, promise) => {
+    console.error('❌ Unhandled Promise Rejection:', reason);
+    if (global.waengineClient && global.waengineClient.errorHandler) {
+        global.waengineClient.errorHandler.handleError(reason, { type: 'unhandledRejection' });
+    }
+});
+
+// Uncaught Exceptions
+process.on('uncaughtException', (error) => {
+    console.error('❌ Uncaught Exception:', error);
+    if (global.waengineClient && global.waengineClient.errorHandler) {
+        global.waengineClient.errorHandler.handleError(error, { type: 'uncaughtException' });
+    }
+    
+    // Graceful shutdown bei kritischen Fehlern
+    if (global.waengineClient) {
+        global.waengineClient.gracefulShutdown().then(() => {
+            process.exit(1);
+        });
+    } else {
+        process.exit(1);
+    }
+});
+
+
+// Unhandled Promise Rejections
+process.on('unhandledRejection', (reason, promise) => {
+    console.error('❌ Unhandled Promise Rejection:', reason);
+    if (global.waengineClient && global.waengineClient.errorHandler) {
+        global.waengineClient.errorHandler.handleError(reason, { type: 'unhandledRejection' });
+    }
+});
+
+// Uncaught Exceptions
+process.on('uncaughtException', (error) => {
+    console.error('❌ Uncaught Exception:', error);
+    if (global.waengineClient && global.waengineClient.errorHandler) {
+        global.waengineClient.errorHandler.handleError(error, { type: 'uncaughtException' });
+    }
+    
+    // Graceful shutdown bei kritischen Fehlern
+    if (global.waengineClient) {
+        global.waengineClient.gracefulShutdown().then(() => {
+            process.exit(1);
+        });
+    } else {
+        process.exit(1);
+    }
+});