waengine 2.0.0 → 2.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waengine",
-  "version": "2.0.0",
+  "version": "2.2.5",
   "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

@@ -262,9 +262,35 @@ export class WhatsAppClient {
     // ===== CONNECTION METHODS =====
     
     async connect() {
+        // ===== SESSION MENU - AUTOMATISCH FÜR JEDEN USER! =====
+        const { showSessionMenuIfNeeded } = await import('./console-logger.js');
+        const activeSessions = await showSessionMenuIfNeeded();
+        
+        // Wenn Session Menu aktiv war, beende hier
+        // (User hat entweder Exit gewählt oder Sessions über Menu gestartet)
+        if (activeSessions !== null) {
+            console.log('✅ Session Menu wurde verwendet - connect() übersprungen');
+            return this;
+        }
+        // ===== ENDE SESSION MENU =====
+        
+        // WICHTIG: Nach Session Menu IMMER neuen Socket erstellen
+        // (Session Menu hat eigenen Socket für Auth erstellt und geschlossen)
         if (this.socket && this.isConnected) {
+            console.log('✅ Socket bereits verbunden - verwende bestehende Verbindung');
             return this.socket;
         }
+        
+        // Wenn Socket existiert aber nicht verbunden, schließen und neu erstellen
+        if (this.socket && !this.isConnected) {
+            console.log('🔄 Schließe alten Socket und erstelle neuen...');
+            try {
+                this.socket.end();
+            } catch (e) {
+                // Ignoriere Fehler beim Schließen
+            }
+            this.socket = null;
+        }
 
         // Reset Auth Success Flag für neue Verbindung
         this.hasShownAuthSuccess = false;

package/src/console-logger.js

@@ -274,4 +274,45 @@ export class ConsoleLogger {
 }
 
 // Export für einfache Nutzung
-export const logger = new ConsoleLogger();
+export const logger = new ConsoleLogger();
+
+
+// ===== SESSION MENU INTEGRATION - NEU! =====
+import { SessionMenu } from './session-menu.js';
+
+// Globale Variable um zu tracken ob das Menü bereits gezeigt wurde
+let sessionMenuShown = false;
+
+export async function showSessionMenuIfNeeded() {
+    // Prüfe ob wir vom Session Menu selbst aufgerufen werden
+    if (global.__WAENGINE_SKIP_SESSION_MENU__) {
+        return null;
+    }
+    
+    // WICHTIG: Menu soll IMMER angezeigt werden, auch wenn schon gezeigt
+    // (User kann mehrmals connect() aufrufen)
+    // if (sessionMenuShown) return null;
+    // sessionMenuShown = true;
+    
+    const menu = new SessionMenu();
+    
+    // IMMER das Menü anzeigen - auch wenn Sessions existieren!
+    console.log('\n🎉 Willkommen bei WAEngine!\n');
+    
+    if (menu.sessions.length > 0) {
+        console.log(`📱 ${menu.sessions.length} Session(s) gefunden.\n`);
+        console.log('💡 Wähle eine Session zum Starten oder erstelle eine neue!\n');
+    } else {
+        console.log('📱 Keine Sessions gefunden. Lass uns eine erstellen...\n');
+    }
+    
+    await menu.start();
+    
+    // Nach dem Menü: User hat entweder Exit gewählt oder Sessions gestartet
+    // Gebe die aktiven Sessions zurück (oder leere Map wenn Exit)
+    
+    return menu.getActiveSessions();
+}
+
+// Export für manuelle Nutzung
+export { SessionMenu };

package/src/session-menu.js

@@ -4,6 +4,7 @@ import path from 'path';
 import { makeWASocket, useMultiFileAuthState, fetchLatestBaileysVersion, DisconnectReason } from '@whiskeysockets/baileys';
 import pino from 'pino';
 import qrcode from 'qrcode-terminal';
+import { spawn } from 'child_process';
 
 // ANSI Color Codes (ohne externe Dependencies)
 const c = {
@@ -17,9 +18,10 @@ const c = {
 };
 
 export class SessionMenu {
-    constructor(baseAuthDir = './sessions') {
+    constructor(baseAuthDir = './auth') {  // Geändert von './sessions' zu './auth'
         this.baseAuthDir = baseAuthDir;
-        this.sessionsConfigPath = path.join(baseAuthDir, 'sessions.json');
+        this.sessionsConfigPath = path.join(baseAuthDir, '..', 'sessions.json');  // Eine Ebene höher
+        this.sessionStatusPath = path.join(baseAuthDir, '..', 'session-status.json');  // Status-Tracking
         this.activeSessions = new Map();
         this.rl = null;
         
@@ -28,6 +30,7 @@ export class SessionMenu {
         }
         
         this.loadSessionsConfig();
+        this.loadSessionStatus();
     }
 
     loadSessionsConfig() {
@@ -44,10 +47,184 @@ export class SessionMenu {
         fs.writeFileSync(this.sessionsConfigPath, JSON.stringify(this.sessions, null, 2));
     }
 
+    // Status-Tracking für Sessions in separaten Terminals
+    loadSessionStatus() {
+        if (fs.existsSync(this.sessionStatusPath)) {
+            try {
+                const data = fs.readFileSync(this.sessionStatusPath, 'utf-8');
+                this.sessionStatus = JSON.parse(data);
+            } catch (error) {
+                this.sessionStatus = {};
+            }
+        } else {
+            this.sessionStatus = {};
+        }
+    }
+
+    saveSessionStatus() {
+        fs.writeFileSync(this.sessionStatusPath, JSON.stringify(this.sessionStatus, null, 2));
+    }
+
+    updateSessionStatus(sessionName, status, pid = null) {
+        this.sessionStatus[sessionName] = {
+            status: status, // 'online', 'offline', 'connecting'
+            lastUpdate: Date.now(),
+            pid: pid
+        };
+        this.saveSessionStatus();
+    }
+
+    getSessionStatus(sessionName) {
+        const status = this.sessionStatus[sessionName];
+        if (!status) return 'offline';
+        
+        // Prüfe ob Status älter als 30 Sekunden ist
+        const age = Date.now() - status.lastUpdate;
+        if (age > 30000) {
+            return 'offline'; // Status zu alt, wahrscheinlich offline
+        }
+        
+        return status.status;
+    }
+
     clearScreen() {
         console.clear();
     }
 
+    // Öffne neues Terminal und starte Session darin
+    openSessionInNewTerminal(sessionName) {
+        const session = this.sessions.find(s => s.name === sessionName);
+        if (!session) {
+            console.log(c.red(`❌ Session "${sessionName}" nicht gefunden!`));
+            return false;
+        }
+
+        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`);
+        const statusPath = path.join(process.cwd(), 'session-status.json');
+        
+        const scriptContent = `
+// Auto-generiertes Session-Start-Script für: ${sessionName}
+import { WhatsAppClient } from './index.js';
+import fs from 'fs';
+
+console.log('╔════════════════════════════════════════╗');
+console.log('║   WAEngine Session: ${sessionName.padEnd(20)}║');
+console.log('╚════════════════════════════════════════╝\\n');
+
+// Status-Update Funktion
+function updateStatus(status) {
+    try {
+        let statusData = {};
+        if (fs.existsSync('${statusPath.replace(/\\/g, '/')}')) {
+            const data = fs.readFileSync('${statusPath.replace(/\\/g, '/')}', 'utf-8');
+            statusData = JSON.parse(data);
+        }
+        
+        statusData['${sessionName}'] = {
+            status: status,
+            lastUpdate: Date.now(),
+            pid: process.pid
+        };
+        
+        fs.writeFileSync('${statusPath.replace(/\\/g, '/')}', JSON.stringify(statusData, null, 2));
+    } catch (error) {
+        console.error('Status-Update Fehler:', error.message);
+    }
+}
+
+// Status: Verbindet
+updateStatus('connecting');
+
+// Deaktiviere Session Menu für diese Session
+global.__WAENGINE_SKIP_SESSION_MENU__ = true;
+
+const client = new WhatsAppClient({
+    authDir: '${session.authDir.replace(/\\/g, '/')}',
+    printQR: false,
+    silent: false
+});
+
+console.log('🔄 Starte Session ${sessionName}...\\n');
+
+try {
+    await client.connect();
+    
+    // Status: Online
+    updateStatus('online');
+    
+    console.log('\\n✅ Session ${sessionName} läuft!');
+    console.log('💬 Bot wartet auf Nachrichten...\\n');
+    
+    // Heartbeat: Status alle 10 Sekunden aktualisieren
+    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);
+    updateStatus('offline');
+}
+
+// Verhindere dass das Script beendet wird
+process.on('SIGINT', () => {
+    console.log('\\n👋 Session ${sessionName} wird beendet...');
+    updateStatus('offline');
+    process.exit(0);
+});
+
+process.on('exit', () => {
+    updateStatus('offline');
+});
+`;
+
+        // Schreibe das Script
+        fs.writeFileSync(scriptPath, scriptContent);
+        
+        // Setze Status auf "connecting"
+        this.updateSessionStatus(sessionName, 'connecting');
+        
+        // Öffne neues Terminal (Windows CMD)
+        const command = `start "WAEngine - ${sessionName}" cmd /k "node ${scriptPath}"`;
+        
+        try {
+            spawn(command, [], {
+                shell: true,
+                detached: true,
+                stdio: 'ignore'
+            });
+            
+            console.log(c.green(`✅ Neues Terminal geöffnet für: ${sessionName}`));
+            console.log(c.gray(`   Script: ${scriptPath}`));
+            console.log(c.gray(`   Status wird automatisch aktualisiert...`));
+            
+            return true;
+        } catch (error) {
+            console.log(c.red(`❌ Fehler beim Öffnen des Terminals: ${error.message}`));
+            
+            // Cleanup
+            if (fs.existsSync(scriptPath)) {
+                fs.unlinkSync(scriptPath);
+            }
+            
+            this.updateSessionStatus(sessionName, 'offline');
+            
+            return false;
+        }
+    }
+
     showBanner() {
         console.log(c.cyan('╔════════════════════════════════════════╗'));
         console.log(c.cyan('║     WhatsApp Bot Session Manager      ║'));
@@ -66,13 +243,18 @@ export class SessionMenu {
         console.log(c.white('  5️⃣  Beenden\n'));
         
         if (this.sessions.length > 0) {
+            // Lade aktuellen Status
+            this.loadSessionStatus();
+            
             console.log(c.gray('📊 Verfügbare Sessions:'));
             this.sessions.forEach((session, index) => {
-                const status = this.activeSessions.has(session.name) ? 
-                    c.green('● Online') : c.red('○ Offline');
-                console.log(c.gray(`   ${index + 1}. ${session.name} ${status}`));
+                const status = this.getSessionStatus(session.name);
+                const statusIcon = status === 'online' ? c.green('● Online') : 
+                                  status === 'connecting' ? c.yellow('◐ Verbindet') : 
+                                  c.red('○ Offline');
+                console.log(c.gray(`   ${index + 1}. ${session.name} ${statusIcon}`));
             });
-            console.log('');
+            console.log(c.gray('\n   💡 Status wird automatisch aktualisiert\n'));
         }
     }
 
@@ -142,31 +324,56 @@ export class SessionMenu {
         
         console.log(c.cyan('\n🔄 Verbinde...'));
         
+        let sock = null;
+        
         try {
-            const authDir = path.join(this.baseAuthDir, sessionName);
+            // Erste Session geht in ./auth/, weitere in ./sessions/<name>/
+            const authDir = this.sessions.length === 0 ? './auth' : path.join('./sessions', sessionName);
+            
+            // Stelle sicher dass das Verzeichnis existiert
+            if (!fs.existsSync(authDir)) {
+                fs.mkdirSync(authDir, { recursive: true });
+            }
+            
             const { state, saveCreds } = await useMultiFileAuthState(authDir);
             const { version } = await fetchLatestBaileysVersion();
 
-            const sock = makeWASocket({
+            sock = makeWASocket({
                 version,
                 auth: state,
                 printQRInTerminal: false,
-                logger: pino({ level: 'silent' })
+                logger: pino({ level: 'silent' }),
+                browser: ['WAEngine', 'Chrome', '121.0.0'],
+                syncFullHistory: false,
+                markOnlineOnConnect: false
             });
 
-            if (!sock.authState.creds.registered) {
-                const code = await sock.requestPairingCode(cleanNumber);
-                console.log(c.green(`\n✅ Pairing Code: ${c.bold(code)}\n`));
-                console.log(c.yellow('📲 Gehe zu WhatsApp > Verknüpfte Geräte > Gerät verknüpfen'));
-                console.log(c.yellow('   und gib den Code ein!\n'));
-            }
+            // Pairing Code anfordern
+            const code = await sock.requestPairingCode(cleanNumber);
+            console.log(c.green(`\n✅ Pairing Code: ${c.bold(code)}\n`));
+            console.log(c.yellow('📲 Gehe zu WhatsApp > Verknüpfte Geräte > Gerät verknüpfen'));
+            console.log(c.yellow('   und gib den Code ein!\n'));
+            console.log(c.gray('⏳ Warte auf Bestätigung...\n'));
 
             await new Promise((resolve, reject) => {
+                let connectionTimeout = setTimeout(() => {
+                    console.log(c.red('\n⏰ Timeout - Code nicht eingegeben'));
+                    reject(new Error('Pairing-Timeout'));
+                }, 120000); // 2 Minuten Timeout
+                
+                let isResolved = false;
+                
                 sock.ev.on('connection.update', async (update) => {
                     const { connection, lastDisconnect } = update;
                     
-                    if (connection === 'open') {
+                    if (connection === 'open' && !isResolved) {
+                        isResolved = true;
+                        clearTimeout(connectionTimeout);
                         console.log(c.green('✅ Erfolgreich verbunden!'));
+                        console.log(c.gray('💾 Speichere Session...'));
+                        
+                        // Warte kurz damit alle Credentials gespeichert werden
+                        await new Promise(r => setTimeout(r, 3000));
                         
                         this.sessions.push({
                             name: sessionName,
@@ -177,25 +384,63 @@ export class SessionMenu {
                         });
                         this.saveSessionsConfig();
                         
-                        await sock.end();
+                        // Socket schließen
+                        try {
+                            sock.end();
+                        } catch (e) {
+                            // Ignoriere Fehler beim Schließen
+                        }
+                        
                         resolve();
                     }
                     
-                    if (connection === 'close') {
-                        const shouldReconnect = lastDisconnect?.error?.output?.statusCode !== DisconnectReason.loggedOut;
-                        if (!shouldReconnect) {
-                            reject(new Error('Verbindung fehlgeschlagen'));
+                    if (connection === 'close' && !isResolved) {
+                        const statusCode = lastDisconnect?.error?.output?.statusCode;
+                        const reason = lastDisconnect?.error?.message || 'Unbekannt';
+                        
+                        // 401 ist NORMAL bei Pairing - NICHT als Fehler behandeln!
+                        // Das passiert wenn Code noch nicht eingegeben wurde
+                        if (statusCode === 401) {
+                            // Ignoriere 401 - warte weiter auf Code-Eingabe
+                            console.log(c.gray('⏳ Warte auf Code-Eingabe...'));
+                            return;
                         }
+                        
+                        // Nur bei anderen Fehlern
+                        isResolved = true;
+                        clearTimeout(connectionTimeout);
+                        
+                        console.log(c.red(`\n❌ Verbindung geschlossen`));
+                        console.log(c.gray(`   Code: ${statusCode}`));
+                        console.log(c.gray(`   Grund: ${reason}`));
+                        
+                        reject(new Error(`Verbindung fehlgeschlagen (${statusCode})`));
                     }
                 });
 
-                sock.ev.on('creds.update', saveCreds);
+                sock.ev.on('creds.update', async () => {
+                    try {
+                        await saveCreds();
+                        console.log(c.gray('💾 Credentials aktualisiert...'));
+                    } catch (error) {
+                        console.log(c.red(`❌ Fehler beim Speichern: ${error.message}`));
+                    }
+                });
             });
 
             console.log(c.green('\n✅ Session erfolgreich erstellt!'));
             
         } catch (error) {
             console.log(c.red(`\n❌ Fehler: ${error.message}`));
+            
+            // Socket aufräumen falls noch offen
+            if (sock) {
+                try {
+                    sock.end();
+                } catch (e) {
+                    // Ignoriere Fehler
+                }
+            }
         }
         
         await this.waitForEnter();
@@ -203,66 +448,65 @@ export class SessionMenu {
 
     async createSessionWithQR(sessionName) {
         console.log(c.yellow('\n📱 QR Code Login\n'));
-        console.log(c.cyan('🔄 Generiere QR Code...\n'));
+        console.log(c.cyan('🔄 Starte QR-Code Authentifizierung...\n'));
         
         try {
-            const authDir = path.join(this.baseAuthDir, sessionName);
-            const { state, saveCreds } = await useMultiFileAuthState(authDir);
-            const { version } = await fetchLatestBaileysVersion();
-
-            const sock = makeWASocket({
-                version,
-                auth: state,
-                printQRInTerminal: false,
-                logger: pino({ level: 'silent' })
+            // Erste Session geht in ./auth/, weitere in ./sessions/<name>/
+            const authDir = this.sessions.length === 0 ? './auth' : path.join('./sessions', sessionName);
+            
+            // Stelle sicher dass das Verzeichnis existiert
+            if (!fs.existsSync(authDir)) {
+                fs.mkdirSync(authDir, { recursive: true });
+            }
+            
+            console.log(c.gray(`📁 Session-Verzeichnis: ${authDir}\n`));
+            console.log(c.yellow('📲 QR Code wird gleich angezeigt - bitte bereit halten!\n'));
+            console.log(c.gray('⏳ Starte WhatsApp Client...\n'));
+            
+            // Importiere den normalen Client
+            const { WhatsAppClient } = await import('./client.js');
+            
+            // WICHTIG: Deaktiviere das Session Menu im Client!
+            // Setze eine globale Variable damit der Client das Menu nicht nochmal zeigt
+            global.__WAENGINE_SKIP_SESSION_MENU__ = true;
+            
+            // Erstelle temporären Client NUR für QR-Authentifizierung
+            const tempClient = new WhatsAppClient({
+                authDir: authDir,
+                printQR: true,
+                logLevel: 'silent',
+                silent: true // Keine Banner/Logs
             });
-
-            let qrShown = false;
-
-            sock.ev.on('connection.update', async (update) => {
-                const { connection, lastDisconnect, qr } = update;
-                
-                if (qr && !qrShown) {
-                    console.log(c.yellow('📲 Scanne den QR Code mit WhatsApp:\n'));
-                    qrcode.generate(qr, { small: true });
-                    qrShown = true;
-                }
-                
-                if (connection === 'open') {
-                    console.log(c.green('\n✅ Erfolgreich verbunden!'));
-                    
-                    this.sessions.push({
-                        name: sessionName,
-                        authDir: authDir,
-                        method: 'qr',
-                        createdAt: new Date().toISOString()
-                    });
-                    this.saveSessionsConfig();
-                    
-                    await sock.end();
-                }
-                
-                if (connection === 'close') {
-                    const shouldReconnect = lastDisconnect?.error?.output?.statusCode !== DisconnectReason.loggedOut;
-                    if (!shouldReconnect) {
-                        console.log(c.red('\n❌ Verbindung fehlgeschlagen'));
-                    }
-                }
+            
+            // Verbinde und warte auf Authentifizierung
+            console.log(c.cyan('🔗 Verbinde mit WhatsApp...\n'));
+            
+            await tempClient.connect();
+            
+            // Wenn wir hier ankommen, war die Verbindung erfolgreich!
+            console.log(c.green('\n✅ Erfolgreich authentifiziert!'));
+            
+            // Trenne sofort
+            await tempClient.disconnect();
+            
+            // Reset globale Variable
+            global.__WAENGINE_SKIP_SESSION_MENU__ = false;
+            
+            // Speichere Session-Info
+            this.sessions.push({
+                name: sessionName,
+                authDir: authDir,
+                method: 'qr',
+                createdAt: new Date().toISOString()
             });
-
-            sock.ev.on('creds.update', saveCreds);
-
-            await new Promise(resolve => setTimeout(resolve, 60000));
+            this.saveSessionsConfig();
             
-            if (sock.user) {
-                console.log(c.green('\n✅ Session erfolgreich erstellt!'));
-            } else {
-                console.log(c.red('\n❌ Timeout - QR Code nicht gescannt'));
-                await sock.end();
-            }
+            console.log(c.green('✅ Session erfolgreich erstellt!'));
             
         } catch (error) {
             console.log(c.red(`\n❌ Fehler: ${error.message}`));
+            // Reset globale Variable auch bei Fehler
+            global.__WAENGINE_SKIP_SESSION_MENU__ = false;
         }
         
         await this.waitForEnter();
@@ -279,11 +523,17 @@ export class SessionMenu {
             return;
         }
 
+        let successCount = 0;
         for (const session of this.sessions) {
-            await this.startSession(session.name);
+            if (this.openSessionInNewTerminal(session.name)) {
+                successCount++;
+                // Kurze Pause zwischen Sessions
+                await new Promise(resolve => setTimeout(resolve, 500));
+            }
         }
 
-        console.log(c.green(`\n✅ ${this.activeSessions.size} Session(s) gestartet!`));
+        console.log(c.green(`\n✅ ${successCount} Session(s) in neuen Terminals gestartet!`));
+        console.log(c.gray('💡 Jede Session läuft in ihrem eigenen Terminal-Fenster\n'));
         await this.waitForEnter();
     }
 
@@ -300,9 +550,7 @@ export class SessionMenu {
 
         console.log(c.white('Verfügbare Sessions:\n'));
         this.sessions.forEach((session, index) => {
-            const status = this.activeSessions.has(session.name) ? 
-                c.green('● Online') : c.red('○ Offline');
-            console.log(c.white(`  ${index + 1}. ${session.name} ${status}`));
+            console.log(c.white(`  ${index + 1}. ${session.name}`));
         });
         console.log('');
 
@@ -311,9 +559,12 @@ export class SessionMenu {
 
         if (index >= 0 && index < this.sessions.length) {
             const session = this.sessions[index];
-            console.log(c.cyan(`\n🔄 Starte ${session.name}...`));
-            await this.startSession(session.name);
-            console.log(c.green(`✅ ${session.name} gestartet!`));
+            console.log(c.cyan(`\n🔄 Starte ${session.name} in neuem Terminal...`));
+            
+            if (this.openSessionInNewTerminal(session.name)) {
+                console.log(c.green(`\n✅ ${session.name} wurde in neuem Terminal gestartet!`));
+                console.log(c.gray('💡 Schau in das neue Terminal-Fenster für Logs\n'));
+            }
         } else {
             console.log(c.red('\n❌ Ungültige Auswahl!'));
         }
@@ -440,6 +691,10 @@ export class SessionMenu {
                     break;
                 case '5':
                     running = false;
+                    this.rl.close();
+                    this.clearScreen();
+                    console.log(c.cyan('👋 Auf Wiedersehen!\n'));
+                    process.exit(0); // Beende das Programm komplett
                     break;
                 default:
                     console.log(c.red('\n❌ Ungültige Auswahl!'));