waengine 1.9.6 → 1.9.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waengine",
-  "version": "1.9.6",
+  "version": "1.9.9",
   "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);
@@ -1257,6 +1278,60 @@ export class WhatsAppClient {
         }
     }
 
+    // ===== 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/device-detector.js

@@ -0,0 +1,376 @@
+/**
+ * WhatsApp Device Detector
+ * Erkennt Gerätetypen anhand der Message ID
+ * 
+ * Message ID Struktur:
+ * - WhatsApp Web: 3EB0XXXXXXXXXXXXXXXX (beginnt oft mit 3EB0)
+ * - Android: Meist 20 Zeichen, alphanumerisch
+ * - iPhone: Meist mit Bindestrichen, z.B. XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ * - Desktop: Ähnlich wie Web, aber andere Präfixe
+ * - Business: Spezielle Präfixe wie BAE5
+ */
+
+export class DeviceDetector {
+    constructor() {
+        // Pattern-Definitionen für verschiedene Gerätetypen
+        this.patterns = {
+            // WhatsApp Web - typische Präfixe
+            web: {
+                prefixes: ['3EB0', '3AA0', '3A', '3E'],
+                pattern: /^3[EA][AB0-9]{2}[A-F0-9]{16,20}$/i,
+                confidence: 0.85
+            },
+            
+            // iPhone/iOS - oft mit Bindestrichen oder spezifischen Mustern
+            iphone: {
+                prefixes: ['BAE5', 'ABCD'],
+                pattern: /^[A-F0-9]{8}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{12}$/i,
+                alternativePattern: /^[A-F0-9]{32}$/i,
+                confidence: 0.80
+            },
+            
+            // Android - meist alphanumerisch ohne Bindestriche
+            android: {
+                pattern: /^[A-F0-9]{20,32}$/i,
+                excludePrefixes: ['3EB0', '3AA0', 'BAE5'],
+                confidence: 0.75
+            },
+            
+            // WhatsApp Desktop (Windows/Mac)
+            desktop: {
+                prefixes: ['3EB1', '3EB2', '3AA1'],
+                pattern: /^3[EA][AB][12][A-F0-9]{16,20}$/i,
+                confidence: 0.85
+            },
+            
+            // WhatsApp Business
+            business: {
+                prefixes: ['BAE5', 'BAE6'],
+                pattern: /^BAE[56][A-F0-9]{16,20}$/i,
+                confidence: 0.90
+            }
+        };
+        
+        // Statistiken
+        this.stats = {
+            total: 0,
+            detected: {},
+            unknown: 0
+        };
+    }
+
+    /**
+     * Hauptfunktion: Erkennt Gerätetyp anhand der Message ID
+     * @param {string} messageId - Die WhatsApp Message ID
+     * @returns {Object} Erkennungsergebnis mit Gerätetyp und Confidence
+     */
+    detectDevice(messageId) {
+        if (!messageId || typeof messageId !== 'string') {
+            return this.createResult('unknown', 0, 'Ungültige Message ID');
+        }
+
+        this.stats.total++;
+        
+        // Normalisiere Message ID (Großbuchstaben, Leerzeichen entfernen)
+        const normalizedId = messageId.trim().toUpperCase();
+        
+        // Prüfe jeden Gerätetyp
+        const results = [];
+        
+        // 1. Business Check (höchste Priorität)
+        const businessResult = this.checkBusiness(normalizedId);
+        if (businessResult.confidence > 0.7) {
+            return this.recordResult(businessResult);
+        }
+        results.push(businessResult);
+        
+        // 2. iPhone Check
+        const iphoneResult = this.checkIPhone(normalizedId);
+        if (iphoneResult.confidence > 0.7) {
+            return this.recordResult(iphoneResult);
+        }
+        results.push(iphoneResult);
+        
+        // 3. Desktop Check
+        const desktopResult = this.checkDesktop(normalizedId);
+        if (desktopResult.confidence > 0.7) {
+            return this.recordResult(desktopResult);
+        }
+        results.push(desktopResult);
+        
+        // 4. Web Check
+        const webResult = this.checkWeb(normalizedId);
+        if (webResult.confidence > 0.7) {
+            return this.recordResult(webResult);
+        }
+        results.push(webResult);
+        
+        // 5. Android Check (niedrigste Priorität, da am unspezifischsten)
+        const androidResult = this.checkAndroid(normalizedId);
+        results.push(androidResult);
+        
+        // Bestes Ergebnis zurückgeben
+        const bestResult = results.reduce((best, current) => 
+            current.confidence > best.confidence ? current : best
+        );
+        
+        return this.recordResult(bestResult);
+    }
+
+    /**
+     * Prüft auf WhatsApp Business
+     */
+    checkBusiness(messageId) {
+        const { prefixes, pattern, confidence } = this.patterns.business;
+        
+        // Prefix-Check
+        const hasPrefix = prefixes.some(prefix => messageId.startsWith(prefix));
+        if (hasPrefix && pattern.test(messageId)) {
+            return this.createResult('business', confidence, 'Business Prefix erkannt');
+        }
+        
+        return this.createResult('business', 0, 'Kein Business Pattern');
+    }
+
+    /**
+     * Prüft auf iPhone/iOS
+     */
+    checkIPhone(messageId) {
+        const { prefixes, pattern, alternativePattern, confidence } = this.patterns.iphone;
+        
+        // UUID-Format (mit Bindestrichen)
+        if (pattern.test(messageId)) {
+            return this.createResult('iphone', confidence, 'UUID-Format erkannt');
+        }
+        
+        // Alternative: 32 Zeichen Hex ohne Bindestriche
+        if (alternativePattern.test(messageId)) {
+            // Zusätzliche Heuristik: iPhone IDs haben oft bestimmte Charakteristiken
+            const hasIPhoneCharacteristics = this.hasIPhoneCharacteristics(messageId);
+            if (hasIPhoneCharacteristics) {
+                return this.createResult('iphone', confidence * 0.9, 'iPhone Charakteristiken erkannt');
+            }
+        }
+        
+        // Prefix-Check
+        const hasPrefix = prefixes.some(prefix => messageId.startsWith(prefix));
+        if (hasPrefix) {
+            return this.createResult('iphone', confidence * 0.8, 'iPhone Prefix erkannt');
+        }
+        
+        return this.createResult('iphone', 0, 'Kein iPhone Pattern');
+    }
+
+    /**
+     * Prüft auf WhatsApp Desktop
+     */
+    checkDesktop(messageId) {
+        const { prefixes, pattern, confidence } = this.patterns.desktop;
+        
+        // Prefix-Check
+        const hasPrefix = prefixes.some(prefix => messageId.startsWith(prefix));
+        if (hasPrefix && pattern.test(messageId)) {
+            return this.createResult('desktop', confidence, 'Desktop Prefix erkannt');
+        }
+        
+        return this.createResult('desktop', 0, 'Kein Desktop Pattern');
+    }
+
+    /**
+     * Prüft auf WhatsApp Web
+     */
+    checkWeb(messageId) {
+        const { prefixes, pattern, confidence } = this.patterns.web;
+        
+        // Prefix-Check
+        const hasPrefix = prefixes.some(prefix => messageId.startsWith(prefix));
+        if (hasPrefix && pattern.test(messageId)) {
+            return this.createResult('web', confidence, 'Web Prefix erkannt');
+        }
+        
+        return this.createResult('web', 0, 'Kein Web Pattern');
+    }
+
+    /**
+     * Prüft auf Android
+     */
+    checkAndroid(messageId) {
+        const { pattern, excludePrefixes, confidence } = this.patterns.android;
+        
+        // Ausschluss-Check: Nicht wenn andere spezifische Präfixe
+        const hasExcludedPrefix = excludePrefixes.some(prefix => 
+            messageId.startsWith(prefix)
+        );
+        
+        if (hasExcludedPrefix) {
+            return this.createResult('android', 0, 'Ausgeschlossener Prefix');
+        }
+        
+        // Pattern-Check
+        if (pattern.test(messageId)) {
+            // Android ist der Fallback, daher niedrigere Confidence
+            return this.createResult('android', confidence, 'Android Pattern erkannt');
+        }
+        
+        return this.createResult('android', 0, 'Kein Android Pattern');
+    }
+
+    /**
+     * Heuristische Prüfung auf iPhone-Charakteristiken
+     */
+    hasIPhoneCharacteristics(messageId) {
+        // iPhone IDs haben oft eine gleichmäßigere Verteilung von Zeichen
+        const charDistribution = this.analyzeCharDistribution(messageId);
+        
+        // Prüfe auf gleichmäßige Verteilung (iPhone typisch)
+        const isBalanced = charDistribution.variance < 0.3;
+        
+        return isBalanced;
+    }
+
+    /**
+     * Analysiert die Zeichenverteilung
+     */
+    analyzeCharDistribution(str) {
+        const counts = {};
+        for (const char of str) {
+            counts[char] = (counts[char] || 0) + 1;
+        }
+        
+        const values = Object.values(counts);
+        const mean = values.reduce((a, b) => a + b, 0) / values.length;
+        const variance = values.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / values.length;
+        
+        return { mean, variance: variance / mean };
+    }
+
+    /**
+     * Erstellt ein Erkennungsergebnis
+     */
+    createResult(deviceType, confidence, reason) {
+        return {
+            deviceType,
+            confidence: Math.round(confidence * 100) / 100,
+            reason,
+            timestamp: Date.now()
+        };
+    }
+
+    /**
+     * Zeichnet Ergebnis in Statistiken auf
+     */
+    recordResult(result) {
+        if (result.confidence > 0.5) {
+            this.stats.detected[result.deviceType] = 
+                (this.stats.detected[result.deviceType] || 0) + 1;
+        } else {
+            this.stats.unknown++;
+        }
+        
+        return result;
+    }
+
+    /**
+     * Batch-Erkennung für mehrere Message IDs
+     */
+    detectBatch(messageIds) {
+        return messageIds.map(id => ({
+            messageId: id,
+            ...this.detectDevice(id)
+        }));
+    }
+
+    /**
+     * Erweiterte Analyse mit zusätzlichen Informationen
+     */
+    analyzeMessage(message) {
+        const messageId = message.key?.id || message.id;
+        const detection = this.detectDevice(messageId);
+        
+        return {
+            messageId,
+            ...detection,
+            metadata: {
+                length: messageId?.length || 0,
+                hasHyphens: messageId?.includes('-') || false,
+                prefix: messageId?.substring(0, 4) || '',
+                timestamp: message.messageTimestamp || message.timestamp,
+                from: message.key?.remoteJid || message.from,
+                isGroup: (message.key?.remoteJid || message.from)?.includes('@g.us')
+            }
+        };
+    }
+
+    /**
+     * Gibt Statistiken zurück
+     */
+    getStats() {
+        return {
+            ...this.stats,
+            detectionRate: this.stats.total > 0 
+                ? Math.round(((this.stats.total - this.stats.unknown) / this.stats.total) * 100)
+                : 0
+        };
+    }
+
+    /**
+     * Setzt Statistiken zurück
+     */
+    resetStats() {
+        this.stats = {
+            total: 0,
+            detected: {},
+            unknown: 0
+        };
+    }
+
+    /**
+     * Gibt eine lesbare Beschreibung des Gerätetyps zurück
+     */
+    getDeviceDescription(deviceType) {
+        const descriptions = {
+            web: '🌐 WhatsApp Web',
+            iphone: '📱 iPhone/iOS',
+            android: '🤖 Android',
+            desktop: '💻 WhatsApp Desktop',
+            business: '💼 WhatsApp Business',
+            unknown: '❓ Unbekannt'
+        };
+        
+        return descriptions[deviceType] || descriptions.unknown;
+    }
+
+    /**
+     * Formatiert ein Erkennungsergebnis für die Ausgabe
+     */
+    formatResult(result) {
+        const description = this.getDeviceDescription(result.deviceType);
+        const confidenceBar = '█'.repeat(Math.round(result.confidence * 10));
+        
+        return {
+            device: description,
+            confidence: `${Math.round(result.confidence * 100)}%`,
+            confidenceBar,
+            reason: result.reason,
+            reliable: result.confidence >= 0.7
+        };
+    }
+}
+
+// Singleton-Instanz für einfache Verwendung
+export const deviceDetector = new DeviceDetector();
+
+/**
+ * Convenience-Funktionen für direkten Import
+ */
+export function detectDevice(messageId) {
+    return deviceDetector.detectDevice(messageId);
+}
+
+export function detectDeviceFromMessage(message) {
+    return deviceDetector.analyzeMessage(message);
+}
+
+export function getDeviceStats() {
+    return deviceDetector.getStats();
+}

package/src/index.js

@@ -1,6 +1,7 @@
 export { WhatsAppClient } from "./client.js";
 export { MultiWhatsAppClient } from "./multi-client.js";
 export { DeviceManager } from "./device-manager.js";
+export { DeviceDetector, deviceDetector, detectDevice, detectDeviceFromMessage, getDeviceStats } from "./device-detector.js";
 export { PrefixManager } from "./prefix-manager.js";
 export { WAStorage, createStorage, getStorage, write, read, del } from "./storage.js";
 export { AIIntegration } from "./ai-integration.js";

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 }