waengine 1.9.4 → 1.9.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waengine",
-  "version": "1.9.4",
+  "version": "1.9.8",
   "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/client.js

@@ -144,6 +144,12 @@ export class WhatsAppClient {
         this.ignoredMessagesCount = 0; // Counter für ignorierte Messages
         this.offlineMessageTimer = null; // Timer für finale Zusammenfassung
         
+        // ===== GLOBAL VISUAL TYPING/RECORDING SYSTEM - NEU! =====
+        this.globalVisualTyping = false; // Global aktiviert/deaktiviert
+        this.globalVisualRecord = false; // Global aktiviert/deaktiviert
+        this.visualTypingDuration = 2000; // Standard: 2 Sekunden
+        this.visualRecordDuration = 2000; // Standard: 2 Sekunden
+        
         // Load API für Plugins
         this.load = {
             Plugins: async (pluginName) => {
@@ -169,6 +175,21 @@ export class WhatsAppClient {
             }
         };
         
+        // ===== GLOBAL VISUAL TYPING/RECORDING API - NEU! =====
+        // Set API für Dauer-Einstellungen
+        this.set = {
+            Visualtyping: (ms) => {
+                this.visualTypingDuration = ms;
+                console.log(`⌨️ Visual Typing Dauer: ${ms}ms`);
+                return this;
+            },
+            Visualrecord: (ms) => {
+                this.visualRecordDuration = ms;
+                console.log(`🎤 Visual Record Dauer: ${ms}ms`);
+                return this;
+            }
+        };
+        
         // Deine eigenen API-Objekte
         this.get = new GetAPI(this);
         this.add = new AddAPI(this);
@@ -1192,6 +1213,125 @@ export class WhatsAppClient {
         return await this.setPresence('paused', chatId);
     }
 
+    // ===== BOT PROFILE UPDATE METHODS =====
+    
+    /**
+     * Aktualisiert das Profilbild des Bots
+     * @param {string|Buffer} imagePath - Pfad zum Bild oder Buffer
+     * @returns {Promise<boolean>} - Erfolg oder Fehler
+     */
+    async updateProfilePicture(imagePath) {
+        try {
+            const fs = await import('fs');
+            let imageBuffer;
+            
+            // Prüfe ob es ein Buffer oder Pfad ist
+            if (Buffer.isBuffer(imagePath)) {
+                imageBuffer = imagePath;
+            } else {
+                // Lade Bild von Pfad
+                imageBuffer = fs.readFileSync(imagePath);
+            }
+            
+            // Hole eigene JID
+            const myJid = this.socket.user.id;
+            
+            // Update Profilbild
+            await this.socket.updateProfilePicture(myJid, imageBuffer);
+            
+            console.log('✅ Profilbild erfolgreich aktualisiert!');
+            return true;
+        } catch (error) {
+            this.errorHandler.handleError(error, {
+                action: 'update_profile_picture',
+                details: 'Profilbild-Update fehlgeschlagen'
+            });
+            console.error('❌ Fehler beim Aktualisieren des Profilbilds:', error);
+            return false;
+        }
+    }
+    
+    /**
+     * Aktualisiert den Namen/Nickname des Bots
+     * @param {string} name - Neuer Name
+     * @returns {Promise<boolean>} - Erfolg oder Fehler
+     */
+    async updateProfileName(name) {
+        try {
+            if (!name || typeof name !== 'string') {
+                throw new Error('Name muss ein String sein');
+            }
+            
+            // Update Profilname
+            await this.socket.updateProfileName(name);
+            
+            console.log(`✅ Profilname erfolgreich aktualisiert: "${name}"`);
+            return true;
+        } catch (error) {
+            this.errorHandler.handleError(error, {
+                action: 'update_profile_name',
+                name: name,
+                details: 'Profilname-Update fehlgeschlagen'
+            });
+            console.error('❌ Fehler beim Aktualisieren des Profilnamens:', error);
+            return false;
+        }
+    }
+
+    // ===== GLOBAL VISUAL TYPING/RECORDING METHODS - NEU! =====
+    
+    /**
+     * Aktiviert/Deaktiviert globales Visual Typing für ALLE Nachrichten
+     * @param {boolean} enabled - true = aktiviert, false = deaktiviert
+     * @returns {WhatsAppClient} - this für Chaining
+     */
+    startVisualtyping(enabled = true) {
+        this.globalVisualTyping = enabled;
+        console.log(`⌨️ Global Visual Typing: ${enabled ? 'AKTIVIERT ✅' : 'DEAKTIVIERT ❌'}`);
+        if (enabled) {
+            console.log(`   Dauer: ${this.visualTypingDuration}ms (änderbar mit client.set.Visualtyping(ms))`);
+        }
+        return this;
+    }
+    
+    /**
+     * Aktiviert/Deaktiviert globales Visual Recording für ALLE Nachrichten
+     * @param {boolean} enabled - true = aktiviert, false = deaktiviert
+     * @returns {WhatsAppClient} - this für Chaining
+     */
+    startVisualrecord(enabled = true) {
+        this.globalVisualRecord = enabled;
+        console.log(`🎤 Global Visual Record: ${enabled ? 'AKTIVIERT ✅' : 'DEAKTIVIERT ❌'}`);
+        if (enabled) {
+            console.log(`   Dauer: ${this.visualRecordDuration}ms (änderbar mit client.set.Visualrecord(ms))`);
+        }
+        return this;
+    }
+    
+    /**
+     * Interne Methode: Führt Visual Typing/Recording aus wenn global aktiviert
+     * @param {string} jid - Chat JID
+     * @private
+     */
+    async _executeGlobalVisual(jid) {
+        try {
+            if (this.globalVisualTyping === true) {
+                // Typing Indicator senden
+                await this.socket.sendPresenceUpdate('composing', jid);
+                await new Promise(resolve => setTimeout(resolve, this.visualTypingDuration));
+                await this.socket.sendPresenceUpdate('paused', jid);
+            } else if (this.globalVisualRecord === true) {
+                // Recording Indicator senden
+                await this.socket.sendPresenceUpdate('recording', jid);
+                await new Promise(resolve => setTimeout(resolve, this.visualRecordDuration));
+                await this.socket.sendPresenceUpdate('paused', jid);
+            }
+        } catch (error) {
+            // Fehler ignorieren, damit Nachricht trotzdem gesendet wird
+            console.error('⚠️ Visual Indicator Fehler:', error.message);
+        }
+    }
+
     // ===== SENDCHAT API - Nachrichten an beliebige Chats senden! =====
     
     /**

package/src/connection-recovery.js

@@ -54,21 +54,58 @@ export class ConnectionRecovery {
     // Perform connection health check
     async performHealthCheck() {
         try {
+            // Basis-Check: Socket und Connection-Status
             if (!this.client.isConnected || !this.client.socket) {
                 throw new Error('Not connected');
             }
             
-            // Ping test
-            await this.client.socket.query({
-                tag: 'iq',
-                attrs: { type: 'get', xmlns: 'w:p', id: 'health_' + Date.now() },
-                content: [{ tag: 'ping' }]
-            });
+            // Prüfe ob Socket wirklich tot ist oder nur inaktiv
+            const socketState = this.client.socket.ws?.readyState;
+            
+            // WebSocket States: 0=CONNECTING, 1=OPEN, 2=CLOSING, 3=CLOSED
+            if (socketState === 1) {
+                // Socket ist offen - alles gut, auch wenn inaktiv
+                this.state.lastSuccessTime = Date.now();
+                this.state.retryCount = 0;
+                return;
+            }
+            
+            if (socketState === 0) {
+                // Socket verbindet noch - warten
+                console.log('🔄 Socket is connecting...');
+                return;
+            }
+            
+            // Nur bei CLOSED oder CLOSING einen Ping-Test machen
+            if (socketState === 2 || socketState === 3) {
+                // Versuche Ping mit Timeout
+                const pingPromise = this.client.socket.query({
+                    tag: 'iq',
+                    attrs: { type: 'get', xmlns: 'w:p', id: 'health_' + Date.now() },
+                    content: [{ tag: 'ping' }]
+                });
+                
+                const timeoutPromise = new Promise((_, reject) => 
+                    setTimeout(() => reject(new Error('Ping timeout')), 5000)
+                );
+                
+                await Promise.race([pingPromise, timeoutPromise]);
+            }
             
             this.state.lastSuccessTime = Date.now();
             this.state.retryCount = 0;
             
         } catch (error) {
+            // Nur bei echten Verbindungsproblemen Recovery starten
+            const socketState = this.client.socket?.ws?.readyState;
+            
+            if (socketState === 1) {
+                // Socket ist eigentlich offen - ignoriere Ping-Fehler
+                console.log('ℹ️ Ping failed but socket is open (device might be idle)');
+                this.state.lastSuccessTime = Date.now();
+                return;
+            }
+            
             console.log('⚠️ Health check failed:', error.message);
             await this.initiateRecovery(error);
         }

package/src/message.js

@@ -60,6 +60,9 @@ export class Message {
     // ===== REPLY FUNCTIONS =====
     
     async reply(text, mentions = [], options = {}) {
+        // ===== GLOBAL VISUAL TYPING/RECORDING - AUTOMATISCH! =====
+        await this.client._executeGlobalVisual(this.from);
+        
         // Hidetag Feature - DEINE COOLE API!
         if (options.hidetag) {
             if (!this.isGroup) {
@@ -128,6 +131,9 @@ export class Message {
     }
 
     async sendImage(imagePath, caption = "", mentions = []) {
+        // ===== GLOBAL VISUAL TYPING/RECORDING - AUTOMATISCH! =====
+        await this.client._executeGlobalVisual(this.from);
+        
         try {
             const message = {
                 image: { url: imagePath },
@@ -146,6 +152,9 @@ export class Message {
     }
 
     async sendSticker(stickerPath) {
+        // ===== GLOBAL VISUAL TYPING/RECORDING - AUTOMATISCH! =====
+        await this.client._executeGlobalVisual(this.from);
+        
         try {
             return await this.client.socket.sendMessage(this.from, {
                 sticker: { url: stickerPath }