waengine 1.7.3 → 1.7.4

package/src/easy-bot.js

@@ -1,6 +1,102 @@
 import { WhatsAppClient } from "./client.js";
 import { MultiWhatsAppClient } from "./multi-client.js";
 import { EasyAdvanced, EasyAdvancedRule } from "./easy-advanced.js";
+import { ConsoleLogger } from "./console-logger.js";
+import { ErrorHandler } from "./error-handler.js";
+
+// ===== CHAIN-PROXY PATTERN - UNIVERSELLE LÖSUNG =====
+class EasyChain {
+    constructor(bot) {
+        this.bot = bot;
+        this.currentRule = null;
+    }
+
+    // ===== RULE METHODS - ALLE geben this (EasyChain) zurück! =====
+    when(trigger) {
+        const rule = new EasyRule(trigger, this.bot);
+        this.bot.rules.push(rule);
+        this.currentRule = rule;
+        return this; // ✅ KRITISCH: Gibt EasyChain zurück für weitere Chaining
+    }
+
+    reply(text) {
+        if (this.currentRule) {
+            this.currentRule.actions.push({ type: 'reply', value: text });
+        }
+        return this; // ✅ Gibt EasyChain zurück
+    }
+
+    send(text) {
+        if (this.currentRule) {
+            this.currentRule.actions.push({ type: 'reply', value: text });
+        }
+        return this;
+    }
+
+    react(emoji) {
+        if (this.currentRule) {
+            this.currentRule.actions.push({ type: 'react', value: emoji });
+        }
+        return this;
+    }
+
+    type(seconds = 2) {
+        if (this.currentRule) {
+            this.currentRule.actions.push({ type: 'type', value: seconds * 1000 });
+        }
+        return this;
+    }
+
+    // ===== NEUE METHODEN =====
+    done() {
+        this.currentRule = null; // Reset für nächste Rule
+        return this; // Ermöglicht weitere .when() Aufrufe
+    }
+
+    // ===== BOT CONTROL METHODS =====
+    start() {
+        return this.bot.start();
+    }
+
+    stop() {
+        return this.bot.stop();
+    }
+
+    status() {
+        return this.bot.status();
+    }
+
+    // ===== ADVANCED METHODS =====
+    enableAI() {
+        this.bot.enableAI();
+        return this;
+    }
+
+    enableAll() {
+        this.bot.enableAll();
+        return this;
+    }
+
+    enableDefaults() {
+        this.bot.enableDefaults();
+        return this;
+    }
+
+    command(cmd, response) {
+        this.bot.command(cmd, response);
+        return this;
+    }
+
+    autoReply(trigger, response) {
+        this.bot.autoReply(trigger, response);
+        return this;
+    }
+
+    template(name, content) {
+        this.bot.template(name, content);
+        return this;
+    }
+}
 
 export class EasyBot {
     constructor() {
@@ -21,8 +117,11 @@ export class EasyBot {
             reactionsEnabled: true
         };
 
-        // ===== ADVANCED FEATURES INTEGRATION - NEU! =====
-        this.advanced = null; // Wird nach Client-Erstellung initialisiert
+        // Advanced features integration
+        this.advanced = null;
+        
+        // ✅ Chain-Proxy für Fluent API
+        this.chain = new EasyChain(this);
     }
 
     // ===== FACTORY METHODS =====
@@ -33,29 +132,41 @@ export class EasyBot {
             authDir: "./auth",
             logLevel: "silent",
             
-            // CLEAN QR DEFAULTS - NEU!
-            printQR: false,                    // Browser QR bevorzugt
-            qrSpamPrevention: true,           // Anti-Spam aktiviert
-            qrDisplayInterval: 30000,         // 30s zwischen Terminal QR
-            qrMaxDisplays: 3,                 // Max 3 Terminal QR
-            clearTerminalOnQR: true,          // Terminal bei QR leeren
+            // CLEAN QR DEFAULTS
+            printQR: false,
+            qrSpamPrevention: true,
+            qrDisplayInterval: 30000,
+            qrMaxDisplays: 1, // ✅ FIX: Nur 1 QR Code!
+            clearTerminalOnQR: true,
             
-            // ROBUSTE CONNECTION DEFAULTS - NEU!
-            maxReconnectAttempts: 100, // Viele Versuche für 24/7
-            reconnectInterval: 2000, // Schnellere Wiederverbindung
+            // ROBUSTE CONNECTION DEFAULTS
+            maxReconnectAttempts: 100,
+            reconnectInterval: 2000,
             exponentialBackoff: true,
-            maxBackoffDelay: 30000, // Max 30 Sekunden
-            heartbeatInterval: 20000, // 20 Sekunden Heartbeat
+            maxBackoffDelay: 30000,
+            heartbeatInterval: 20000,
             connectionTimeout: 180000, // 3 Minuten Timeout
             keepAlive: true,
             quietHeartbeat: true, // Heartbeat-Spam deaktivieren
+            
+            // SCHÖNE CONSOLE FÜR ALLE!
+            verbose: options.verbose || false,
+            silent: options.silent || false,
+            
+            // ERROR HANDLER - DEINE EMAIL IMMER DABEI!
+            errorHandler: {
+                supportEmail: "Liaia@outlook.de", // IMMER deine Email
+                showSupportInfo: true,
+                logErrors: true
+            },
+            
             ...options
         });
         
         // Advanced Features nach Client-Erstellung initialisieren
         bot.advanced = new EasyAdvanced(bot);
         
-        return bot;
+        return bot.chain; // ✅ KRITISCH: Gibt Chain-Proxy zurück für Fluent API!
     }
 
     static createMulti(deviceCount = 2, options = {}) {
@@ -73,6 +184,9 @@ export class EasyBot {
             connectionTimeout: 180000,
             keepAlive: true,
             quietHeartbeat: true, // Heartbeat-Spam deaktivieren
+            // Console Logger Settings
+            verbose: options.verbose || false,
+            silent: options.silent || false,
             ...options
         });
         return bot;
@@ -99,7 +213,7 @@ export class EasyBot {
     when(trigger) {
         const rule = new EasyRule(trigger, this);
         this.rules.push(rule);
-        return rule;
+        return this.chain; // ✅ KRITISCH: Gibt Chain zurück für Fluent API!
     }
 
     // Shorthand methods
@@ -696,6 +810,254 @@ export class EasyBot {
         
         return this;
     }
+    
+    // ===== ERROR HANDLING METHODS - NEU! =====
+    
+    /**
+     * Configure support contact information
+     */
+    setSupportContact(email, discord = null, github = null) {
+        if (this.client) {
+            this.client.errorHandler.options.supportEmail = email;
+            if (discord) this.client.errorHandler.options.supportDiscord = discord;
+            if (github) this.client.errorHandler.options.supportGitHub = github;
+        }
+        return this;
+    }
+    
+    /**
+     * Enable/disable error reporting
+     */
+    enableErrorReporting(enabled = true) {
+        if (this.client) {
+            this.client.errorHandler.options.sendErrorReports = enabled;
+        }
+        return this;
+    }
+    
+    /**
+     * Get error statistics
+     */
+    getErrorStats() {
+        if (this.client) {
+            return this.client.errorHandler.getErrorStats();
+        }
+        return { totalErrors: 0, lastError: null };
+    }
+    
+    /**
+     * Add error handling to bot
+     */
+    onError(callback) {
+        if (this.client) {
+            this.client.on('error', callback);
+        }
+        return this;
+    }
+    
+    // ===== BUSINESS FEATURES - NEU! =====
+    
+    /**
+     * Set business profile
+     */
+    setBusinessProfile(profileData) {
+        if (this.client) {
+            this.client.business.setProfile(profileData);
+        }
+        return this;
+    }
+    
+    /**
+     * Create product
+     */
+    createProduct(productData) {
+        if (this.client) {
+            return this.client.business.createProduct(productData);
+        }
+        return this;
+    }
+    
+    /**
+     * Send product template
+     */
+    sendProduct(productId) {
+        this.addRule(new EasyRule('product', async (msg) => {
+            if (this.client) {
+                const product = this.client.business.getProduct(productId);
+                if (product) {
+                    await this.client.ui.sendProductTemplate(msg.from, product);
+                }
+            }
+        }));
+        return this;
+    }
+    
+    // ===== UI COMPONENTS - NEU! =====
+    
+    /**
+     * Send carousel
+     */
+    carousel(cards, options = {}) {
+        this.addRule(new EasyRule('carousel', async (msg) => {
+            if (this.client) {
+                await this.client.ui.sendCarousel(msg.from, cards, options);
+            }
+        }));
+        return this;
+    }
+    
+    /**
+     * Create interactive form
+     */
+    form(formConfig) {
+        this.addRule(new EasyRule('form', async (msg) => {
+            if (this.client) {
+                await this.client.ui.createForm(msg.from, formConfig);
+            }
+        }));
+        return this;
+    }
+    
+    /**
+     * Send quick replies
+     */
+    quickReplies(text, replies, options = {}) {
+        this.addRule(new EasyRule('quickReplies', async (msg) => {
+            if (this.client) {
+                await this.client.ui.sendQuickReplies(msg.from, text, replies, options);
+            }
+        }));
+        return this;
+    }
+    
+    /**
+     * Set persistent menu
+     */
+    setPersistentMenu(menuItems) {
+        if (this.client) {
+            // Set menu for all users who interact with the bot
+            this.client.on('message', async (msg) => {
+                if (msg.text?.toLowerCase() === 'menu') {
+                    await this.client.ui.setPersistentMenu(msg.from, menuItems);
+                }
+            });
+        }
+        return this;
+    }
+    
+    // ===== ANALYTICS FEATURES - NEU! =====
+    
+    /**
+     * Get analytics stats
+     */
+    getAnalytics(days = 7) {
+        if (this.client) {
+            return this.client.analyticsManager.getDetailedStats(days);
+        }
+        return null;
+    }
+    
+    /**
+     * Track custom event
+     */
+    trackEvent(eventName, data = {}) {
+        if (this.client) {
+            this.client.analyticsManager.trackEvent(eventName, data);
+        }
+        return this;
+    }
+    
+    // ===== HELPER METHODS FÜR MEDIA =====
+    
+    async sendMedia(msg, type, data) {
+        try {
+            const activeClient = this.isMultiDevice ? this.multiClient.getNextDevice() : this.client;
+            
+            switch (type) {
+                case 'image':
+                    if (data.path) {
+                        await activeClient.socket.sendMessage(msg.from, {
+                            image: { url: data.path },
+                            caption: data.caption || ''
+                        });
+                    }
+                    break;
+                    
+                case 'video':
+                    if (data.path) {
+                        await activeClient.socket.sendMessage(msg.from, {
+                            video: { url: data.path },
+                            caption: data.caption || ''
+                        });
+                    }
+                    break;
+                    
+                case 'audio':
+                    if (data) {
+                        await activeClient.socket.sendMessage(msg.from, {
+                            audio: { url: data },
+                            mimetype: 'audio/mp4'
+                        });
+                    }
+                    break;
+                    
+                case 'sticker':
+                    if (data) {
+                        await activeClient.socket.sendMessage(msg.from, {
+                            sticker: { url: data }
+                        });
+                    }
+                    break;
+                    
+                case 'document':
+                    if (data.path) {
+                        await activeClient.socket.sendMessage(msg.from, {
+                            document: { url: data.path },
+                            fileName: data.filename || 'document'
+                        });
+                    }
+                    break;
+                    
+                case 'location':
+                    await activeClient.socket.sendMessage(msg.from, {
+                        location: {
+                            degreesLatitude: data.lat,
+                            degreesLongitude: data.lng
+                        }
+                    });
+                    break;
+                    
+                case 'contact':
+                    await activeClient.socket.sendMessage(msg.from, {
+                        contacts: {
+                            displayName: data.name,
+                            contacts: [{ vcard: data.vcard }]
+                        }
+                    });
+                    break;
+                    
+                case 'poll':
+                    await activeClient.socket.sendMessage(msg.from, {
+                        poll: {
+                            name: data.question,
+                            values: data.options,
+                            selectableCount: 1
+                        }
+                    });
+                    break;
+            }
+        } catch (error) {
+            console.error(`❌ Fehler beim Senden von ${type}:`, error.message);
+            await this.sendReply(msg, `❌ ${type} konnte nicht gesendet werden`);
+        }
+    }
+    
+    // ===== HELPER METHOD FÜR RULES =====
+    
+    addRule(rule) {
+        this.rules.push(rule);
+        return this;
+    }
 }
 
 // ===== EASY RULE CLASS =====
@@ -707,25 +1069,41 @@ class EasyRule {
         this.actions = [];
     }
 
-    // Actions - Return this for action chaining within rule
+    // Actions - Return chain for fluent API!
     reply(text) {
         this.actions.push({ type: 'reply', value: text });
-        return this; // Return this for more actions on same rule!
+        return this.bot.chain; // ✅ KRITISCH: Gibt Chain zurück für Fluent API!
     }
 
     send(text) {
         this.actions.push({ type: 'reply', value: text });
-        return this; // Return this for more actions on same rule!
+        return this.bot.chain; // ✅ KRITISCH: Gibt Chain zurück für Fluent API!
     }
 
     react(emoji) {
         this.actions.push({ type: 'react', value: emoji });
-        return this; // Return this for more actions on same rule!
+        return this.bot.chain; // ✅ KRITISCH: Gibt Chain zurück für Fluent API!
     }
 
     type(seconds = 2) {
         this.actions.push({ type: 'type', value: seconds * 1000 });
-        return this; // Return this for more actions on same rule!
+        return this.bot.chain; // ✅ KRITISCH: Gibt Chain zurück für Fluent API!
+    }
+
+    // Neue Typing-Methoden hinzufügen
+    quickType(text) {
+        this.actions.push({ type: 'quickType', value: text });
+        return this;
+    }
+
+    normalType(text) {
+        this.actions.push({ type: 'normalType', value: text });
+        return this;
+    }
+
+    slowType(text) {
+        this.actions.push({ type: 'slowType', value: text });
+        return this;
     }
 
     typeAndReply(text, seconds = 2) {
@@ -1010,12 +1388,13 @@ class EasyRule {
         return this;
     }
 
-    // NEW: when() method on rule for chaining new rules!
+    // NEW: when() method on rule for chaining new rules! - KORRIGIERT!
     when(trigger) {
         // Create new rule and add to bot
         const newRule = new EasyRule(trigger, this.bot);
         this.bot.rules.push(newRule);
-        return newRule;
+        this.bot.chain.currentRule = newRule; // Set new rule as current
+        return this.bot.chain; // ✅ KRITISCH: Gibt Chain zurück für Fluent API!
     }
 
     // End action chaining, return bot for new rules
@@ -1028,6 +1407,93 @@ class EasyRule {
         return this.bot;
     }
 
+    // ✅ KRITISCH: start() Methode hinzufügen!
+    start() {
+        return this.bot.start(); // Delegiere zu EasyBot.start()
+    }
+
+    // ✅ FEHLENDE METHODEN: Delegiere zu EasyBot
+    command(cmd, response) {
+        return this.bot.command(cmd, response);
+    }
+
+    autoReply(trigger, response) {
+        return this.bot.autoReply(trigger, response);
+    }
+
+    template(name, content) {
+        return this.bot.template(name, content);
+    }
+
+    enableDefaults() {
+        return this.bot.enableDefaults();
+    }
+
+    enableAll() {
+        return this.bot.enableAll();
+    }
+
+    status() {
+        return this.bot.status();
+    }
+
+    stop() {
+        return this.bot.stop();
+    }
+
+    // ✅ ADVANCED FEATURES: Delegiere zu EasyBot
+    enableAI() {
+        return this.bot.enableAI();
+    }
+
+    enableWeather() {
+        return this.bot.enableWeather();
+    }
+
+    enableCrypto() {
+        return this.bot.enableCrypto();
+    }
+
+    enableNews() {
+        return this.bot.enableNews();
+    }
+
+    enableFun() {
+        return this.bot.enableFun();
+    }
+
+    enableStorage() {
+        return this.bot.enableStorage();
+    }
+
+    enableScheduler() {
+        return this.bot.enableScheduler();
+    }
+
+    enableMultiDevice() {
+        return this.bot.enableMultiDevice();
+    }
+
+    enableTyping() {
+        return this.bot.enableTyping();
+    }
+
+    enableAutoRestart() {
+        return this.bot.enableAutoRestart();
+    }
+
+    enableReactions() {
+        return this.bot.enableReactions();
+    }
+
+    ignoreOfflineMessages() {
+        return this.bot.ignoreOfflineMessages();
+    }
+
+    enableRobustConnection() {
+        return this.bot.enableRobustConnection();
+    }
+
     // Matching
     matches(msg) {
         const text = msg.text?.toLowerCase() || '';
@@ -1064,6 +1530,21 @@ class EasyRule {
                         await this.bot.typeMessage(msg, action.value);
                         break;
                         
+                    case 'quickType':
+                        await this.bot.typeMessage(msg, 1000); // 1 Sekunde
+                        await this.bot.sendReply(msg, action.value);
+                        break;
+                        
+                    case 'normalType':
+                        await this.bot.typeMessage(msg, 2000); // 2 Sekunden
+                        await this.bot.sendReply(msg, action.value);
+                        break;
+                        
+                    case 'slowType':
+                        await this.bot.typeMessage(msg, 4000); // 4 Sekunden
+                        await this.bot.sendReply(msg, action.value);
+                        break;
+                        
                     case 'template':
                         const template = this.bot.templates.get(action.value);
                         if (template) {