waengine 1.5.0 → 1.7.3

package/src/easy-bot.js

@@ -1,5 +1,6 @@
 import { WhatsAppClient } from "./client.js";
 import { MultiWhatsAppClient } from "./multi-client.js";
+import { EasyAdvanced, EasyAdvancedRule } from "./easy-advanced.js";
 
 export class EasyBot {
     constructor() {
@@ -19,6 +20,9 @@ export class EasyBot {
             typingEnabled: true,
             reactionsEnabled: true
         };
+
+        // ===== ADVANCED FEATURES INTEGRATION - NEU! =====
+        this.advanced = null; // Wird nach Client-Erstellung initialisiert
     }
 
     // ===== FACTORY METHODS =====
@@ -44,8 +48,13 @@ export class EasyBot {
             heartbeatInterval: 20000, // 20 Sekunden Heartbeat
             connectionTimeout: 180000, // 3 Minuten Timeout
             keepAlive: true,
+            quietHeartbeat: true, // Heartbeat-Spam deaktivieren
             ...options
         });
+        
+        // Advanced Features nach Client-Erstellung initialisieren
+        bot.advanced = new EasyAdvanced(bot);
+        
         return bot;
     }
 
@@ -63,6 +72,7 @@ export class EasyBot {
             heartbeatInterval: 20000,
             connectionTimeout: 180000,
             keepAlive: true,
+            quietHeartbeat: true, // Heartbeat-Spam deaktivieren
             ...options
         });
         return bot;
@@ -79,6 +89,7 @@ export class EasyBot {
             reconnectInterval: 1000, // Sehr schnelle Wiederverbindung
             heartbeatInterval: 15000, // 15 Sekunden Heartbeat
             connectionTimeout: 300000, // 5 Minuten Timeout
+            quietHeartbeat: true, // Heartbeat-Spam deaktivieren
             ...options
         });
     }
@@ -740,6 +751,112 @@ class EasyRule {
         return this;
     }
 
+    // ===== ADVANCED MEDIA ACTIONS - NEU! =====
+    
+    voice(audioPath) {
+        this.actions.push({ type: 'voice', value: audioPath });
+        return this;
+    }
+
+    videoMessage(videoPath) {
+        this.actions.push({ type: 'videoMessage', value: videoPath });
+        return this;
+    }
+
+    gif(gifPath, caption = "") {
+        this.actions.push({ type: 'gif', value: { path: gifPath, caption } });
+        return this;
+    }
+
+    // ===== ADVANCED MESSAGE ACTIONS - NEU! =====
+    
+    forward(targetChat = null) {
+        this.actions.push({ type: 'forward', value: targetChat });
+        return this;
+    }
+
+    pin() {
+        this.actions.push({ type: 'pin', value: true });
+        return this;
+    }
+
+    star() {
+        this.actions.push({ type: 'star', value: true });
+        return this;
+    }
+
+    quote(text) {
+        this.actions.push({ type: 'quote', value: text });
+        return this;
+    }
+
+    // ===== RICH CONTENT ACTIONS - NEU! =====
+    
+    buttons(text, buttonList, footer = "") {
+        this.actions.push({ type: 'buttons', value: { text, buttons: buttonList, footer } });
+        return this;
+    }
+
+    list(title, description, buttonText, sections) {
+        this.actions.push({ type: 'list', value: { title, description, buttonText, sections } });
+        return this;
+    }
+
+    // ===== GROUP ACTIONS - NEU! =====
+    
+    groupInfo() {
+        this.actions.push({ type: 'groupInfo', value: true });
+        return this;
+    }
+
+    inviteLink() {
+        this.actions.push({ type: 'inviteLink', value: true });
+        return this;
+    }
+
+    // ===== PRIVACY ACTIONS - NEU! =====
+    
+    block() {
+        this.actions.push({ type: 'block', value: true });
+        return this;
+    }
+
+    unblock() {
+        this.actions.push({ type: 'unblock', value: true });
+        return this;
+    }
+
+    // ===== ANALYTICS ACTIONS - NEU! =====
+    
+    checkOnline() {
+        this.actions.push({ type: 'checkOnline', value: true });
+        return this;
+    }
+
+    archive() {
+        this.actions.push({ type: 'archive', value: true });
+        return this;
+    }
+
+    mute(duration = 8 * 60 * 60 * 1000) {
+        this.actions.push({ type: 'mute', value: duration });
+        return this;
+    }
+
+    // ===== STATUS ACTIONS - NEU! =====
+    
+    sendStatus(text, options = {}) {
+        this.actions.push({ type: 'sendStatus', value: { text, options } });
+        return this;
+    }
+
+    // ===== SYSTEM ACTIONS - NEU! =====
+    
+    backup() {
+        this.actions.push({ type: 'backup', value: true });
+        return this;
+    }
+
     sendAudio(path) {
         this.actions.push({ type: 'audio', value: path });
         return this;
@@ -1084,6 +1201,235 @@ class EasyRule {
                             console.error('❌ Fehler bei News:', error.message);
                         }
                         break;
+
+                    // ===== ADVANCED FEATURES CASES - NEU! =====
+                    
+                    case 'voice':
+                        try {
+                            const mentions = msg.getMentions();
+                            if (mentions.length > 0) {
+                                await msg.sendVoiceToMentioned(action.value);
+                            } else {
+                                await msg.sendVoiceMessage(action.value);
+                            }
+                        } catch (error) {
+                            console.error('❌ Voice Message Fehler:', error.message);
+                            await this.bot.sendReply(msg, '❌ Voice Message nicht verfügbar');
+                        }
+                        break;
+
+                    case 'videoMessage':
+                        try {
+                            const mentions = msg.getMentions();
+                            if (mentions.length > 0) {
+                                await msg.sendVideoMessageToMentioned(action.value);
+                            } else {
+                                await msg.sendVideoMessage(action.value);
+                            }
+                        } catch (error) {
+                            console.error('❌ Video Message Fehler:', error.message);
+                            await this.bot.sendReply(msg, '❌ Video Message nicht verfügbar');
+                        }
+                        break;
+
+                    case 'gif':
+                        try {
+                            const mentions = msg.getMentions();
+                            if (mentions.length > 0) {
+                                await msg.sendGifToMentioned(action.value.path, action.value.caption);
+                            } else {
+                                await msg.sendGif(action.value.path, action.value.caption);
+                            }
+                        } catch (error) {
+                            console.error('❌ GIF Fehler:', error.message);
+                            await this.bot.sendReply(msg, '❌ GIF nicht verfügbar');
+                        }
+                        break;
+
+                    case 'forward':
+                        try {
+                            if (action.value) {
+                                await msg.forward(action.value);
+                            } else {
+                                const mentions = msg.getMentions();
+                                if (mentions.length > 0) {
+                                    await msg.forwardToMentioned();
+                                } else {
+                                    await msg.forwardToSender();
+                                }
+                            }
+                        } catch (error) {
+                            console.error('❌ Forward Fehler:', error.message);
+                            await this.bot.sendReply(msg, '❌ Forward nicht verfügbar');
+                        }
+                        break;
+
+                    case 'pin':
+                        try {
+                            if (!msg.isGroup) {
+                                await this.bot.sendReply(msg, '❌ Pin funktioniert nur in Gruppen!');
+                            } else if (!(await msg.isAdmin())) {
+                                await this.bot.sendReply(msg, '❌ Nur Admins können pinnen!');
+                            } else {
+                                await msg.pin();
+                                await this.bot.sendReply(msg, '📌 Nachricht gepinnt!');
+                            }
+                        } catch (error) {
+                            console.error('❌ Pin Fehler:', error.message);
+                            await this.bot.sendReply(msg, '❌ Pin nicht verfügbar');
+                        }
+                        break;
+
+                    case 'star':
+                        try {
+                            await msg.star();
+                            await this.bot.sendReply(msg, '⭐ Nachricht markiert!');
+                        } catch (error) {
+                            console.error('❌ Star Fehler:', error.message);
+                            await this.bot.sendReply(msg, '❌ Star nicht verfügbar');
+                        }
+                        break;
+
+                    case 'quote':
+                        try {
+                            await msg.quote(action.value);
+                        } catch (error) {
+                            console.error('❌ Quote Fehler:', error.message);
+                            await this.bot.sendReply(msg, '❌ Quote nicht verfügbar');
+                        }
+                        break;
+
+                    case 'buttons':
+                        try {
+                            await msg.sendButtons(action.value.text, action.value.buttons, action.value.footer);
+                        } catch (error) {
+                            console.error('❌ Buttons Fehler:', error.message);
+                            await this.bot.sendReply(msg, '❌ Buttons nicht verfügbar');
+                        }
+                        break;
+
+                    case 'list':
+                        try {
+                            await msg.sendList(action.value.title, action.value.description, action.value.buttonText, action.value.sections);
+                        } catch (error) {
+                            console.error('❌ List Fehler:', error.message);
+                            await this.bot.sendReply(msg, '❌ List nicht verfügbar');
+                        }
+                        break;
+
+                    case 'groupInfo':
+                        try {
+                            if (!msg.isGroup) {
+                                await this.bot.sendReply(msg, '❌ Nur in Gruppen verfügbar!');
+                            } else {
+                                const metadata = await this.bot.client.get.GroupMetadata(msg.from);
+                                let info = `🏢 **Gruppeninfo**\n\n`;
+                                info += `📝 Name: ${metadata.subject}\n`;
+                                info += `👥 Mitglieder: ${metadata.participants.length}\n`;
+                                info += `👑 Admins: ${metadata.participants.filter(p => p.admin).length}\n`;
+                                info += `📅 Erstellt: ${new Date(metadata.creation * 1000).toLocaleDateString()}\n`;
+                                if (metadata.desc) info += `📄 Beschreibung: ${metadata.desc}\n`;
+                                await this.bot.sendReply(msg, info);
+                            }
+                        } catch (error) {
+                            console.error('❌ Group Info Fehler:', error.message);
+                            await this.bot.sendReply(msg, '❌ Group Info nicht verfügbar');
+                        }
+                        break;
+
+                    case 'inviteLink':
+                        try {
+                            if (!msg.isGroup) {
+                                await this.bot.sendReply(msg, '❌ Nur in Gruppen verfügbar!');
+                            } else if (!(await msg.isAdmin())) {
+                                await this.bot.sendReply(msg, '❌ Nur Admins können Einladungslinks erstellen!');
+                            } else {
+                                const inviteLink = await this.bot.client.group.getInviteLink(msg.from);
+                                await this.bot.sendReply(msg, `🔗 **Einladungslink:**\n${inviteLink}`);
+                            }
+                        } catch (error) {
+                            console.error('❌ Invite Link Fehler:', error.message);
+                            await this.bot.sendReply(msg, '❌ Invite Link nicht verfügbar');
+                        }
+                        break;
+
+                    case 'block':
+                        try {
+                            const mentions = msg.getMentions();
+                            const targetJid = mentions.length > 0 ? mentions[0] : msg.getSender();
+                            await this.bot.client.privacy.block(targetJid);
+                            await this.bot.sendReply(msg, '🚫 User blockiert!');
+                        } catch (error) {
+                            console.error('❌ Block Fehler:', error.message);
+                            await this.bot.sendReply(msg, '❌ Block nicht verfügbar');
+                        }
+                        break;
+
+                    case 'unblock':
+                        try {
+                            const mentions = msg.getMentions();
+                            const targetJid = mentions.length > 0 ? mentions[0] : msg.getSender();
+                            await this.bot.client.privacy.unblock(targetJid);
+                            await this.bot.sendReply(msg, '✅ User entblockiert!');
+                        } catch (error) {
+                            console.error('❌ Unblock Fehler:', error.message);
+                            await this.bot.sendReply(msg, '❌ Unblock nicht verfügbar');
+                        }
+                        break;
+
+                    case 'checkOnline':
+                        try {
+                            const mentions = msg.getMentions();
+                            const targetJid = mentions.length > 0 ? mentions[0] : msg.getSender();
+                            const isOnline = await this.bot.client.analytics.isOnline(targetJid);
+                            const userNumber = targetJid.split('@')[0].split(':')[0];
+                            await this.bot.sendReply(msg, `📱 +${userNumber} ist ${isOnline ? 'ONLINE 🟢' : 'OFFLINE 🔴'}`);
+                        } catch (error) {
+                            console.error('❌ Online Check Fehler:', error.message);
+                            await this.bot.sendReply(msg, '❌ Online Check nicht verfügbar');
+                        }
+                        break;
+
+                    case 'archive':
+                        try {
+                            await this.bot.client.analytics.archiveChat(msg.from);
+                            await this.bot.sendReply(msg, '📦 Chat archiviert!');
+                        } catch (error) {
+                            console.error('❌ Archive Fehler:', error.message);
+                            await this.bot.sendReply(msg, '❌ Archive nicht verfügbar');
+                        }
+                        break;
+
+                    case 'mute':
+                        try {
+                            await this.bot.client.analytics.muteChat(msg.from, action.value);
+                            await this.bot.sendReply(msg, `🔇 Chat für ${Math.round(action.value / 60000)} Minuten stummgeschaltet!`);
+                        } catch (error) {
+                            console.error('❌ Mute Fehler:', error.message);
+                            await this.bot.sendReply(msg, '❌ Mute nicht verfügbar');
+                        }
+                        break;
+
+                    case 'sendStatus':
+                        try {
+                            await this.bot.client.status.send('text', action.value.text, action.value.options);
+                            await this.bot.sendReply(msg, `📢 Status gesendet: "${action.value.text}"`);
+                        } catch (error) {
+                            console.error('❌ Status Fehler:', error.message);
+                            await this.bot.sendReply(msg, '❌ Status nicht verfügbar');
+                        }
+                        break;
+
+                    case 'backup':
+                        try {
+                            await this.bot.sendReply(msg, '💾 Erstelle Backup...');
+                            const backup = await this.bot.client.system.backup();
+                            await this.bot.sendReply(msg, `✅ Backup erstellt! Timestamp: ${backup.timestamp}`);
+                        } catch (error) {
+                            console.error('❌ Backup Fehler:', error.message);
+                            await this.bot.sendReply(msg, '❌ Backup nicht verfügbar');
+                        }
+                        break;
                         
                     case 'crypto':
                         try {
@@ -1252,10 +1598,7 @@ class EasyRule {
                         }
                         break;
                         
-                    case 'mentionUser':
-                        // Implementierung für mentionUser
-                        await this.bot.sendReply(msg, action.value.text);
-                        break;
+
                         
                     case 'delete':
                         // Implementierung für delete

package/src/index.js

@@ -12,6 +12,19 @@ export { EasyBot, createBot, createMultiBot, quickBot, bot, multiBot } from "./e
 export { generateQRCode } from "./qr.js";
 export { Message } from "./message.js";
 
+// ===== ADVANCED FEATURES EXPORTS - NEU! =====
+export { 
+    AdvancedMessage, 
+    AdvancedGroup, 
+    AdvancedPrivacy, 
+    AdvancedAnalytics, 
+    AdvancedStatus, 
+    AdvancedBusiness, 
+    AdvancedSystem 
+} from "./advanced-features.js";
+
+export { EasyAdvanced, EasyAdvancedRule } from "./easy-advanced.js";
+
 // NEUE ROBUSTE FACTORY METHODS - NEU!
 export const createRobustBot = () => EasyBot.createRobust();
 export const createUltraRobustBot = () => EasyBot.createRobust().enableUltraRobust();

package/src/message.js

@@ -1,6 +1,7 @@
 // Message-Klasse mit deinen eigenen Funktionen
 import { getStorage } from "./storage.js";
 import { StickerCreator } from "./sticker-creator.js";
+import { AdvancedMessage, AdvancedGroup, AdvancedPrivacy, AdvancedAnalytics, AdvancedStatus, AdvancedBusiness, AdvancedSystem } from "./advanced-features.js";
 
 export class Message {
     constructor(client, data) {
@@ -36,6 +37,24 @@ export class Message {
                 }
             }
         };
+
+        // ===== ADVANCED FEATURES INTEGRATION - NEU! =====
+        this.advanced = new AdvancedMessage(this);
+        this.forward = this.advanced.forwardMessage.bind(this.advanced);
+        this.forwardToMentioned = this.advanced.forwardToMentioned.bind(this.advanced);
+        this.forwardToSender = this.advanced.forwardToSender.bind(this.advanced);
+        this.edit = this.advanced.editMessage.bind(this.advanced);
+        this.pin = this.advanced.pinMessage.bind(this.advanced);
+        this.unpin = this.advanced.unpinMessage.bind(this.advanced);
+        this.star = this.advanced.starMessage.bind(this.advanced);
+        this.unstar = this.advanced.unstarMessage.bind(this.advanced);
+        this.replyTo = this.advanced.replyToMessage.bind(this.advanced);
+        this.replyToSender = this.advanced.replyToSender.bind(this.advanced);
+        this.quote = this.advanced.quoteMessage.bind(this.advanced);
+        this.sendButtons = this.advanced.sendButtonMessage.bind(this.advanced);
+        this.sendList = this.advanced.sendListMessage.bind(this.advanced);
+        this.sendTemplate = this.advanced.sendTemplateMessage.bind(this.advanced);
+        this.sendCarousel = this.advanced.sendCarouselMessage.bind(this.advanced);
     }
 
     // ===== REPLY FUNCTIONS =====
@@ -99,6 +118,39 @@ export class Message {
         });
     }
 
+    // ===== PROFILE PICTURE FUNCTIONS - NEU! =====
+    
+    async getProfilePicture(jid) {
+        try {
+            // Baileys Funktion für Profilbild-URL
+            const profilePicUrl = await this.client.socket.profilePictureUrl(jid, 'image');
+            return profilePicUrl;
+        } catch (error) {
+            // Fallback: Kein Profilbild verfügbar
+            return null;
+        }
+    }
+
+    async sendProfilePicture(jid, caption = "") {
+        try {
+            const profilePicUrl = await this.getProfilePicture(jid);
+            
+            if (!profilePicUrl) {
+                await this.reply(`❌ Kein Profilbild für diesen User verfügbar.`);
+                return false;
+            }
+
+            // Profilbild als Bild senden
+            await this.sendImage(profilePicUrl, caption);
+            return true;
+            
+        } catch (error) {
+            console.error('❌ Fehler beim Senden des Profilbilds:', error);
+            await this.reply(`❌ Fehler beim Laden des Profilbilds: ${error.message}`);
+            return false;
+        }
+    }
+
     async sendAudio(audioPath) {
         return await this.client.socket.sendMessage(this.from, {
             audio: { url: audioPath },
@@ -133,6 +185,147 @@ export class Message {
         return await this.client.socket.sendMessage(this.from, message);
     }
 
+    // ===== ADVANCED MEDIA FEATURES - NEU! =====
+    
+    async sendVoiceMessage(audioPath, mentions = []) {
+        const message = {
+            audio: { url: audioPath },
+            mimetype: 'audio/ogg; codecs=opus',
+            ptt: true // Push-to-talk (Voice Message)
+        };
+
+        if (mentions.length > 0) {
+            message.mentions = mentions;
+        }
+
+        return await this.client.socket.sendMessage(this.from, message);
+    }
+
+    async sendVoiceToMentioned(audioPath) {
+        const mentions = this.getMentions();
+        if (mentions.length === 0) {
+            return await this.sendVoiceMessage(audioPath);
+        }
+
+        const results = [];
+        for (const jid of mentions) {
+            try {
+                const result = await this.client.socket.sendMessage(jid, {
+                    audio: { url: audioPath },
+                    mimetype: 'audio/ogg; codecs=opus',
+                    ptt: true
+                });
+                results.push({ jid, success: true, result });
+            } catch (error) {
+                results.push({ jid, success: false, error: error.message });
+            }
+        }
+        return results;
+    }
+
+    async sendVideoMessage(videoPath, mentions = []) {
+        const message = {
+            video: { url: videoPath },
+            ptv: true, // Push-to-view (Video Message)
+            mimetype: 'video/mp4'
+        };
+
+        if (mentions.length > 0) {
+            message.mentions = mentions;
+        }
+
+        return await this.client.socket.sendMessage(this.from, message);
+    }
+
+    async sendVideoMessageToMentioned(videoPath) {
+        const mentions = this.getMentions();
+        if (mentions.length === 0) {
+            return await this.sendVideoMessage(videoPath);
+        }
+
+        const results = [];
+        for (const jid of mentions) {
+            try {
+                const result = await this.client.socket.sendMessage(jid, {
+                    video: { url: videoPath },
+                    ptv: true,
+                    mimetype: 'video/mp4'
+                });
+                results.push({ jid, success: true, result });
+            } catch (error) {
+                results.push({ jid, success: false, error: error.message });
+            }
+        }
+        return results;
+    }
+
+    async sendGif(gifPath, caption = "", mentions = []) {
+        const message = {
+            video: { url: gifPath },
+            caption: caption,
+            gifPlayback: true,
+            mimetype: 'video/mp4'
+        };
+
+        if (mentions.length > 0) {
+            message.mentions = mentions;
+        }
+
+        return await this.client.socket.sendMessage(this.from, message);
+    }
+
+    async sendGifToMentioned(gifPath, caption = "") {
+        const mentions = this.getMentions();
+        if (mentions.length === 0) {
+            return await this.sendGif(gifPath, caption);
+        }
+
+        const results = [];
+        for (const jid of mentions) {
+            try {
+                const result = await this.client.socket.sendMessage(jid, {
+                    video: { url: gifPath },
+                    caption: caption,
+                    gifPlayback: true,
+                    mimetype: 'video/mp4'
+                });
+                results.push({ jid, success: true, result });
+            } catch (error) {
+                results.push({ jid, success: false, error: error.message });
+            }
+        }
+        return results;
+    }
+
+    async sendVideoWithThumbnail(videoPath, thumbnailPath, caption = "", mentions = []) {
+        const message = {
+            video: { url: videoPath },
+            caption: caption,
+            jpegThumbnail: thumbnailPath,
+            mimetype: 'video/mp4'
+        };
+
+        if (mentions.length > 0) {
+            message.mentions = mentions;
+        }
+
+        return await this.client.socket.sendMessage(this.from, message);
+    }
+
+    async sendImageWithThumbnail(imagePath, thumbnailPath, caption = "", mentions = []) {
+        const message = {
+            image: { url: imagePath },
+            caption: caption,
+            jpegThumbnail: thumbnailPath
+        };
+
+        if (mentions.length > 0) {
+            message.mentions = mentions;
+        }
+
+        return await this.client.socket.sendMessage(this.from, message);
+    }
+
     async sendLocation(latitude, longitude) {
         return await this.client.socket.sendMessage(this.from, {
             location: {

package/src/multi-client.js

@@ -16,6 +16,7 @@ export class MultiWhatsAppClient {
             heartbeatInterval: options.heartbeatInterval || 20000,
             connectionTimeout: options.connectionTimeout || 180000,
             keepAlive: options.keepAlive !== false,
+            quietHeartbeat: options.quietHeartbeat !== false, // Heartbeat-Spam deaktivieren
             ...options
         });