waengine 2.3.2 → 2.3.8-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waengine",
-  "version": "2.3.2",
+  "version": "2.3.8-rc.1",
   "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

@@ -138,12 +138,19 @@ export class WhatsAppClient {
         this.ui = new UIComponents(this);
         
         // Offline Message Ignore System - NEU!
-        this.ignoreOfflineMessages = false;
+        // Automatisch aktivieren wenn Environment-Variable gesetzt ist
+        this.ignoreOfflineMessages = process.env.WAENGINE_IGNORE_OFFLINE_MESSAGES === 'true' || false;
         this.lastOnlineTimestamp = Date.now();
         this.connectionStartTime = null;
         this.ignoredMessagesCount = 0; // Counter für ignorierte Messages
         this.offlineMessageTimer = null; // Timer für finale Zusammenfassung
         
+        // Log wenn automatisch aktiviert
+        if (this.ignoreOfflineMessages) {
+            console.log('\n📵 Offline Message Ignore: AUTOMATISCH AKTIVIERT');
+            console.log('   └─ Grund: Session über Session Menu gestartet\n');
+        }
+        
         // ===== GLOBAL VISUAL TYPING/RECORDING SYSTEM - NEU! =====
         this.globalVisualTyping = false; // Global aktiviert/deaktiviert
         this.globalVisualRecord = false; // Global aktiviert/deaktiviert
@@ -372,8 +379,9 @@ export class WhatsAppClient {
                 syncFullHistory: true, // Wichtig für Message-Empfang
                 markOnlineOnConnect: true,
                 getMessage: async (key) => {
-                    // Wichtig für Message-Handling
-                    return { conversation: "Message not found" };
+                    // WICHTIG: undefined zurückgeben statt "Message not found"
+                    // Sonst wird es als echte Nachricht behandelt und spammt!
+                    return undefined;
                 },
                 shouldIgnoreJid: jid => isJidBroadcast(jid),
                 // Bessere Message-Synchronisation
@@ -392,8 +400,9 @@ export class WhatsAppClient {
                 syncFullHistory: true, // Wichtig für Message-Empfang
                 markOnlineOnConnect: true,
                 getMessage: async (key) => {
-                    // Wichtig für Message-Handling
-                    return { conversation: "Message not found" };
+                    // WICHTIG: undefined zurückgeben statt "Message not found"
+                    // Sonst wird es als echte Nachricht behandelt und spammt!
+                    return undefined;
                 },
                 shouldIgnoreJid: jid => isJidBroadcast(jid),
                 // Bessere Message-Synchronisation
@@ -561,7 +570,9 @@ export class WhatsAppClient {
                     // Connection Start Time für Offline Message Ignore setzen
                     this.connectionStartTime = Date.now();
                     if (this.ignoreOfflineMessages) {
-                        this.logger.info(`Offline Messages werden ignoriert (seit ${new Date(this.connectionStartTime).toLocaleString()})`);
+                        console.log(`\n📵 Offline Message Ignore: AKTIV`);
+                        console.log(`   ├─ Verbunden seit: ${new Date(this.connectionStartTime).toLocaleString()}`);
+                        console.log(`   └─ Alle Messages vor diesem Zeitpunkt werden ignoriert\n`);
                     }
                     
                     await closeBrowser(); // QR Browser schließen
@@ -968,17 +979,31 @@ export class WhatsAppClient {
             // DEBUG: Zeige alle Message-Types
             console.log(`📥 Message Event - Type: ${type}, Count: ${messages.length}`);
             
-            // WICHTIG: Alle Types akzeptieren außer explizit ausgeschlossene
-            // Nur "prepend" (alte History) ignorieren wenn gewünscht
-            // if (type === "prepend") return; // Optional: Alte Messages ignorieren
+            // WICHTIG: Alte History-Messages ignorieren (prepend)
+            if (type === "prepend") {
+                console.log(`⏭️ Ignoriere ${messages.length} History Messages (prepend)`);
+                return;
+            }
 
             messages.forEach((msg) => {
+                // KRITISCHE VALIDIERUNG: Prüfe ob Message-Key existiert
+                if (!msg.key || !msg.key.remoteJid || !msg.key.id) {
+                    console.log(`⚠️ Ungültige Message ohne Key - ignoriert`);
+                    return;
+                }
+                
                 // Bessere Message-Validierung
                 if (!msg.message || msg.key.fromMe) return;
                 
                 // OFFLINE MESSAGE IGNORE - DEINE NEUE FUNKTION!
                 if (this.ignoreOfflineMessages && this.connectionStartTime) {
-                    const messageTimestamp = msg.messageTimestamp * 1000; // Convert to milliseconds
+                    // messageTimestamp kann in Sekunden oder Millisekunden sein
+                    let messageTimestamp = msg.messageTimestamp;
+                    
+                    // Wenn Timestamp in Sekunden (< Jahr 2000 in Millisekunden), konvertiere zu Millisekunden
+                    if (messageTimestamp < 946684800000) {
+                        messageTimestamp = messageTimestamp * 1000;
+                    }
                     
                     // Ignoriere Messages die vor der Verbindung gesendet wurden
                     if (messageTimestamp < this.connectionStartTime) {
@@ -997,7 +1022,7 @@ export class WhatsAppClient {
                             }
                         }, 3000);
                         
-                        return;
+                        return; // WICHTIG: Beende hier - verarbeite Message NICHT weiter!
                     }
                 }
                 

package/src/console-logger.js

@@ -285,7 +285,8 @@ let sessionMenuShown = false;
 
 export async function showSessionMenuIfNeeded() {
     // Prüfe ob wir vom Session Menu selbst aufgerufen werden
-    if (global.__WAENGINE_SKIP_SESSION_MENU__) {
+    // WICHTIG: Prüfe sowohl global als auch Environment-Variable!
+    if (global.__WAENGINE_SKIP_SESSION_MENU__ || process.env.__WAENGINE_SKIP_SESSION_MENU__ === 'true') {
         return null;
     }
     

package/src/message.js

@@ -727,6 +727,100 @@ export class Message {
         }
     }
 
+    // ===== MESSAGE DEL - Lösche beliebige Message (Admin erforderlich in Gruppen) =====
+    async MessageDel(messageId, participantJid = null) {
+        try {
+            // Wenn keine Parameter, lösche die aktuelle Message
+            if (!messageId) {
+                return await this.deleteMessage();
+            }
+            
+            // Prüfe in Gruppen ob Bot Admin ist
+            if (this.isGroup) {
+                const isBotAdmin = await this.isGroupAdmin(this.client.socket.user.id);
+                if (!isBotAdmin) {
+                    console.log('⚠️ Bot ist kein Admin - kann nur eigene Messages löschen');
+                    return {
+                        success: false,
+                        reason: 'not_admin',
+                        error: 'Bot muss Admin sein um Messages von anderen zu löschen'
+                    };
+                }
+            }
+            
+            // Bot JID ermitteln
+            const botJid = this.client.socket.user?.id;
+            const botNumber = botJid?.split('@')[0]?.split(':')[0];
+            
+            // Prüfe ob Message vom Bot ist
+            let isFromBot = false;
+            if (participantJid) {
+                const participantNumber = participantJid?.split('@')[0]?.split(':')[0];
+                isFromBot = botNumber === participantNumber;
+            }
+            
+            // Erstelle Message Key
+            const messageKey = {
+                remoteJid: this.from,
+                id: messageId,
+                fromMe: isFromBot
+            };
+            
+            // In Gruppen: participant hinzufügen wenn nicht vom Bot
+            if (this.isGroup && participantJid && !isFromBot) {
+                messageKey.participant = participantJid;
+            }
+            
+            console.log('🗑️ MessageDel - Lösche Message:', {
+                messageId: messageId,
+                participant: participantJid,
+                isFromBot: isFromBot,
+                isGroup: this.isGroup,
+                key: messageKey
+            });
+            
+            // Sende Delete Request
+            const result = await this.client.socket.sendMessage(this.from, {
+                delete: messageKey
+            });
+            
+            console.log('✅ MessageDel erfolgreich:', result);
+            return {
+                success: true,
+                messageId: messageId,
+                participant: participantJid,
+                wasFromBot: isFromBot,
+                result: result
+            };
+            
+        } catch (error) {
+            console.error('❌ MessageDel Fehler:', error.message);
+            
+            // Spezifische Fehlerbehandlung
+            if (error.message?.includes('not-found') || error.message?.includes('404')) {
+                return {
+                    success: false,
+                    reason: 'message_not_found',
+                    error: 'Message nicht gefunden oder zu alt'
+                };
+            }
+            
+            if (error.message?.includes('forbidden') || error.message?.includes('403')) {
+                return {
+                    success: false,
+                    reason: 'no_permission',
+                    error: 'Keine Berechtigung - Bot muss Admin sein'
+                };
+            }
+            
+            return {
+                success: false,
+                reason: 'unknown_error',
+                error: error.message
+            };
+        }
+    }
+
     // ===== MEDIA DOWNLOAD - NEU in v1.7.9! =====
     
     async downloadMedia(options = {}) {

package/src/session-menu.js

@@ -18,13 +18,16 @@ const c = {
 };
 
 export class SessionMenu {
-    constructor(baseAuthDir = './auth') {  // Geändert von './sessions' zu './auth'
+    constructor(baseAuthDir = './auth') {
         this.baseAuthDir = baseAuthDir;
-        this.sessionsConfigPath = path.join(baseAuthDir, '..', 'sessions.json');  // Eine Ebene höher
-        this.sessionStatusPath = path.join(baseAuthDir, '..', 'session-status.json');  // Status-Tracking
+        this.sessionsConfigPath = path.join(baseAuthDir, '..', 'sessions.json');
+        this.sessionStatusPath = path.join(baseAuthDir, '..', 'session-status.json');
         this.activeSessions = new Map();
         this.rl = null;
         
+        // Erkenne das Start-Script aus process.argv
+        this.userStartCommand = this.detectStartCommand();
+        
         if (!fs.existsSync(baseAuthDir)) {
             fs.mkdirSync(baseAuthDir, { recursive: true });
         }
@@ -32,6 +35,22 @@ export class SessionMenu {
         this.loadSessionsConfig();
         this.loadSessionStatus();
     }
+    
+    // Erkenne wie der User seinen Bot gestartet hat
+    detectStartCommand() {
+        // process.argv[0] = node
+        // process.argv[1] = script.js
+        const scriptPath = process.argv[1];
+        
+        if (scriptPath) {
+            const scriptName = path.basename(scriptPath);
+            console.log(c.green(`✅ Start-Command erkannt: node ${scriptName}`));
+            return scriptName;
+        }
+        
+        // Fallback
+        return 'index.js';
+    }
 
     loadSessionsConfig() {
         if (fs.existsSync(this.sessionsConfigPath)) {
@@ -101,20 +120,17 @@ export class SessionMenu {
 
         console.log(c.cyan(`\n🚀 Öffne neues Terminal für Session: ${sessionName}...`));
         
-        // Erstelle ein temporäres Start-Script für diese Session
-        const scriptPath = path.join(process.cwd(), `.session-${sessionName}.js`);
+        // Setze Status auf "connecting"
+        this.updateSessionStatus(sessionName, 'connecting');
+        
+        // Erstelle Wrapper-Script für Status-Tracking
+        const wrapperPath = path.join(process.cwd(), `.session-${sessionName}-wrapper.js`);
         const statusPath = path.join(process.cwd(), 'session-status.json');
         
-        const scriptContent = `
-// Auto-generiertes Session-Start-Script für: ${sessionName}
-import { WhatsAppClient } from 'waengine';
+        const wrapperContent = `// Session Wrapper für: ${sessionName}
 import fs from 'fs';
+import { spawn } from 'child_process';
 
-console.log('╔════════════════════════════════════════╗');
-console.log('║   WAEngine Session: ${sessionName.padEnd(20)}║');
-console.log('╚════════════════════════════════════════╝\\n');
-
-// Status-Update Funktion
 function updateStatus(status) {
     try {
         let statusData = {};
@@ -131,73 +147,57 @@ function updateStatus(status) {
         
         fs.writeFileSync('${statusPath.replace(/\\/g, '/')}', JSON.stringify(statusData, null, 2));
     } catch (error) {
-        console.error('Status-Update Fehler:', error.message);
+        console.error('❌ Status-Update Fehler:', error.message);
     }
 }
 
-// Status: Verbindet
-updateStatus('connecting');
+console.log('╔════════════════════════════════════════╗');
+console.log('║   WAEngine Session: ${sessionName.padEnd(20)}║');
+console.log('╚════════════════════════════════════════╝\\n');
 
-// Deaktiviere Session Menu für diese Session
-global.__WAENGINE_SKIP_SESSION_MENU__ = true;
+updateStatus('connecting');
 
-const client = new WhatsAppClient({
-    authDir: '${session.authDir.replace(/\\/g, '/')}',
-    printQR: false,
-    silent: false
+// Starte User's Bot-Script mit Environment-Variablen
+const botProcess = spawn('node', ['${this.userStartCommand}'], {
+    env: {
+        ...process.env,
+        WAENGINE_AUTH_DIR: '${session.authDir.replace(/\\/g, '/')}',
+        WAENGINE_SESSION_NAME: '${sessionName}',
+        __WAENGINE_SKIP_SESSION_MENU__: 'true',
+        WAENGINE_IGNORE_OFFLINE_MESSAGES: 'true'  // Ignoriere Offline-Nachrichten automatisch
+    },
+    stdio: 'inherit'
 });
 
-console.log('🔄 Starte Session ${sessionName}...\\n');
-
-try {
-    await client.connect();
-    
-    // Status: Online
+// Warte kurz und setze Status auf online
+setTimeout(() => {
     updateStatus('online');
     
-    console.log('\\n✅ Session ${sessionName} läuft!');
-    console.log('💬 Bot wartet auf Nachrichten...\\n');
-    
-    // Heartbeat: Status alle 10 Sekunden aktualisieren
+    // Heartbeat alle 10 Sekunden
     setInterval(() => {
         updateStatus('online');
     }, 10000);
-    
-    // Beispiel: Message Handler
-    client.on('message', async (msg) => {
-        console.log(\`📨 Nachricht von \${msg.from}: \${msg.body}\`);
-        
-        // Hier kann der User seinen Bot-Code einfügen
-        if (msg.body === '!ping') {
-            await msg.reply('🏓 Pong!');
-        }
-    });
-    
-} catch (error) {
-    console.error('❌ Fehler beim Starten:', error.message);
+}, 3000);
+
+botProcess.on('exit', (code) => {
+    console.log(\`\\n👋 Bot beendet (Code: \${code})\`);
     updateStatus('offline');
-}
+    process.exit(code);
+});
 
-// Verhindere dass das Script beendet wird
 process.on('SIGINT', () => {
     console.log('\\n👋 Session ${sessionName} wird beendet...');
     updateStatus('offline');
+    botProcess.kill();
     process.exit(0);
 });
-
-process.on('exit', () => {
-    updateStatus('offline');
-});
 `;
 
-        // Schreibe das Script
-        fs.writeFileSync(scriptPath, scriptContent);
-        
-        // Setze Status auf "connecting"
-        this.updateSessionStatus(sessionName, 'connecting');
+        // Schreibe Wrapper-Script
+        fs.writeFileSync(wrapperPath, wrapperContent);
         
-        // Öffne neues Terminal (Windows CMD)
-        const command = `start "WAEngine - ${sessionName}" cmd /k "node ${scriptPath}"`;
+        // Öffne neues Terminal mit Wrapper-Script
+        const command = `start "WAEngine - ${sessionName}" cmd /k "node ${wrapperPath}"`;
         
         try {
             spawn(command, [], {
@@ -207,7 +207,8 @@ process.on('exit', () => {
             });
             
             console.log(c.green(`✅ Neues Terminal geöffnet für: ${sessionName}`));
-            console.log(c.gray(`   Script: ${scriptPath}`));
+            console.log(c.gray(`   Command: node ${this.userStartCommand}`));
+            console.log(c.gray(`   Auth: ${session.authDir}`));
             console.log(c.gray(`   Status wird automatisch aktualisiert...`));
             
             return true;
@@ -215,8 +216,8 @@ process.on('exit', () => {
             console.log(c.red(`❌ Fehler beim Öffnen des Terminals: ${error.message}`));
             
             // Cleanup
-            if (fs.existsSync(scriptPath)) {
-                fs.unlinkSync(scriptPath);
+            if (fs.existsSync(wrapperPath)) {
+                fs.unlinkSync(wrapperPath);
             }
             
             this.updateSessionStatus(sessionName, 'offline');