waengine 1.7.3 → 1.7.4

package/src/http-client.js

@@ -13,7 +13,7 @@ export class HTTPClient {
             headers: this.baseHeaders
         });
         
-        console.log('🌐 HTTP Client initialisiert');
+        // Stille Initialisierung - keine Console-Spam
     }
 
     // ===== BASIC HTTP METHODS =====

package/src/index.js

@@ -11,6 +11,8 @@ 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";
+export { ConsoleLogger, logger } from "./console-logger.js";
+export { ErrorHandler, defaultErrorHandler } from "./error-handler.js";
 
 // ===== ADVANCED FEATURES EXPORTS - NEU! =====
 export { 
@@ -28,3 +30,16 @@ export { EasyAdvanced, EasyAdvancedRule } from "./easy-advanced.js";
 // NEUE ROBUSTE FACTORY METHODS - NEU!
 export const createRobustBot = () => EasyBot.createRobust();
 export const createUltraRobustBot = () => EasyBot.createRobust().enableUltraRobust();
+
+// ===== NEUE ADVANCED MANAGER EXPORTS =====
+export { BusinessManager } from "./business-manager.js";
+export { AnalyticsManager } from "./analytics-manager.js";
+export { UIComponents } from "./ui-components.js";
+export { AIFeatures } from "./ai-features.js";
+export { CrossPlatformIntegration as CrossPlatform } from "./cross-platform.js";
+export { SecurityManager } from "./security-manager.js";
+export { AdvancedScheduler } from "./advanced-scheduler.js";
+export { GamingManager } from "./gaming-manager.js";
+export { DatabaseManager } from "./database-manager.js";
+export { ABTestingManager } from "./ab-testing.js";
+export { ReportingManager } from "./reporting-manager.js";

package/src/message.js

@@ -80,42 +80,62 @@ export class Message {
                 hiddenMentions = [options.hidetag];
             }
 
-            return await this.client.socket.sendMessage(this.from, {
-                text: text,
-                mentions: [...mentions, ...hiddenMentions]
-            });
+            try {
+                return await this.client.socket.sendMessage(this.from, {
+                    text: text,
+                    mentions: [...mentions, ...hiddenMentions]
+                });
+            } catch (error) {
+                console.error('❌ Fehler beim Senden der Hidetag-Nachricht:', error);
+                throw error;
+            }
         }
 
         // Normale Reply
-        if (mentions.length > 0) {
+        try {
+            if (mentions.length > 0) {
+                return await this.client.socket.sendMessage(this.from, {
+                    text: text,
+                    mentions: mentions
+                });
+            }
+            
             return await this.client.socket.sendMessage(this.from, {
-                text: text,
-                mentions: mentions
+                text: text
             });
+        } catch (error) {
+            console.error('❌ Fehler beim Senden der Nachricht:', error);
+            throw error;
         }
-        
-        return await this.client.socket.sendMessage(this.from, {
-            text: text
-        });
     }
 
     async sendImage(imagePath, caption = "", mentions = []) {
-        const message = {
-            image: { url: imagePath },
-            caption: caption
-        };
+        try {
+            const message = {
+                image: { url: imagePath },
+                caption: caption
+            };
 
-        if (mentions.length > 0) {
-            message.mentions = mentions;
-        }
+            if (mentions.length > 0) {
+                message.mentions = mentions;
+            }
 
-        return await this.client.socket.sendMessage(this.from, message);
+            return await this.client.socket.sendMessage(this.from, message);
+        } catch (error) {
+            console.error('❌ Fehler beim Senden des Bildes:', error);
+            throw error;
+        }
     }
 
     async sendSticker(stickerPath) {
-        return await this.client.socket.sendMessage(this.from, {
-            sticker: { url: stickerPath }
-        });
+        try {
+            return await this.client.socket.sendMessage(this.from, {
+                sticker: { url: stickerPath }
+            });
+        } catch (error) {
+            console.error('❌ Fehler beim Senden des Stickers:', error);
+            throw error;
+        }
     }
 
     // ===== PROFILE PICTURE FUNCTIONS - NEU! =====
@@ -152,23 +172,33 @@ export class Message {
     }
 
     async sendAudio(audioPath) {
-        return await this.client.socket.sendMessage(this.from, {
-            audio: { url: audioPath },
-            mimetype: 'audio/mp4'
-        });
+        try {
+            return await this.client.socket.sendMessage(this.from, {
+                audio: { url: audioPath },
+                mimetype: 'audio/mp4'
+            });
+        } catch (error) {
+            console.error('❌ Fehler beim Senden der Audio-Datei:', error);
+            throw error;
+        }
     }
 
     async sendVideo(videoPath, caption = "", mentions = []) {
-        const message = {
-            video: { url: videoPath },
-            caption: caption
-        };
+        try {
+            const message = {
+                video: { url: videoPath },
+                caption: caption
+            };
 
-        if (mentions.length > 0) {
-            message.mentions = mentions;
-        }
+            if (mentions.length > 0) {
+                message.mentions = mentions;
+            }
 
-        return await this.client.socket.sendMessage(this.from, message);
+            return await this.client.socket.sendMessage(this.from, message);
+        } catch (error) {
+            console.error('❌ Fehler beim Senden des Videos:', error);
+            throw error;
+        }
     }
 
     async sendDocument(documentPath, fileName, mentions = []) {
@@ -352,44 +382,143 @@ export class Message {
         try {
             console.log('📊 Sende Poll:', question, options);
             
-            // Baileys V3 Poll Format (korrekte Syntax)
-            const pollMessage = {
-                poll: {
-                    name: question,
-                    values: options,
-                    selectableCount: 1
-                }
-            };
+            // PROBLEM IDENTIFIZIERT: WhatsApp blockiert möglicherweise Bot-Polls
+            // Versuche verschiedene Ansätze
             
-            // Alternative V3 Syntax versuchen
-            const pollMessageV3 = {
-                pollCreationMessage: {
-                    name: question,
-                    options: options.map(option => ({ optionName: option })),
-                    selectableOptionsCount: 1
+            // Ansatz 1: Standard Poll ohne selectableCount
+            try {
+                console.log('🧪 Ansatz 1: Standard Poll ohne selectableCount');
+                const basicPoll = {
+                    poll: {
+                        name: question,
+                        values: options
+                    }
+                };
+                
+                const result1 = await this.client.socket.sendMessage(this.from, basicPoll);
+                console.log('✅ Basic Poll gesendet:', result1?.key?.id);
+                
+                // Warte kurz und prüfe ob Poll ankommt
+                await new Promise(resolve => setTimeout(resolve, 2000));
+                console.log('⏳ Poll sollte jetzt sichtbar sein...');
+                return result1;
+                
+            } catch (error1) {
+                console.log('❌ Basic Poll fehlgeschlagen:', error1.message);
+                
+                // Ansatz 2: Poll mit expliziter Konfiguration
+                try {
+                    console.log('🧪 Ansatz 2: Poll mit expliziter Konfiguration');
+                    const configuredPoll = {
+                        poll: {
+                            name: question,
+                            values: options,
+                            selectableCount: 1,
+                            messageSecret: Buffer.from(Array(32).fill(0).map(() => Math.floor(Math.random() * 256)))
+                        }
+                    };
+                    
+                    const result2 = await this.client.socket.sendMessage(this.from, configuredPoll);
+                    console.log('✅ Configured Poll gesendet:', result2?.key?.id);
+                    return result2;
+                    
+                } catch (error2) {
+                    console.log('❌ Configured Poll fehlgeschlagen:', error2.message);
+                    throw error2;
                 }
-            };
+            }
             
-            console.log('📊 Versuche Standard Poll Format...');
+        } catch (error) {
+            console.error('❌ Alle Poll-Ansätze fehlgeschlagen:', error.message);
+            console.log('🔄 Verwende intelligenten Fallback...');
             
+            // INTELLIGENTER FALLBACK: Interaktive Nachricht mit Buttons (falls verfügbar)
             try {
-                const result = await this.client.socket.sendMessage(this.from, pollMessage);
-                console.log('✅ Standard Poll gesendet:', result);
-                return result;
-            } catch (standardError) {
-                console.log('⚠️ Standard Format fehlgeschlagen, versuche V3 Format...');
+                console.log('🧪 Versuche Button-Fallback...');
+                
+                const buttonMessage = {
+                    text: `📊 **${question}**\n\n_Wähle eine Option:_`,
+                    buttons: options.slice(0, 3).map((option, index) => ({
+                        buttonId: `poll_${index}`,
+                        buttonText: { displayText: option },
+                        type: 1
+                    })),
+                    headerType: 1
+                };
+                
+                const buttonResult = await this.client.socket.sendMessage(this.from, buttonMessage);
+                console.log('✅ Button-Fallback erfolgreich:', buttonResult?.key?.id);
+                return buttonResult;
+                
+            } catch (buttonError) {
+                console.log('❌ Button-Fallback fehlgeschlagen:', buttonError.message);
+                
+                // LETZTER FALLBACK: Emoji-basierte Poll
+                console.log('🔄 Verwende Emoji-Fallback...');
+                
+                let fallbackText = `📊 **${question}**\n\n`;
+                const emojis = ['1️⃣', '2️⃣', '3️⃣', '4️⃣', '5️⃣', '6️⃣', '7️⃣', '8️⃣', '9️⃣', '🔟'];
+                
+                options.forEach((option, index) => {
+                    const emoji = emojis[index] || `${index + 1}️⃣`;
+                    fallbackText += `${emoji} ${option}\n`;
+                });
+                
+                fallbackText += `\n_Reagiere mit dem entsprechenden Emoji zum Abstimmen!_`;
                 
-                const resultV3 = await this.client.socket.sendMessage(this.from, pollMessageV3);
-                console.log('✅ V3 Poll gesendet:', resultV3);
-                return resultV3;
+                const fallbackResult = await this.reply(fallbackText);
+                
+                // Auto-Reactions hinzufügen
+                setTimeout(async () => {
+                    try {
+                        for (let i = 0; i < Math.min(options.length, emojis.length); i++) {
+                            await new Promise(resolve => setTimeout(resolve, 200));
+                            await this.client.socket.sendMessage(this.from, {
+                                react: {
+                                    text: emojis[i],
+                                    key: fallbackResult.key
+                                }
+                            });
+                        }
+                        console.log('✅ Emoji-Fallback mit Auto-Reactions bereit');
+                    } catch (reactError) {
+                        console.log('⚠️ Auto-Reactions fehlgeschlagen:', reactError.message);
+                    }
+                }, 300);
+                
+                return fallbackResult;
             }
+        }
+    }
+
+    async sendMultiPoll(question, options, maxSelections = 1) {
+        if (!Array.isArray(options) || options.length < 2 || options.length > 12) {
+            throw new Error('Poll muss zwischen 2 und 12 Optionen haben');
+        }
+
+        try {
+            console.log('📊 Sende Multi-Poll:', question, options, 'Max:', maxSelections);
+            
+            // KORRIGIERTE Multi-Poll Syntax
+            const multiPollMessage = {
+                poll: {
+                    name: question,
+                    values: options,
+                    selectableCount: maxSelections
+                }
+            };
+            
+            console.log('📋 Multi-Poll Message:', JSON.stringify(multiPollMessage, null, 2));
+            
+            const result = await this.client.socket.sendMessage(this.from, multiPollMessage);
+            console.log('✅ Multi-Poll erfolgreich gesendet:', result?.key?.id);
+            return result;
             
         } catch (error) {
-            console.error('❌ Alle Poll Formate fehlgeschlagen:', error);
-            console.log('🔄 Verwende Fallback...');
+            console.error('❌ Multi-Poll Fehler:', error.message);
             
-            // Fallback: Als interaktive Nachricht mit Emojis
-            let fallbackText = `📊 **${question}**\n\n`;
+            // Fallback: Als normale Nachricht mit Hinweis
+            let fallbackText = `📊 **${question}**\n_(Max. ${maxSelections} Auswahlen)_\n\n`;
             const emojis = ['1️⃣', '2️⃣', '3️⃣', '4️⃣', '5️⃣', '6️⃣', '7️⃣', '8️⃣', '9️⃣', '🔟'];
             
             options.forEach((option, index) => {
@@ -397,15 +526,15 @@ export class Message {
                 fallbackText += `${emoji} ${option}\n`;
             });
             
-            fallbackText += `\n_Reagiere mit dem entsprechenden Emoji zum Abstimmen!_`;
+            fallbackText += `\n_Reagiere mit bis zu ${maxSelections} Emojis!_`;
             
             const fallbackResult = await this.reply(fallbackText);
             
-            // Auto-Reactions hinzufügen für bessere UX
+            // Auto-Reactions für Multi-Poll
             setTimeout(async () => {
                 try {
                     for (let i = 0; i < Math.min(options.length, emojis.length); i++) {
-                        await new Promise(resolve => setTimeout(resolve, 500)); // Delay zwischen Reactions
+                        await new Promise(resolve => setTimeout(resolve, 300));
                         await this.client.socket.sendMessage(this.from, {
                             react: {
                                 text: emojis[i],
@@ -413,42 +542,16 @@ export class Message {
                             }
                         });
                     }
+                    console.log('✅ Multi-Poll Auto-Reactions hinzugefügt');
                 } catch (reactError) {
-                    console.log('⚠️ Konnte keine Auto-Reactions hinzufügen:', reactError.message);
+                    console.log('⚠️ Multi-Poll Auto-Reactions fehlgeschlagen:', reactError.message);
                 }
-            }, 1000);
+            }, 500);
             
             return fallbackResult;
         }
     }
 
-    async sendMultiPoll(question, options, maxSelections = 1) {
-        if (!Array.isArray(options) || options.length < 2 || options.length > 12) {
-            throw new Error('Poll muss zwischen 2 und 12 Optionen haben');
-        }
-
-        try {
-            return await this.client.socket.sendMessage(this.from, {
-                poll: {
-                    name: question,
-                    values: options,
-                    selectableCount: maxSelections
-                }
-            });
-        } catch (error) {
-            console.error('❌ Multi-Poll Fehler:', error);
-            
-            // Fallback: Als normale Nachricht
-            let fallbackText = `📊 **${question}**\n_(Max. ${maxSelections} Auswahlen)_\n\n`;
-            options.forEach((option, index) => {
-                fallbackText += `${index + 1}. ${option}\n`;
-            });
-            fallbackText += `\n_Reagiere mit den entsprechenden Zahlen!_`;
-            
-            return await this.reply(fallbackText);
-        }
-    }
-
     // ===== UTILITY FUNCTIONS =====
     
     async react(emoji) {

package/src/multi-client.js

@@ -1,8 +1,15 @@
 import { DeviceManager } from "./device-manager.js";
 import { Message } from "./message.js";
+import { ConsoleLogger } from "./console-logger.js";
 
 export class MultiWhatsAppClient {
     constructor(options = {}) {
+        // Console Logger initialisieren
+        this.logger = new ConsoleLogger({
+            verbose: options.verbose || false,
+            silent: options.silent || false
+        });
+        
         this.deviceManager = new DeviceManager({
             maxDevices: options.maxDevices || 3,
             loadBalancing: options.loadBalancing || 'round-robin',
@@ -27,7 +34,9 @@ export class MultiWhatsAppClient {
         // Device Manager Events weiterleiten
         this.setupDeviceManagerEvents();
         
-        console.log("🚀 MultiWhatsAppClient mit robusten Verbindungen initialisiert");
+        // Schöne Console Ausgabe statt Spam
+        this.logger.showBanner();
+        this.logger.info("Multi-Device Bot wird initialisiert...");
     }
 
     // ===== DEVICE MANAGEMENT =====
@@ -67,8 +76,8 @@ export class MultiWhatsAppClient {
 
     // 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!");
+        // Schöne Setup Animation
+        await this.logger.animateSetup();
         
         const results = [];
         let connectedCount = 0;
@@ -77,34 +86,39 @@ export class MultiWhatsAppClient {
             const deviceId = deviceIds[i];
             
             try {
-                console.log(`\n📱 Device ${i + 1}/${deviceIds.length}: '${deviceId}'`);
-                console.log("⏳ Warte auf QR-Scan für dieses Device...");
+                // QR-Code Animation
+                await this.logger.animateQRGeneration(deviceId, i + 1, deviceIds.length);
                 
                 // Verbinde ein Device und warte bis es fertig ist
                 const client = await this.deviceManager.connectDevice(deviceId);
                 
-                console.log(`✅ Device '${deviceId}' erfolgreich verbunden!`);
+                // Connection Animation - Device sollte authentifiziert sein nach connectDevice
+                await this.logger.animateConnection(deviceId, true);
+                
                 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));
+                    await this.logger.showDevicePause(3);
                 }
                 
             } catch (error) {
-                console.error(`❌ Device '${deviceId}' Verbindung fehlgeschlagen:`, error.message);
+                this.logger.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)");
+                this.logger.warning("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`);
+        // Finale schöne Zusammenfassung
+        const connectedDeviceNames = results
+            .filter(r => r.status === 'connected')
+            .map(r => r.deviceId);
+            
+        this.logger.showFinalSummary(connectedDeviceNames);
         
         if (connectedCount === 0) {
             throw new Error("❌ Keine Devices konnten verbunden werden!");

package/src/plugin-manager.js

@@ -26,28 +26,77 @@ export class PluginManager {
         try {
             console.log(`🔌 Lade Plugin: ${pluginName}`);
             
-            // Plugin importieren
-            const pluginPath = join(process.cwd(), this.pluginsDir, pluginName, 'index.js');
+            // Plugin-Pfad validieren
+            if (!pluginName || typeof pluginName !== 'string') {
+                throw new Error('Ungültiger Plugin-Name');
+            }
+            
+            // Sanitize Plugin-Name (Sicherheit)
+            const sanitizedName = pluginName.replace(/[^a-zA-Z0-9-_]/g, '');
+            if (!sanitizedName) {
+                throw new Error('Plugin-Name enthält ungültige Zeichen');
+            }
+            
+            const pluginPath = join(process.cwd(), this.pluginsDir, sanitizedName, 'index.js');
             
             if (!existsSync(pluginPath)) {
-                console.log(`📝 Plugin ${pluginName} nicht gefunden - wird übersprungen`);
+                console.log(`📝 Plugin ${sanitizedName} nicht gefunden - wird übersprungen`);
                 return null;
             }
             
-            const { default: PluginClass } = await import(pluginPath);
+            // Plugin-Struktur validieren vor Import
+            const pluginModule = await import(pluginPath);
+            
+            if (!pluginModule.default) {
+                throw new Error(`Plugin ${sanitizedName} hat keinen default export`);
+            }
+            
+            const PluginClass = pluginModule.default;
             
-            // Plugin instanziieren
-            const plugin = new PluginClass(this.client);
-            this.plugins.set(pluginName, plugin);
+            // Validiere Plugin-Klasse
+            if (typeof PluginClass !== 'function') {
+                throw new Error(`Plugin ${sanitizedName} default export ist keine Klasse`);
+            }
             
-            // Commands registrieren
-            await this.registerPluginCommands(plugin);
+            // Plugin instanziieren mit Error-Handling
+            let plugin;
+            try {
+                plugin = new PluginClass(this.client);
+            } catch (constructorError) {
+                throw new Error(`Plugin ${sanitizedName} Konstruktor-Fehler: ${constructorError.message}`);
+            }
             
-            console.log(`✅ Plugin geladen: ${pluginName} v${plugin.version}`);
+            // Validiere Plugin-Interface
+            if (!plugin.name || !plugin.version) {
+                throw new Error(`Plugin ${sanitizedName} fehlt name oder version`);
+            }
+            
+            if (typeof plugin.getCommands !== 'function') {
+                console.warn(`⚠️ Plugin ${sanitizedName} hat keine getCommands() Methode`);
+                plugin.getCommands = () => [];
+            }
+            
+            // Plugin registrieren
+            this.plugins.set(sanitizedName, plugin);
+            
+            // Commands registrieren mit Error-Handling
+            try {
+                await this.registerPluginCommands(plugin);
+            } catch (commandError) {
+                console.warn(`⚠️ Plugin ${sanitizedName} Commands konnten nicht registriert werden:`, commandError.message);
+            }
+            
+            console.log(`✅ Plugin geladen: ${plugin.name} v${plugin.version}`);
             return plugin;
             
         } catch (error) {
             console.error(`❌ Plugin Fehler: ${pluginName}`, error.message);
+            
+            // Plugin aus Map entfernen falls teilweise geladen
+            if (this.plugins.has(pluginName)) {
+                this.plugins.delete(pluginName);
+            }
+            
             return null;
         }
     }

package/src/prefix-manager.js

@@ -115,7 +115,10 @@ export class PrefixManager {
         
         const prefix = this.getPrefix(chatId);
         const commandText = text.slice(prefix.length).trim();
-        const [command, ...args] = commandText.split(' ');
+        const [command, ...rawArgs] = commandText.split(' ');
+        
+        // INTELLIGENTES ARGUMENT-PARSING für Anführungszeichen
+        const args = this.parseQuotedArguments(rawArgs.join(' '));
         
         return {
             prefix,
@@ -126,6 +129,50 @@ export class PrefixManager {
         };
     }
 
+    // Parst Argumente mit Anführungszeichen-Unterstützung
+    parseQuotedArguments(argsString) {
+        if (!argsString.trim()) return [];
+        
+        const args = [];
+        let current = '';
+        let inQuotes = false;
+        let quoteChar = '';
+        
+        for (let i = 0; i < argsString.length; i++) {
+            const char = argsString[i];
+            
+            if ((char === '"' || char === "'") && !inQuotes) {
+                // Start einer Anführungszeichen-Gruppe
+                inQuotes = true;
+                quoteChar = char;
+            } else if (char === quoteChar && inQuotes) {
+                // Ende einer Anführungszeichen-Gruppe
+                inQuotes = false;
+                quoteChar = '';
+                if (current.trim()) {
+                    args.push(current.trim());
+                    current = '';
+                }
+            } else if (char === ' ' && !inQuotes) {
+                // Leerzeichen außerhalb von Anführungszeichen
+                if (current.trim()) {
+                    args.push(current.trim());
+                    current = '';
+                }
+            } else {
+                // Normales Zeichen
+                current += char;
+            }
+        }
+        
+        // Letztes Argument hinzufügen
+        if (current.trim()) {
+            args.push(current.trim());
+        }
+        
+        return args;
+    }
+
     // ===== STATISTICS =====
     
     getStats() {