waengine 2.3.10 → 2.4.4

package/FEATURES.md

@@ -1013,6 +1013,174 @@ const type = client.getMessageType(message)
 
 ---
 
+## 🎨 Console Renderer **NEU in v2.0.0!**
+
+### **Schöne Console-Ausgabe mit Custom Prefix und Farben**
+
+Verwandle deine Console in ein professionelles Dashboard mit automatischen Prefixes und Farben für alle Ausgaben!
+
+```javascript
+import { WhatsAppClient, render } from 'waengine';
+
+const client = new WhatsAppClient();
+
+// Prefix und Farben konfigurieren
+render.consolePrefix('MyBot');           // Prefix: [MyBot]
+render.consolePrefixColor('cyan');       // Prefix-Farbe
+render.consoleColor('green');            // Standard-Farbe
+render.consoleError('red');              // Fehler-Farbe
+render.consoleWarn('yellow');            // Warn-Farbe
+render.consoleInfo('blue');              // Info-Farbe
+
+// Jetzt haben ALLE Console-Ausgaben automatisch den Prefix!
+console.log('Bot gestartet!');           // [MyBot] Bot gestartet!
+console.error('Ein Fehler!');            // [MyBot] Ein Fehler! (rot)
+console.warn('Warnung!');                // [MyBot] Warnung! (gelb)
+console.info('Information');             // [MyBot] Information (blau)
+```
+
+### **Verfügbare Farben (30+ Farben)**
+
+**Basic Colors:**
+- `black`, `red`, `green`, `yellow`, `blue`, `magenta`, `cyan`, `white`
+
+**Bright Colors:**
+- `brightRed`, `brightGreen`, `brightYellow`, `brightBlue`, `brightMagenta`, `brightCyan`, `brightWhite`
+
+**Background Colors:**
+- `bgBlack`, `bgRed`, `bgGreen`, `bgYellow`, `bgBlue`, `bgMagenta`, `bgCyan`, `bgWhite`
+
+**Bright Backgrounds:**
+- `bgBrightRed`, `bgBrightGreen`, `bgBrightYellow`, `bgBrightBlue`, `bgBrightMagenta`, `bgBrightCyan`, `bgBrightWhite`
+
+**Styles:**
+- `bold`, `dim`, `italic`, `underline`, `inverse`, `strikethrough`
+
+### **Direkte Print-Funktionen**
+```javascript
+// Direkt mit Farbe ausgeben (ohne Prefix)
+render.print('Wichtige Nachricht', 'red');
+render.print('Erfolg!', 'green');
+
+// Success Helper (grün mit ✓)
+render.success('Operation erfolgreich!');
+
+// Alle verfügbaren Farben anzeigen
+render.showColors();
+```
+
+### **Renderer Control**
+```javascript
+// Renderer aktivieren/deaktivieren
+render.enable();   // Aktivieren
+render.disable();  // Deaktivieren
+
+// Komplett zurücksetzen
+render.reset();    // Entfernt alle Patches
+```
+
+### **Praktische Anwendungen**
+```javascript
+// Bot mit schöner Console
+import { WhatsAppClient, render } from 'waengine';
+
+const client = new WhatsAppClient();
+
+// Setup
+render.consolePrefix('WABot');
+render.consolePrefixColor('brightCyan');
+render.consoleColor('white');
+render.consoleError('brightRed');
+render.consoleWarn('brightYellow');
+
+client.on('message', async (msg) => {
+    console.log(`Nachricht von ${msg.from}: ${msg.text}`);
+    // Output: [WABot] Nachricht von 123@s.whatsapp.net: Hello
+});
+
+client.on('error', (error) => {
+    console.error(`Fehler: ${error.message}`);
+    // Output: [WABot] Fehler: Connection lost (rot)
+});
+
+// Multi-Bot mit verschiedenen Farben
+const bot1 = new WhatsAppClient();
+render.consolePrefix('Bot1');
+render.consolePrefixColor('green');
+
+const bot2 = new WhatsAppClient();
+render.consolePrefix('Bot2');
+render.consolePrefixColor('blue');
+```
+
+### **Console Renderer Features**
+- ✅ **Auto-Prefix** - Automatischer Prefix vor JEDER Console-Ausgabe
+- ✅ **30+ Farben** - Basic, Bright, Background, Styles
+- ✅ **Separate Farben** - Unterschiedliche Farben für log/error/warn/info
+- ✅ **Prefix-Farbe** - Eigene Farbe für den Prefix
+- ✅ **Direct Print** - Direkte Ausgabe ohne Prefix
+- ✅ **Success Helper** - Grüne Success-Messages mit ✓
+- ✅ **Color Preview** - Alle Farben anzeigen
+- ✅ **Enable/Disable** - Renderer an/aus schalten
+- ✅ **Reset** - Komplett zurücksetzen
+- ✅ **Zero Config** - Funktioniert out-of-the-box
+
+### **Beispiel: Multi-Bot Dashboard**
+```javascript
+import { WhatsAppClient, render } from 'waengine';
+
+// Bot 1 - Grün
+render.consolePrefix('Support');
+render.consolePrefixColor('brightGreen');
+const supportBot = new WhatsAppClient();
+
+// Bot 2 - Blau  
+render.consolePrefix('Sales');
+render.consolePrefixColor('brightBlue');
+const salesBot = new WhatsAppClient();
+
+// Bot 3 - Magenta
+render.consolePrefix('Admin');
+render.consolePrefixColor('brightMagenta');
+const adminBot = new WhatsAppClient();
+
+// Jetzt hat jeder Bot seine eigene Farbe in der Console!
+// [Support] Nachricht empfangen... (grün)
+// [Sales] Kunde kontaktiert... (blau)
+// [Admin] Gruppe erstellt... (magenta)
+```
+
+---
+
+## 🗑️ MessageDel API - Nachrichten von anderen Usern löschen **NEU in v2.0.0!**
+
+### **Admin-Funktion zum Löschen von Nachrichten anderer User**
+
+Lösche Nachrichten von anderen Usern in Gruppen (erfordert Admin-Rechte)!
+
+```javascript
+// Nachricht von anderem User löschen
+const result = await msg.MessageDel(messageId, participantJid);
+
+if (result.success) {
+    console.log('✅ Nachricht gelöscht!');
+} else {
+    console.log(`❌ Fehler: ${result.reason}`);
+}
+```
+
+### **Return Object**
+```javascript
+{
+    success: boolean,           // true wenn erfolgreich
+    messageId: string,          // ID der gelöschten Nachricht
+    participant: string,        // JID des ursprünglichen Senders
+    wasFromBot: boolean,        // true wenn Bot-Nachricht
+    result: object,             // Baileys Result Object
+    reason: string,     
+
+---
+
 ## 💾 Storage System
 
 ### **Einfache Storage API**

package/README.md

@@ -216,10 +216,20 @@ client.setPrefix('!');
 // NEW: Ignore offline messages to prevent spam
 client.ignore.message.offline(true);
 
+// NEW: Control if bot ignores its own messages (default: true)
+client.ignore.message.FromMe(true);  // Bot ignores itself (prevents loops)
+// client.ignore.message.FromMe(false); // Bot reacts to own messages
+
 client.on('message', async (msg) => {
     if (msg.text === 'hello') {
         await msg.simulateTyping('Hello! How can I help?');
     }
+    
+    // Dynamically change FromMe ignore during runtime
+    if (msg.text === '/enable-echo') {
+        msg.ignore.FromMe(false); // Bot now reacts to own messages
+        await msg.reply('Echo mode enabled!');
+    }
 });
 
 await client.connect();
@@ -859,6 +869,111 @@ const type = client.getMessageType(message)
 
 ---
 
+## 🤖 FromMe Ignore API
+
+### **Control Bot Self-Interaction**
+
+By default, the bot ignores its own messages to prevent infinite loops. You can control this behavior:
+
+```javascript
+import { WhatsAppClient } from "waengine";
+
+const client = new WhatsAppClient();
+
+// ✅ Default: Bot ignores its own messages (prevents loops)
+client.ignore.message.FromMe(true);
+
+// ❌ Bot reacts to its own messages (use with caution!)
+client.ignore.message.FromMe(false);
+
+client.on('message', async (msg) => {
+    if (msg.text === '/menu') {
+        // With FromMe(true): Bot sends /menu but doesn't process it ✅
+        // With FromMe(false): Bot sends /menu and processes it again ❌ (loop!)
+        await msg.reply('📋 Menu: /help, /info, /status');
+    }
+});
+
+await client.connect();
+```
+
+### **Dynamic Control During Runtime**
+
+```javascript
+client.on('message', async (msg) => {
+    // Enable echo mode (bot reacts to own messages)
+    if (msg.text === '/echo-on') {
+        msg.ignore.FromMe(false);
+        await msg.reply('🔊 Echo mode enabled!');
+    }
+    
+    // Disable echo mode (bot ignores own messages)
+    if (msg.text === '/echo-off') {
+        msg.ignore.FromMe(true);
+        await msg.reply('🔇 Echo mode disabled!');
+    }
+    
+    // Check current status
+    if (msg.text === '/status') {
+        const status = client.ignoreFromMe ? 'ACTIVE ✅' : 'INACTIVE ❌';
+        await msg.reply(`FromMe Ignore: ${status}`);
+    }
+});
+```
+
+### **Use Cases**
+
+**Standard Bot (Recommended):**
+```javascript
+// Default behavior - bot ignores itself
+// No configuration needed!
+client.on('message', async (msg) => {
+    if (msg.text === '/menu') {
+        await msg.reply('Menu displayed!');
+        // ✅ No infinite loop
+    }
+});
+```
+
+**Echo Bot:**
+```javascript
+// Bot reacts to own messages
+client.ignore.message.FromMe(false);
+
+const processedIds = new Set();
+
+client.on('message', async (msg) => {
+    // Prevent infinite loops with message ID tracking
+    if (processedIds.has(msg.id)) return;
+    processedIds.add(msg.id);
+    
+    if (!msg.text.startsWith('/')) {
+        await msg.reply(`Echo: ${msg.text}`);
+    }
+});
+```
+
+**Self-Testing Bot:**
+```javascript
+// Bot tests its own commands
+client.ignore.message.FromMe(false);
+
+client.on('message', async (msg) => {
+    if (msg.text === '/test-all') {
+        // Bot sends and processes its own commands
+        await msg.reply('/help');
+        await msg.reply('/info');
+        await msg.reply('/status');
+    }
+});
+```
+
+⚠️ **Important:** When using `FromMe(false)`, always implement loop prevention mechanisms!
+
+📚 **Full Documentation:** See [FROMME-IGNORE-API.md](./FROMME-IGNORE-API.md)
+
+---
+
 ## 📚 Examples
 
 ### **EasyBot (Beginners)**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waengine",
-  "version": "2.3.10",
+  "version": "2.4.4",
   "description": "🚀 WAEngine - The most powerful WhatsApp Bot Library with 860+ Working Features, Complete Baileys Integration & Production-Ready Stability",
   "main": "src/index.js",
   "type": "module",

package/src/advanced-features.js

@@ -235,110 +235,169 @@ export class AdvancedMessage {
         }
     }
 
-    async sendCarouselMessage(cards) {
+    async sendCarouselMessage(cards, options = {}) {
         try {
-            // REAL WhatsApp Interactive Carousel - ONE message with swipeable cards!
-            const carouselMessage = {
-                interactiveMessage: {
+            const fs = await import('fs');
+            const { prepareWAMessageMedia, generateWAMessageFromContent } = await import('@whiskeysockets/baileys');
+            
+            // Default options
+            const carouselHeader = options.header || 'Carousel';
+            const carouselBody = options.body || 'Swipe to see all options';
+            
+            // Prepare all cards with media
+            const preparedCards = [];
+            
+            for (const [index, card] of cards.entries()) {
+                const carouselCard = {
+                    body: card.body || '',
+                    footer: card.footer || `${index + 1}/${cards.length}`,
                     header: {
-                        title: 'Carousel',
+                        title: card.title,
+                        subtitle: card.subtitle || '',
                         hasMediaAttachment: false
                     },
-                    body: {
-                        text: 'Swipe to see all options'
-                    },
-                    carouselMessage: {
-                        cards: cards.map((card, index) => {
-                            const carouselCard = {
-                                body: {
-                                    text: card.body || ''
+                    nativeFlowMessage: {
+                        buttons: []
+                    }
+                };
+                
+                // Prepare media if exists
+                if (card.video) {
+                    try {
+                        const videoBuffer = fs.readFileSync(card.video);
+                        const preparedMedia = await prepareWAMessageMedia(
+                            { video: videoBuffer },
+                            { upload: this.socket.waUploadToServer }
+                        );
+                        
+                        if (preparedMedia && preparedMedia.videoMessage) {
+                            carouselCard.header.hasMediaAttachment = true;
+                            carouselCard.header.videoMessage = preparedMedia.videoMessage;
+                        }
+                    } catch (mediaError) {
+                        console.error('⚠️ Video preparation failed:', mediaError.message);
+                        // Continue without video
+                    }
+                } else if (card.image) {
+                    try {
+                        const imageBuffer = fs.readFileSync(card.image);
+                        const preparedMedia = await prepareWAMessageMedia(
+                            { image: imageBuffer },
+                            { upload: this.socket.waUploadToServer }
+                        );
+                        
+                        if (preparedMedia && preparedMedia.imageMessage) {
+                            carouselCard.header.hasMediaAttachment = true;
+                            carouselCard.header.imageMessage = preparedMedia.imageMessage;
+                        }
+                    } catch (mediaError) {
+                        console.error('⚠️ Image preparation failed:', mediaError.message);
+                        // Continue without image
+                    }
+                }
+                
+                // Add buttons
+                if (card.buttons && card.buttons.length > 0) {
+                    carouselCard.nativeFlowMessage.buttons = card.buttons.map(btn => ({
+                        name: 'quick_reply',
+                        buttonParamsJson: JSON.stringify({
+                            display_text: btn.text || btn.title,
+                            id: btn.id || `btn_${index}`
+                        })
+                    }));
+                }
+                
+                preparedCards.push(carouselCard);
+            }
+            
+            // Create the carousel message structure
+            const message = generateWAMessageFromContent(
+                this.msg.from,
+                {
+                    viewOnceMessage: {
+                        message: {
+                            interactiveMessage: {
+                                header: {
+                                    title: carouselHeader,
+                                    hasMediaAttachment: false
                                 },
-                                footer: {
-                                    text: card.footer || `${index + 1}/${cards.length}`
+                                body: {
+                                    text: carouselBody
                                 },
-                                nativeFlowMessage: {
-                                    buttons: []
+                                carouselMessage: {
+                                    cards: preparedCards
                                 }
-                            };
-                            
-                            // Add header with media (video or image)
-                            if (card.video) {
-                                carouselCard.header = {
-                                    title: card.title,
-                                    subtitle: card.subtitle || '',
-                                    hasMediaAttachment: true,
-                                    videoMessage: {
-                                        url: card.video,
-                                        gifPlayback: card.gifPlayback || false
-                                    }
-                                };
-                            } else if (card.image) {
-                                carouselCard.header = {
-                                    title: card.title,
-                                    subtitle: card.subtitle || '',
-                                    hasMediaAttachment: true,
-                                    imageMessage: {
-                                        url: card.image
-                                    }
-                                };
-                            } else {
-                                carouselCard.header = {
-                                    title: card.title,
-                                    subtitle: card.subtitle || '',
-                                    hasMediaAttachment: false
-                                };
-                            }
-                            
-                            // Add buttons
-                            if (card.buttons && card.buttons.length > 0) {
-                                carouselCard.nativeFlowMessage.buttons = card.buttons.map(btn => ({
-                                    name: 'quick_reply',
-                                    buttonParamsJson: JSON.stringify({
-                                        display_text: btn.text || btn.title,
-                                        id: btn.id || `btn_${index}`
-                                    })
-                                }));
                             }
-                            
-                            return carouselCard;
-                        })
+                        }
                     }
-                }
-            };
+                },
+                { userJid: this.socket.user.id }
+            );
             
-            return await this.socket.sendMessage(this.msg.from, carouselMessage);
+            return await this.socket.relayMessage(this.msg.from, message.message, {
+                messageId: message.key.id
+            });
             
         } catch (error) {
             console.error('❌ Interactive Carousel fehlgeschlagen:', error);
             
-            // Fallback: List Message (closest to carousel)
+            // Fallback: Send videos individually
             try {
-                const listMessage = {
-                    text: 'Select an option',
-                    footer: `${cards.length} options available`,
-                    title: 'Carousel',
-                    buttonText: 'View Options',
-                    sections: [{
-                        title: 'All Options',
-                        rows: cards.map((card, i) => ({
-                            title: card.title,
-                            description: card.body || card.subtitle || '',
-                            rowId: `carousel_${i}`
-                        }))
-                    }]
-                };
+                console.log('🔄 Fallback: Sending cards individually...');
+                const results = [];
+                const fs = await import('fs');
+                
+                for (const [index, card] of cards.entries()) {
+                    try {
+                        const caption = `${card.title}\n\n${card.body || ''}\n\n${card.footer || ''}`;
+                        
+                        if (card.video) {
+                            // Send as video using socket directly
+                            const videoBuffer = fs.readFileSync(card.video);
+                            await this.socket.sendMessage(this.msg.from, {
+                                video: videoBuffer,
+                                caption: caption,
+                                gifPlayback: card.gifPlayback || false
+                            });
+                        } else if (card.image) {
+                            // Send as image using socket directly
+                            const imageBuffer = fs.readFileSync(card.image);
+                            await this.socket.sendMessage(this.msg.from, {
+                                image: imageBuffer,
+                                caption: caption
+                            });
+                        } else {
+                            // Send as text
+                            await this.socket.sendMessage(this.msg.from, {
+                                text: caption
+                            });
+                        }
+                        results.push({ index, success: true });
+                        
+                        // Small delay between messages
+                        if (index < cards.length - 1) {
+                            await new Promise(resolve => setTimeout(resolve, 1000));
+                        }
+                    } catch (cardError) {
+                        console.error(`❌ Card ${index} fehlgeschlagen:`, cardError);
+                        results.push({ index, success: false, error: cardError.message });
+                    }
+                }
                 
-                return await this.socket.sendMessage(this.msg.from, listMessage);
+                console.log('✅ Fallback completed:', results);
+                return { type: 'fallback_individual', results };
                 
-            } catch (listError) {
-                console.error('❌ List fallback fehlgeschlagen:', listError);
+            } catch (fallbackError) {
+                console.error('❌ Individual fallback fehlgeschlagen:', fallbackError);
                 
-                // Final fallback: Text
+                // Final fallback: Text list
                 const fallbackText = cards.map((card, i) => 
                     `${i + 1}. **${card.title}**\n${card.body || ''}`
                 ).join('\n\n');
                 
-                return await this.msg.reply(fallbackText);
+                return await this.socket.sendMessage(this.msg.from, {
+                    text: fallbackText
+                });
             }
         }
     }

package/src/client.js

@@ -145,6 +145,9 @@ export class WhatsAppClient {
         this.ignoredMessagesCount = 0; // Counter für ignorierte Messages
         this.offlineMessageTimer = null; // Timer für finale Zusammenfassung
         
+        // FromMe Ignore System - NEUE GLOBALE API!
+        this.ignoreFromMe = true; // Standard: Bot ignoriert sich selbst
+        
         // Log wenn automatisch aktiviert
         if (this.ignoreOfflineMessages) {
             console.log('\n📵 Offline Message Ignore: AUTOMATISCH AKTIVIERT');
@@ -178,6 +181,11 @@ export class WhatsAppClient {
                     this.ignoreOfflineMessages = enabled;
                     console.log(`📵 Offline Message Ignore: ${enabled ? 'AKTIVIERT' : 'DEAKTIVIERT'}`);
                     return this;
+                },
+                FromMe: (enabled = true) => {
+                    this.ignoreFromMe = enabled;
+                    console.log(`🤖 FromMe Ignore: ${enabled ? 'AKTIVIERT (Bot ignoriert sich selbst)' : 'DEAKTIVIERT (Bot reagiert auf eigene Messages)'}`);
+                    return this;
                 }
             }
         };
@@ -373,7 +381,7 @@ export class WhatsAppClient {
             this.socket = makeWASocket({
                 version,
                 auth: state,
-                logger: pino({ level: this.options.logLevel }),
+                logger: pino({ level: 'silent' }), // Force silent to prevent session logs
                 browser: this.options.browser,
                 generateHighQualityLinkPreview: true,
                 syncFullHistory: true, // Wichtig für Message-Empfang
@@ -394,7 +402,7 @@ export class WhatsAppClient {
         } catch (versionError) {
             this.socket = makeWASocket({
                 auth: state,
-                logger: pino({ level: this.options.logLevel }),
+                logger: pino({ level: 'silent' }), // Force silent to prevent session logs
                 browser: this.options.browser,
                 generateHighQualityLinkPreview: true,
                 syncFullHistory: true, // Wichtig für Message-Empfang
@@ -993,7 +1001,12 @@ export class WhatsAppClient {
                 }
                 
                 // Bessere Message-Validierung
-                if (!msg.message || msg.key.fromMe) return;
+                if (!msg.message) return;
+                
+                // FromMe Ignore - DEINE NEUE FUNKTION!
+                if (this.ignoreFromMe && msg.key.fromMe) {
+                    return; // Bot ignoriert seine eigenen Messages
+                }
                 
                 // OFFLINE MESSAGE IGNORE - DEINE NEUE FUNKTION!
                 if (this.ignoreOfflineMessages && this.connectionStartTime) {

package/src/message.js

@@ -37,6 +37,15 @@ export class Message {
                 }
             }
         };
+        
+        // Ignore API - DEINE NEUE FUNKTION!
+        this.ignore = {
+            FromMe: (enabled = true) => {
+                this.client.ignoreFromMe = enabled;
+                console.log(`🤖 FromMe Ignore: ${enabled ? 'AKTIVIERT (Bot ignoriert sich selbst)' : 'DEAKTIVIERT (Bot reagiert auf eigene Messages)'}`);
+                return this;
+            }
+        };
 
         // ===== ADVANCED FEATURES INTEGRATION - NEU! =====
         this.advanced = new AdvancedMessage(this);