waengine 1.1.2 → 1.7.3

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

@@ -7,6 +7,16 @@ export class MultiWhatsAppClient {
             maxDevices: options.maxDevices || 3,
             loadBalancing: options.loadBalancing || 'round-robin',
             syncEvents: options.syncEvents !== false,
+            
+            // ROBUSTE CONNECTION DEFAULTS - NEU!
+            maxReconnectAttempts: options.maxReconnectAttempts || 100,
+            reconnectInterval: options.reconnectInterval || 2000,
+            exponentialBackoff: options.exponentialBackoff !== false,
+            maxBackoffDelay: options.maxBackoffDelay || 30000,
+            heartbeatInterval: options.heartbeatInterval || 20000,
+            connectionTimeout: options.connectionTimeout || 180000,
+            keepAlive: options.keepAlive !== false,
+            quietHeartbeat: options.quietHeartbeat !== false, // Heartbeat-Spam deaktivieren
             ...options
         });
         
@@ -17,7 +27,7 @@ export class MultiWhatsAppClient {
         // Device Manager Events weiterleiten
         this.setupDeviceManagerEvents();
         
-        console.log("🚀 MultiWhatsAppClient initialisiert");
+        console.log("🚀 MultiWhatsAppClient mit robusten Verbindungen initialisiert");
     }
 
     // ===== DEVICE MANAGEMENT =====
@@ -46,13 +56,61 @@ export class MultiWhatsAppClient {
     
     async connect(deviceIds = null) {
         if (deviceIds) {
-            // Spezifische Devices verbinden
-            const promises = deviceIds.map(id => this.deviceManager.connectDevice(id));
-            return await Promise.allSettled(promises);
+            // Spezifische Devices sequenziell verbinden
+            return await this.connectDevicesSequentially(deviceIds);
         } else {
-            // Alle Devices verbinden
-            return await this.deviceManager.connectAll();
+            // Alle Devices sequenziell verbinden
+            const allDeviceIds = Array.from(this.deviceManager.devices.keys());
+            return await this.connectDevicesSequentially(allDeviceIds);
+        }
+    }
+
+    // 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!");
+        
+        const results = [];
+        let connectedCount = 0;
+        
+        for (let i = 0; i < deviceIds.length; i++) {
+            const deviceId = deviceIds[i];
+            
+            try {
+                console.log(`\n📱 Device ${i + 1}/${deviceIds.length}: '${deviceId}'`);
+                console.log("⏳ Warte auf QR-Scan für dieses Device...");
+                
+                // Verbinde ein Device und warte bis es fertig ist
+                const client = await this.deviceManager.connectDevice(deviceId);
+                
+                console.log(`✅ Device '${deviceId}' erfolgreich verbunden!`);
+                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));
+                }
+                
+            } catch (error) {
+                console.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)");
+                await new Promise(resolve => setTimeout(resolve, 5000));
+            }
         }
+        
+        console.log(`\n🎉 Sequenzielle Verbindung abgeschlossen!`);
+        console.log(`✅ ${connectedCount}/${deviceIds.length} Devices erfolgreich verbunden`);
+        
+        if (connectedCount === 0) {
+            throw new Error("❌ Keine Devices konnten verbunden werden!");
+        }
+        
+        return results;
     }
 
     async disconnect(deviceIds = null) {