waengine 1.8.3 → 1.9.4

package/FEATURES.md

@@ -458,6 +458,217 @@ msg.raw         // Raw Baileys Object
 
 ---
 
+## 📥 Media Download System **NEU in v1.7.9!**
+
+### **Download Media von Nachrichten**
+
+```javascript
+// Media von Message herunterladen
+const result = await msg.downloadMedia();
+
+if (result.success) {
+    console.log(`Downloaded: ${result.info.type}`);
+    console.log(`Size: ${result.info.fileSize} bytes`);
+    console.log(`Mimetype: ${result.info.mimetype}`);
+    
+    // Buffer verwenden
+    const buffer = result.buffer;
+    
+    // Oder direkt speichern
+    const saved = await msg.downloadMedia({
+        savePath: './downloads',
+        fileName: 'custom_name.jpg'
+    });
+    
+    console.log(`Saved to: ${saved.savedPath}`);
+}
+```
+
+**Download Features:**
+- ✅ **Alle Media-Typen** - Bilder, Videos, Audio, Dokumente, Sticker
+- ✅ **Buffer Return** - Direkter Zugriff auf Media-Buffer
+- ✅ **Auto-Save** - Optional direkt speichern
+- ✅ **Media Info** - Typ, Größe, Mimetype, Dateiname
+- ✅ **Caption Support** - Caption wird mit zurückgegeben
+- ✅ **Error Handling** - Detaillierte Fehlerbehandlung
+
+**Praktische Anwendungen:**
+```javascript
+// Auto-Sticker aus Bildern
+client.on('message', async (msg) => {
+    if (msg.type === 'imageMessage' && msg.text?.toLowerCase() === 'sticker') {
+        const media = await msg.downloadMedia();
+        
+        if (media.success) {
+            await msg.create.sticker.fromMedia(media.buffer, {
+                pack: 'Auto Stickers',
+                author: 'Bot'
+            });
+        }
+    }
+});
+
+// Media-Backup System
+client.on('message', async (msg) => {
+    const mediaTypes = ['imageMessage', 'videoMessage', 'audioMessage'];
+    
+    if (mediaTypes.includes(msg.type)) {
+        await msg.downloadMedia({
+            savePath: './media_backup',
+            fileName: `${msg.id}_${Date.now()}`
+        });
+    }
+});
+
+// Media-Weiterleitung
+client.addCommand('forward-media', async (msg) => {
+    const media = await msg.downloadMedia();
+    
+    if (media.success) {
+        // An anderen Chat senden
+        await client.socket.sendMessage(targetJid, {
+            [media.info.type]: media.buffer,
+            caption: media.info.caption
+        });
+    }
+});
+```
+
+---
+
+## 🎤 Enhanced Recording System
+
+### **Erweiterte Recording-Funktionen**
+
+```javascript
+// Recording starten/stoppen
+await msg.startRecording();
+await msg.stopRecording();
+
+// Recording für bestimmte Zeit
+await msg.simulateRecording(3000); // 3 Sekunden
+
+// Recording + Custom Function
+await msg.recordAndSend(async () => {
+    await msg.sendImage('photo.jpg', 'Nach Recording!');
+}, 3000);
+
+// Recording + Reply
+await msg.recordAndReply('Sprachnachricht!', 2500);
+
+// Visual Record (unified)
+await msg.visualRecord(true);  // Start
+await msg.visualRecord(false); // Stop
+```
+
+**Recording Features:**
+- ✅ **Start/Stop Control** - Manuelles Recording-Control
+- ✅ **Timed Recording** - Automatisches Stoppen nach Zeit
+- ✅ **Record & Send** - Recording + Custom Function
+- ✅ **Record & Reply** - Recording + Antwort
+- ✅ **Realistic Timing** - Basierend auf Nachrichtenlänge
+
+---
+
+## ⌨️ Enhanced Typing System
+
+### **Erweiterte Typing-Funktionen**
+
+```javascript
+// Typing starten/stoppen
+await msg.startTyping();
+await msg.stopTyping();
+
+// Typing für bestimmte Zeit
+await msg.typeFor(3000); // 3 Sekunden
+
+// Typing mit Auto-Stop
+await msg.visualWrite(true, 2000); // Stoppt automatisch nach 2s
+
+// Typing + Custom Function
+await msg.typeAndSend(async () => {
+    await msg.sendImage('photo.jpg');
+}, 2000);
+
+// Convenience Methods
+await msg.quickType('Text');      // 1 Sekunde
+await msg.normalType('Text');     // 2 Sekunden
+await msg.slowType('Text');       // 4 Sekunden
+await msg.realisticType('Text');  // Basierend auf Textlänge
+
+// Typing mit Mentions
+await msg.quickTypeWithMention('Hello @user!', userJid);
+await msg.normalTypeWithMention('Hi @user!', userJid);
+await msg.slowTypeWithMention('Hey @user!', userJid);
+```
+
+**Enhanced Typing Features:**
+- ✅ **Start/Stop Control** - Manuelles Typing-Control
+- ✅ **Timed Typing** - Automatisches Stoppen
+- ✅ **Auto-Stop** - Mit Duration-Parameter
+- ✅ **Type & Send** - Typing + Custom Function
+- ✅ **Convenience Methods** - Quick/Normal/Slow/Realistic
+- ✅ **Mention Support** - Typing mit Mentions kombiniert
+
+---
+
+## 📝 Enhanced Mention System
+
+### **Erweiterte Mention-Funktionen**
+
+```javascript
+// Mention mit Typing
+await msg.slowTypeWithMention('Hello @user!', userJid);
+await msg.quickTypeWithMention('Hi @user!', userJid);
+await msg.normalTypeWithMention('Hey @user!', userJid);
+
+// Mention All
+await msg.mentionAll('Important announcement!');
+
+// Reply mit Mention
+await msg.replyWithMention('Thanks @user!', userJid);
+
+// Check if mentioned
+const isMentioned = msg.isMentioned(userJid);
+
+// Get all mentions
+const mentions = msg.getMentions();
+```
+
+**Enhanced Mention Features:**
+- ✅ **Typing + Mention** - Kombiniert Typing mit Mentions
+- ✅ **Mention All** - Alle Gruppenmitglieder erwähnen
+- ✅ **Reply with Mention** - Antwort mit Mention
+- ✅ **Mention Check** - Prüfen ob User erwähnt wurde
+- ✅ **Get Mentions** - Alle Mentions aus Message
+
+---
+
+## 🔧 Enhanced Message Editing
+
+### **Erweiterte Edit-Funktionen**
+
+```javascript
+// Gesendete Nachricht bearbeiten
+const sentMsg = await msg.reply('Original text');
+await msg.editSent(sentMsg, 'Edited text');
+
+// Mit Error Handling
+try {
+    await msg.editSent(sentMsg, 'New text');
+    console.log('✅ Message edited');
+} catch (error) {
+    console.log('❌ Edit failed:', error.message);
+}
+```
+
+**Edit Features:**
+- ✅ **Edit Sent Messages** - Gesendete Nachrichten bearbeiten
+- ✅ **Error Handling** - Graceful Fehlerbehandlung
+- ✅ **Validation** - Prüft ob Message editierbar ist
+
+---
+
 ## 🎭 Typing Indicator
 
 ### **Manual Control**
@@ -3265,7 +3476,377 @@ const progress = ui.createProgress({
 - 📢 **Advanced Status Features** - Status Updates, Views
 - 💼 **Business Features** - Business Profile, Products, Payments
 - ⚙️ **System Features** - Backup, Restore, Export, Sync
-- 🖼️ **Profile Picture Features** - Get/Send Profile Pictures
+- 🖼️ **Profile Picture Features** - Get/Send Profile Picture
+
+---
+
+## 🛡️ Ultra-Robust Recovery Systems **NEU in v2.0.0!**
+
+### **Connection Recovery System**
+
+Automatische Wiederherstellung bei allen Verbindungsproblemen mit intelligenten Recovery-Strategien.
+
+```javascript
+// Connection Recovery aktivieren
+const recovery = client.connectionRecovery;
+
+// Health Monitoring starten
+recovery.startHealthMonitoring();
+
+// Recovery-Statistiken abrufen
+const stats = recovery.getStats();
+console.log(`Retry Count: ${stats.retryCount}`);
+console.log(`Last Error: ${stats.lastError}`);
+console.log(`Failure Count: ${stats.failureCount}`);
+
+// Recovery manuell initiieren
+await recovery.initiateRecovery(error);
+
+// Recovery-Status zurücksetzen
+recovery.reset();
+```
+
+**Recovery-Strategien (automatisch):**
+1. **Quick Reconnect** - Schnelle Wiederverbindung
+2. **Socket Reset** - Socket neu initialisieren
+3. **Session Repair** - Session reparieren
+4. **Full Restart** - Kompletter Neustart
+
+**Recovery Features:**
+- ✅ **Exponential Backoff** - Intelligente Wartezeiten
+- ✅ **Jitter Factor** - Verhindert Thundering Herd
+- ✅ **Health Checks** - Automatische Verbindungsprüfung
+- ✅ **Max Retries** - Konfigurierbare Retry-Limits
+- ✅ **Failure History** - Vollständige Fehlerhistorie
+- ✅ **Auto-Recovery** - Automatische Wiederherstellung
+
+**Konfiguration:**
+```javascript
+const client = new WhatsAppClient({
+    connectionRecovery: {
+        maxRetries: 10,
+        baseDelay: 2000,
+        maxDelay: 60000,
+        exponentialBackoff: true,
+        jitterFactor: 0.1,
+        healthCheckInterval: 30000
+    }
+});
+```
+
+---
+
+### **Auth Recovery System**
+
+Automatische Wiederherstellung bei Authentifizierungs-Problemen mit Smart Backup System.
+
+```javascript
+// Auth Recovery verwenden
+const authRecovery = client.authRecovery;
+
+// Auto-Backup starten (jede Stunde)
+authRecovery.startAutoBackup();
+
+// Smart Backup erstellen (nur wenn Session valid)
+await authRecovery.createSmartBackup();
+
+// Session-Korruption erkennen
+const issues = await authRecovery.detectCorruption();
+console.log(`Gefundene Probleme: ${issues.length}`);
+
+// Auto-Repair durchführen
+const result = await authRecovery.autoRepair();
+if (result.repaired) {
+    console.log(`✅ Repariert mit: ${result.method}`);
+}
+
+// Von bestem Backup wiederherstellen
+const recovered = await authRecovery.recoverFromBestBackup();
+
+// Recovery-Statistiken
+const stats = authRecovery.getStats();
+console.log(`Backups: ${stats.backupCount}`);
+console.log(`Auto-Backup: ${stats.autoBackupEnabled ? 'AN' : 'AUS'}`);
+```
+
+**Auth Recovery Features:**
+- ✅ **Smart Backups** - Nur valide Sessions werden gesichert
+- ✅ **Auto-Backup** - Stündliche automatische Backups
+- ✅ **Corruption Detection** - Erkennt beschädigte Sessions
+- ✅ **Auto-Repair** - Automatische Reparatur
+- ✅ **Backup History** - Mehrere Backup-Versionen
+- ✅ **Best Backup Recovery** - Wählt bestes Backup automatisch
+- ✅ **Max Backups** - Automatisches Cleanup alter Backups
+
+**Erkannte Probleme:**
+- Missing Auth Directory
+- Missing/Empty creds.json
+- Corrupted JSON
+- Invalid Structure
+- Temp Files
+- Permission Errors
+
+---
+
+### **Resource Manager**
+
+Verhindert Memory Leaks und verwaltet alle Ressourcen automatisch.
+
+```javascript
+// Resource Manager verwenden
+import { globalResourceManager } from 'waengine';
+
+// Ressource registrieren
+const resourceId = globalResourceManager.register('connection', socket, {
+    cleanup: async () => await socket.end(),
+    type: 'socket'
+});
+
+// Ressource freigeben
+await globalResourceManager.release(resourceId);
+
+// Alle Ressourcen eines Typs freigeben
+await globalResourceManager.releaseByType('socket');
+
+// Alle Ressourcen freigeben
+await globalResourceManager.releaseAll();
+
+// Statistiken abrufen
+const stats = globalResourceManager.getStats();
+console.log(`Aktive Ressourcen: ${stats.active}`);
+console.log(`Memory Usage: ${stats.memoryUsage}MB`);
+
+// Memory Leak Detection
+const leaks = globalResourceManager.detectLeaks();
+if (leaks.length > 0) {
+    console.log(`⚠️ ${leaks.length} potenzielle Memory Leaks gefunden`);
+}
+```
+
+**Resource Manager Features:**
+- ✅ **Automatic Cleanup** - Automatische Ressourcen-Freigabe
+- ✅ **Memory Leak Detection** - Erkennt Memory Leaks
+- ✅ **Resource Tracking** - Vollständiges Tracking
+- ✅ **Type-based Management** - Nach Typ verwalten
+- ✅ **Statistics** - Detaillierte Statistiken
+- ✅ **Health Monitoring** - Ressourcen-Gesundheit
+
+---
+
+## 🛡️ Anti-Ban Protection System
+
+Schützt Bots vor WhatsApp-Bans durch intelligente Verhaltens-Mimikry.
+
+```javascript
+// Anti-Ban Protection verwenden
+const antiBan = client.antiBan;
+
+// Geschützte Nachricht senden
+await antiBan.sendMessageProtected(jid, { text: 'Hello!' });
+
+// Geschützte Aktion ausführen
+await antiBan.performActionProtected(async () => {
+    await client.socket.groupSettingUpdate(groupId, 'announcement');
+}, 'group_settings');
+
+// Menschliches Tippen simulieren
+await antiBan.simulateHumanTyping('Lange Nachricht...');
+
+// Presence Updates
+await antiBan.updatePresence('available'); // online
+await antiBan.updatePresence('unavailable'); // offline
+
+// Nachricht "lesen" simulieren
+await antiBan.simulateReadMessage(jid, messageKey);
+
+// Hintergrund-Aktivität starten
+antiBan.startBackgroundActivity();
+
+// Features konfigurieren
+antiBan.setFeature('humanTyping', true);
+antiBan.setFeature('randomDelays', true);
+antiBan.setFeature('presenceUpdates', true);
+
+// Alle Features aktivieren (maximaler Schutz)
+antiBan.enableAllFeatures();
+
+// Statistiken anzeigen
+antiBan.printStats();
+const stats = antiBan.getStats();
+```
+
+**Anti-Ban Features:**
+- ✅ **Human Typing** - Simuliert menschliches Tippen (40-60 WPM)
+- ✅ **Random Delays** - Zufällige menschliche Verzögerungen
+- ✅ **Presence Updates** - Realistische Online/Offline Status
+- ✅ **Read Receipts** - Simuliert Lesen von Nachrichten
+- ✅ **Typing Indicator** - "tippt..." Anzeige
+- ✅ **Smart Browser** - Realistische Browser-Strings
+- ✅ **Background Activity** - Gelegentliche Idle-Aktivität
+- ✅ **Session Rotation** - Optional: Session-Rotation
+
+**Schutz-Level:**
+```javascript
+// Minimaler Schutz (schnell)
+antiBan.disable();
+
+// Standard Schutz (empfohlen)
+antiBan.enable();
+
+// Maximaler Schutz (sicher)
+antiBan.enableAllFeatures();
+antiBan.startBackgroundActivity();
+```
+
+**Statistiken:**
+- Messages Protected
+- Actions Protected
+- Bans Avoided
+- Suspicious Activity Prevented
+- Session Duration
+- Messages per Hour
+
+---
+
+## 🎨 Console Logger System
+
+Schöne animierte Console-Ausgabe ohne Spam.
+
+```javascript
+// Console Logger verwenden
+import { logger } from 'waengine';
+
+// Banner anzeigen
+logger.showBanner();
+
+// Setup Animation
+await logger.animateSetup();
+
+// QR-Code Animation
+await logger.animateQRGeneration('bot1', 1, 2);
+
+// Connection Animation
+await logger.animateConnection('bot1', true);
+
+// Device Pause
+await logger.showDevicePause(3);
+
+// Finale Zusammenfassung
+logger.showFinalSummary(['bot1', 'bot2'], true);
+
+// Dynamische Ready Message
+logger.showDynamicReadyMessage(client);
+
+// Progress Bar erstellen
+const bar = logger.createProgressBar('download', 'Downloading', 100);
+logger.updateProgressBar('download', 50);
+logger.completeProgressBar('download', '✅ Done');
+
+// Simple Logs
+logger.info('Information');
+logger.success('Erfolg!');
+logger.warning('Warnung!');
+logger.error('Fehler!');
+
+// Console leeren
+logger.clear();
+```
+
+**Console Logger Features:**
+- ✅ **Animated Banner** - Schöner Startup-Banner
+- ✅ **Progress Bars** - Animierte Fortschrittsbalken
+- ✅ **Setup Animation** - Schöne Setup-Sequenz
+- ✅ **QR Animation** - QR-Code Box mit Animation
+- ✅ **Connection Animation** - Verbindungs-Animation
+- ✅ **Device Status** - Schöne Device-Anzeige
+- ✅ **Dynamic Messages** - Dynamische Ready-Messages
+- ✅ **Color Support** - Farbige Ausgabe
+- ✅ **Silent Mode** - Komplett deaktivierbar
+
+---
+
+## 🔧 Device Manager
+
+Professionelles Multi-Device Management mit Load Balancing.
+
+```javascript
+// Device Manager verwenden
+import { DeviceManager } from 'waengine';
+
+const deviceManager = new DeviceManager({
+    maxDevices: 3,
+    loadBalancing: 'round-robin', // round-robin, random, least-used
+    syncEvents: true
+});
+
+// Devices hinzufügen
+await deviceManager.addDevice('bot1');
+await deviceManager.addDevice('bot2');
+await deviceManager.addDevice('bot3');
+
+// Einzelnes Device verbinden
+await deviceManager.connectDevice('bot1');
+
+// Alle Devices verbinden (sequenziell)
+await deviceManager.connectAll();
+
+// Device abrufen
+const client = deviceManager.getDevice('bot1');
+
+// Nächstes Device (Load Balancing)
+const nextClient = deviceManager.getNextDevice();
+
+// Smart Send (mit Load Balancing)
+await deviceManager.smartSend(chatId, { text: 'Hello!' }, {
+    strategy: 'load-balance' // load-balance, broadcast, failover
+});
+
+// Broadcast an alle Devices
+const results = await deviceManager.broadcast.sendMessage(chatId, {
+    text: 'Broadcast Message!'
+});
+
+// Send mit Failover
+await deviceManager.sendWithFailover(chatId, { text: 'Important!' });
+
+// Device Status
+const status = deviceManager.getStatus();
+console.log(`Active: ${status.activeDevices}/${status.totalDevices}`);
+
+// Health Check
+const health = deviceManager.getHealthCheck();
+console.log(`Health: ${health.healthPercentage}%`);
+
+// Events
+deviceManager.on('message', (data) => {
+    console.log(`Message from ${data.deviceId}`);
+});
+
+deviceManager.on('device.connected', ({ deviceId }) => {
+    console.log(`Device ${deviceId} connected`);
+});
+
+// Cleanup
+await deviceManager.cleanup();
+```
+
+**Device Manager Features:**
+- ✅ **Multi-Device Support** - Bis zu 3 Devices gleichzeitig
+- ✅ **Load Balancing** - Round-Robin, Random, Least-Used
+- ✅ **Smart Routing** - Intelligentes Message-Routing
+- ✅ **Broadcast System** - An alle Devices senden
+- ✅ **Failover** - Automatisches Failover bei Fehlern
+- ✅ **Event Sync** - Events von allen Devices
+- ✅ **Health Monitoring** - Device-Gesundheit überwachen
+- ✅ **Sequential Connect** - QR-Codes nacheinander
+- ✅ **Statistics** - Detaillierte Device-Statistiken
+
+**Load Balancing Strategien:**
+- **round-robin**: Gleichmäßige Verteilung
+- **random**: Zufällige Auswahl
+- **least-used**: Am wenigsten genutztes Device
+
+---s
 - 🤖 **EasyBot Integration** - Alle Features in EasyBot verfügbar
 
 ### **🎵 Advanced Media Features**

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 WhatsApp Multi Client
+Copyright © 2026 WAengine
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waengine",
-  "version": "1.8.3",
+  "version": "1.9.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",
@@ -12,6 +12,13 @@
     "example:easy": "node examples/easy-bot-examples.js vollständig"
   },
   "keywords": [
+    "best-libary",
+    "Library",
+    "whatsapp-bot-libary",
+    "Whatsapp-libary",
+    "npm",
+    "npm-install-waengine",
+    "api",
     "mention",
     "waengine",
     "hidetag",

package/src/client.js

@@ -937,13 +937,6 @@ export class WhatsAppClient {
                     if (messageTimestamp < this.connectionStartTime) {
                         this.ignoredMessagesCount++;
                         
-                        // Nur alle 10 Messages oder bei der ersten Message loggen
-                        if (this.ignoredMessagesCount === 1) {
-                            console.log(`📵 Offline Messages werden ignoriert...`);
-                        } else if (this.ignoredMessagesCount % 10 === 0) {
-                            console.log(`📵 ${this.ignoredMessagesCount} Offline Messages ignoriert...`);
-                        }
-                        
                         // Timer für finale Zusammenfassung zurücksetzen
                         if (this.offlineMessageTimer) {
                             clearTimeout(this.offlineMessageTimer);
@@ -1317,6 +1310,87 @@ export class WhatsAppClient {
 
         return results;
     }
+
+    // ===== CONTACT INFO API =====
+    
+    /**
+     * Holt erweiterte Kontakt-Informationen
+     * @param {string} jid - Die JID des Kontakts
+     * @returns {Promise<object>} Kontakt-Informationen
+     */
+    async getContactInfo(jid) {
+        try {
+            // Normalisiere JID
+            let normalizedJid = jid;
+            if (!jid.includes('@')) {
+                normalizedJid = `${jid}@s.whatsapp.net`;
+            }
+
+            // Basis-Info: Prüfe ob Nummer auf WhatsApp ist
+            const onWhatsAppCheck = await this.socket.onWhatsApp(normalizedJid);
+            
+            if (!onWhatsAppCheck || onWhatsAppCheck.length === 0) {
+                return { 
+                    exists: false, 
+                    jid: normalizedJid,
+                    number: jid.split('@')[0]
+                };
+            }
+
+            const baseInfo = onWhatsAppCheck[0];
+            
+            // Erweiterte Kontakt-Informationen sammeln
+            const contactInfo = {
+                exists: baseInfo.exists,
+                jid: baseInfo.jid,
+                number: baseInfo.jid.split('@')[0],
+                isBusiness: baseInfo.isBusiness || false,
+                name: null,
+                notify: null,
+                verifiedName: null,
+                status: null,
+                profilePicture: null
+            };
+
+            try {
+                // Versuche Profilbild abzurufen
+                const profilePicUrl = await this.socket.profilePictureUrl(normalizedJid, 'image');
+                contactInfo.profilePicture = profilePicUrl;
+            } catch (error) {
+                // Kein Profilbild verfügbar
+                contactInfo.profilePicture = null;
+            }
+
+            try {
+                // Versuche Status abzurufen
+                const status = await this.socket.fetchStatus(normalizedJid);
+                contactInfo.status = status?.status || null;
+                contactInfo.statusTimestamp = status?.setAt || null;
+            } catch (error) {
+                // Status nicht verfügbar
+            }
+
+            // Versuche Name aus dem Store zu holen (wenn verfügbar)
+            try {
+                if (this.socket.store && this.socket.store.contacts) {
+                    const storeContact = this.socket.store.contacts[normalizedJid];
+                    if (storeContact) {
+                        contactInfo.name = storeContact.name || storeContact.notify || null;
+                        contactInfo.notify = storeContact.notify || null;
+                        contactInfo.verifiedName = storeContact.verifiedName || null;
+                    }
+                }
+            } catch (error) {
+                // Store nicht verfügbar
+            }
+
+            return contactInfo;
+
+        } catch (error) {
+            console.error('❌ Fehler beim Abrufen der Kontakt-Info:', error);
+            return null;
+        }
+    }
 }
 
 // ===== DEINE API-KLASSEN =====

package/src/console-logger.js

@@ -13,7 +13,7 @@ export class ConsoleLogger {
         
         console.log(`
 ╔══════════════════════════════════════════════════════════════╗
-║                    🚀 WAEngine v1.8.3                       ║
+║                    🚀 WAEngine v1.8.9                      ║
 ║              Advanced WhatsApp Bot Framework                 ║
 ╚══════════════════════════════════════════════════════════════╝`);
     }

package/src/message.js

@@ -587,6 +587,55 @@ export class Message {
         });
     }
 
+    // ===== DELETE MESSAGE - Auto-Delete System =====
+    async deleteMessage() {
+        try {
+            // Lösche die aktuelle Message
+            // Erstelle den richtigen Key basierend auf dem Sender
+            const sender = this.getSender();
+            const botJid = this.client.socket.user?.id;
+            const botNumber = botJid?.split('@')[0]?.split(':')[0];
+            const senderNumber = sender?.split('@')[0]?.split(':')[0];
+            const isFromBot = botNumber === senderNumber;
+            
+            const messageKey = {
+                remoteJid: this.from,
+                id: this.id,
+                fromMe: isFromBot
+            };
+            
+            // In Gruppen: participant hinzufügen wenn nicht vom Bot
+            if (this.isGroup && !isFromBot) {
+                messageKey.participant = sender;
+            }
+            
+            console.log('🗑️ Lösche Message:', {
+                id: this.id,
+                from: sender,
+                isFromBot: isFromBot,
+                isGroup: this.isGroup
+            });
+            
+            const result = await this.client.socket.sendMessage(this.from, {
+                delete: messageKey
+            });
+            
+            return { 
+                success: true, 
+                messageId: this.id,
+                sender: sender,
+                wasFromBot: isFromBot,
+                result: result 
+            };
+        } catch (error) {
+            console.error('❌ Fehler beim Löschen der Message:', error.message);
+            return { 
+                success: false, 
+                error: error.message 
+            };
+        }
+    }
+
     async deleteFromReply() {
         // Prüfe ob die Message eine Reply ist
         const contextInfo = this.raw.message?.extendedTextMessage?.contextInfo;
@@ -1558,16 +1607,72 @@ export class Message {
 
     async getContactInfo(jid) {
         try {
-            // onWhatsApp prüft ob Nummer auf WhatsApp ist
-            const contact = await this.client.socket.onWhatsApp(jid);
-            if (contact && contact.length > 0) {
-                return {
-                    exists: contact[0].exists,
-                    jid: contact[0].jid,
-                    isBusiness: contact[0].isBusiness || false
+            // Normalisiere JID
+            let normalizedJid = jid;
+            if (!jid.includes('@')) {
+                normalizedJid = `${jid}@s.whatsapp.net`;
+            }
+
+            // Basis-Info: Prüfe ob Nummer auf WhatsApp ist
+            const onWhatsAppCheck = await this.client.socket.onWhatsApp(normalizedJid);
+            
+            if (!onWhatsAppCheck || onWhatsAppCheck.length === 0) {
+                return { 
+                    exists: false, 
+                    jid: normalizedJid,
+                    number: jid.split('@')[0]
                 };
             }
-            return { exists: false, jid: jid, isBusiness: false };
+
+            const baseInfo = onWhatsAppCheck[0];
+            
+            // Erweiterte Kontakt-Informationen sammeln
+            const contactInfo = {
+                exists: baseInfo.exists,
+                jid: baseInfo.jid,
+                number: baseInfo.jid.split('@')[0],
+                isBusiness: baseInfo.isBusiness || false,
+                name: null,
+                notify: null,
+                verifiedName: null,
+                status: null,
+                profilePicture: null
+            };
+
+            try {
+                // Versuche Profilbild abzurufen
+                const profilePicUrl = await this.client.socket.profilePictureUrl(normalizedJid, 'image');
+                contactInfo.profilePicture = profilePicUrl;
+            } catch (error) {
+                // Kein Profilbild verfügbar
+                contactInfo.profilePicture = null;
+            }
+
+            try {
+                // Versuche Status abzurufen
+                const status = await this.client.socket.fetchStatus(normalizedJid);
+                contactInfo.status = status?.status || null;
+                contactInfo.statusTimestamp = status?.setAt || null;
+            } catch (error) {
+                // Status nicht verfügbar
+            }
+
+            // Versuche Name aus dem Store zu holen (wenn verfügbar)
+            try {
+                if (this.client.socket.store && this.client.socket.store.contacts) {
+                    const storeContact = this.client.socket.store.contacts[normalizedJid];
+                    if (storeContact) {
+                        contactInfo.name = storeContact.name || storeContact.notify || null;
+                        contactInfo.notify = storeContact.notify || null;
+                        contactInfo.verifiedName = storeContact.verifiedName || null;
+                    }
+                }
+            } catch (error) {
+                // Store nicht verfügbar
+            }
+
+            return contactInfo;
+
         } catch (error) {
             console.error('❌ Fehler beim Abrufen der Kontakt-Info:', error);
             return null;