waengine 1.9.9 → 2.0.0

package/bin/waengine.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+// WAEngine CLI - Startet automatisch das Session-Menu
+import { SessionMenu } from '../src/session-menu.js';
+
+const menu = new SessionMenu();
+await menu.start();

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "waengine",
-  "version": "1.9.9",
+  "version": "2.0.0",
   "description": "🚀 WAEngine - The most powerful WhatsApp Bot Library with 860+ Working Features, Complete Baileys Integration & Production-Ready Stability",
   "main": "src/index.js",
   "type": "module",
+  "bin": {
+    "waengine": "./bin/waengine.js",
+    "waengine-menu": "./bin/waengine.js"
+  },
   "scripts": {
-    "start": "node examples/simple-multi-device.js",
+    "start": "node start.js",
+    "menu": "node start.js",
     "test": "node test.js",
     "example:basic": "node examples/easy-bot-examples.js einfach",
     "example:multi": "node examples/multi-device-example.js",
@@ -65,6 +70,7 @@
   "dependencies": {
     "@whiskeysockets/baileys": "^7.0.0-rc.9",
     "axios": "^1.13.4",
+    "chalk": "^5.3.0",
     "node-cron": "^3.0.3",
     "pino": "^8.0.0",
     "qrcode": "^1.5.4",

package/src/auto-session-menu.js

@@ -0,0 +1,77 @@
+// Auto-Session-Menu - Wird automatisch beim Import der Library gestartet
+import { SessionMenu } from './session-menu.js';
+import fs from 'fs';
+import path from 'path';
+
+// Globale Variable um zu tracken ob das Menü bereits gezeigt wurde
+let menuShown = false;
+let autoMenuEnabled = true;
+
+// Prüfe ob User das Auto-Menu deaktiviert hat
+const configPath = './.waengine-config.json';
+if (fs.existsSync(configPath)) {
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        if (config.disableAutoSessionMenu === true) {
+            autoMenuEnabled = false;
+        }
+    } catch (e) {
+        // Ignore config errors
+    }
+}
+
+// Zeige das Session-Menu automatisch beim ersten Import
+export async function showAutoSessionMenu() {
+    if (menuShown || !autoMenuEnabled) {
+        return null;
+    }
+    
+    menuShown = true;
+    
+    const menu = new SessionMenu();
+    
+    // Wenn keine Sessions existieren, zeige das Menü
+    if (menu.sessions.length === 0) {
+        console.log('\n🎉 Willkommen bei WAEngine!\n');
+        console.log('Es wurden noch keine Sessions gefunden.');
+        console.log('Lass uns eine erstellen...\n');
+        
+        await menu.start();
+        return menu.getActiveSessions();
+    }
+    
+    // Wenn Sessions existieren, frage ob sie gestartet werden sollen
+    console.log('\n📱 WAEngine Session Manager\n');
+    console.log(`Gefundene Sessions: ${menu.sessions.length}\n`);
+    
+    const readline = require('readline').createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    
+    const answer = await new Promise(resolve => {
+        readline.question('Möchtest du das Session-Menü öffnen? (j/n): ', resolve);
+    });
+    
+    readline.close();
+    
+    if (answer.toLowerCase() === 'j' || answer.toLowerCase() === 'y') {
+        await menu.start();
+        return menu.getActiveSessions();
+    }
+    
+    return null;
+}
+
+// Funktion um das Auto-Menu zu deaktivieren
+export function disableAutoSessionMenu() {
+    const config = {
+        disableAutoSessionMenu: true
+    };
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    console.log('✅ Auto-Session-Menu deaktiviert');
+    console.log('   Zum Reaktivieren: Lösche .waengine-config.json');
+}
+
+// Export für manuelle Nutzung
+export { SessionMenu };

package/src/index.js

@@ -49,3 +49,7 @@ export { GamingManager } from "./gaming-manager.js";
 export { DatabaseManager } from "./database-manager.js";
 export { ABTestingManager } from "./ab-testing.js";
 export { ReportingManager } from "./reporting-manager.js";
+
+// ===== SESSION MANAGEMENT SYSTEM - NEU! =====
+export { SessionMenu } from "./session-menu.js";
+export { SessionLauncher, launchSessionMenu, quickStart } from "./session-launcher.js";

package/src/init.js

@@ -0,0 +1,22 @@
+// Auto-Init für WAEngine - Startet Session-Menu automatisch
+import { SessionMenu } from './session-menu.js';
+
+// Diese Funktion wird automatisch beim Import ausgeführt
+let initialized = false;
+
+export async function initWAEngine() {
+    if (initialized) return;
+    initialized = true;
+    
+    const menu = new SessionMenu();
+    
+    // Starte das Menü automatisch
+    await menu.start();
+    
+    return menu.getActiveSessions();
+}
+
+// Automatischer Start beim Import (nur wenn als Hauptmodul geladen)
+if (import.meta.url === `file:///${process.argv[1].replace(/\\/g, '/')}`) {
+    initWAEngine();
+}

package/src/session-launcher.js

@@ -0,0 +1,96 @@
+import { SessionMenu } from './session-menu.js';
+import { WhatsAppClient } from './client.js';
+
+/**
+ * Automatischer Session-Launcher für die Library
+ * Wird automatisch beim Import aufgerufen
+ */
+export class SessionLauncher {
+    constructor(options = {}) {
+        this.autoStart = options.autoStart !== false; // Standard: true
+        this.baseAuthDir = options.baseAuthDir || './sessions';
+        this.sessionMenu = new SessionMenu(this.baseAuthDir);
+        this.clients = new Map();
+    }
+
+    /**
+     * Startet das interaktive Session-Menü
+     */
+    async startInteractive() {
+        await this.sessionMenu.start();
+        return this.sessionMenu.getActiveSessions();
+    }
+
+    /**
+     * Startet eine spezifische Session ohne Menü
+     */
+    async startSession(sessionName) {
+        const sock = await this.sessionMenu.startSession(sessionName);
+        if (sock) {
+            // Erstelle WhatsAppClient-Wrapper
+            const client = new WhatsAppClient({
+                authDir: this.sessionMenu.sessions.find(s => s.name === sessionName)?.authDir,
+                socket: sock
+            });
+            this.clients.set(sessionName, client);
+            return client;
+        }
+        return null;
+    }
+
+    /**
+     * Startet alle Sessions ohne Menü
+     */
+    async startAllSessions() {
+        const sessions = this.sessionMenu.sessions;
+        const clients = [];
+
+        for (const session of sessions) {
+            const client = await this.startSession(session.name);
+            if (client) {
+                clients.push(client);
+            }
+        }
+
+        return clients;
+    }
+
+    /**
+     * Gibt alle aktiven Clients zurück
+     */
+    getClients() {
+        return Array.from(this.clients.values());
+    }
+
+    /**
+     * Gibt einen spezifischen Client zurück
+     */
+    getClient(sessionName) {
+        return this.clients.get(sessionName);
+    }
+}
+
+/**
+ * Einfache Funktion zum Starten des Session-Menüs
+ */
+export async function launchSessionMenu(options = {}) {
+    const launcher = new SessionLauncher(options);
+    return await launcher.startInteractive();
+}
+
+/**
+ * Schnellstart-Funktion für Single-Session
+ */
+export async function quickStart(sessionName = 'default', options = {}) {
+    const launcher = new SessionLauncher(options);
+    
+    // Prüfe ob Session existiert
+    const existingSession = launcher.sessionMenu.sessions.find(s => s.name === sessionName);
+    
+    if (!existingSession) {
+        console.log(`⚠️  Session "${sessionName}" nicht gefunden. Starte interaktives Menü...`);
+        return await launcher.startInteractive();
+    }
+    
+    return await launcher.startSession(sessionName);
+}

package/src/session-menu.js

@@ -0,0 +1,462 @@
+import readline from 'readline';
+import fs from 'fs';
+import path from 'path';
+import { makeWASocket, useMultiFileAuthState, fetchLatestBaileysVersion, DisconnectReason } from '@whiskeysockets/baileys';
+import pino from 'pino';
+import qrcode from 'qrcode-terminal';
+
+// ANSI Color Codes (ohne externe Dependencies)
+const c = {
+    cyan: (text) => `\x1b[36m${text}\x1b[0m`,
+    yellow: (text) => `\x1b[33m${text}\x1b[0m`,
+    green: (text) => `\x1b[32m${text}\x1b[0m`,
+    red: (text) => `\x1b[31m${text}\x1b[0m`,
+    white: (text) => `\x1b[37m${text}\x1b[0m`,
+    gray: (text) => `\x1b[90m${text}\x1b[0m`,
+    bold: (text) => `\x1b[1m${text}\x1b[0m`
+};
+
+export class SessionMenu {
+    constructor(baseAuthDir = './sessions') {
+        this.baseAuthDir = baseAuthDir;
+        this.sessionsConfigPath = path.join(baseAuthDir, 'sessions.json');
+        this.activeSessions = new Map();
+        this.rl = null;
+        
+        if (!fs.existsSync(baseAuthDir)) {
+            fs.mkdirSync(baseAuthDir, { recursive: true });
+        }
+        
+        this.loadSessionsConfig();
+    }
+
+    loadSessionsConfig() {
+        if (fs.existsSync(this.sessionsConfigPath)) {
+            const data = fs.readFileSync(this.sessionsConfigPath, 'utf-8');
+            this.sessions = JSON.parse(data);
+        } else {
+            this.sessions = [];
+            this.saveSessionsConfig();
+        }
+    }
+
+    saveSessionsConfig() {
+        fs.writeFileSync(this.sessionsConfigPath, JSON.stringify(this.sessions, null, 2));
+    }
+
+    clearScreen() {
+        console.clear();
+    }
+
+    showBanner() {
+        console.log(c.cyan('╔════════════════════════════════════════╗'));
+        console.log(c.cyan('║     WhatsApp Bot Session Manager      ║'));
+        console.log(c.cyan('╚════════════════════════════════════════╝\n'));
+    }
+
+    showMainMenu() {
+        this.clearScreen();
+        this.showBanner();
+        
+        console.log(c.yellow('📋 Hauptmenü:\n'));
+        console.log(c.white('  1️⃣  Neue Session erstellen'));
+        console.log(c.white('  2️⃣  Alle Sessions starten'));
+        console.log(c.white('  3️⃣  Einzelne Session starten'));
+        console.log(c.white('  4️⃣  Sessions verwalten'));
+        console.log(c.white('  5️⃣  Beenden\n'));
+        
+        if (this.sessions.length > 0) {
+            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}`));
+            });
+            console.log('');
+        }
+    }
+
+    createReadline() {
+        if (this.rl) {
+            this.rl.close();
+        }
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+    }
+
+    question(query) {
+        return new Promise(resolve => {
+            this.rl.question(query, resolve);
+        });
+    }
+
+    async showCreateSessionMenu() {
+        this.clearScreen();
+        this.showBanner();
+        console.log(c.yellow('🆕 Neue Session erstellen\n'));
+        
+        const sessionName = await this.question(c.white('📝 Session-Name eingeben: '));
+        
+        if (!sessionName || sessionName.trim() === '') {
+            console.log(c.red('\n❌ Ungültiger Name!'));
+            await this.waitForEnter();
+            return;
+        }
+
+        if (this.sessions.find(s => s.name === sessionName)) {
+            console.log(c.red('\n❌ Session existiert bereits!'));
+            await this.waitForEnter();
+            return;
+        }
+
+        console.log(c.yellow('\n🔐 Login-Methode wählen:\n'));
+        console.log(c.white('  1️⃣  Pairing Code (Telefonnummer)'));
+        console.log(c.white('  2️⃣  QR Code scannen\n'));
+        
+        const method = await this.question(c.white('Auswahl (1 oder 2): '));
+        
+        if (method === '1') {
+            await this.createSessionWithPairing(sessionName);
+        } else if (method === '2') {
+            await this.createSessionWithQR(sessionName);
+        } else {
+            console.log(c.red('\n❌ Ungültige Auswahl!'));
+            await this.waitForEnter();
+        }
+    }
+
+    async createSessionWithPairing(sessionName) {
+        console.log(c.yellow('\n📱 Pairing Code Login\n'));
+        
+        const phoneNumber = await this.question(c.white('Telefonnummer (mit Vorwahl, z.B. +491234567890): '));
+        
+        if (!phoneNumber.startsWith('+')) {
+            console.log(c.red('\n❌ Nummer muss mit + beginnen!'));
+            await this.waitForEnter();
+            return;
+        }
+
+        const cleanNumber = phoneNumber.replace(/[^0-9]/g, '');
+        
+        console.log(c.cyan('\n🔄 Verbinde...'));
+        
+        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' })
+            });
+
+            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'));
+            }
+
+            await new Promise((resolve, reject) => {
+                sock.ev.on('connection.update', async (update) => {
+                    const { connection, lastDisconnect } = update;
+                    
+                    if (connection === 'open') {
+                        console.log(c.green('✅ Erfolgreich verbunden!'));
+                        
+                        this.sessions.push({
+                            name: sessionName,
+                            authDir: authDir,
+                            method: 'pairing',
+                            phoneNumber: phoneNumber,
+                            createdAt: new Date().toISOString()
+                        });
+                        this.saveSessionsConfig();
+                        
+                        await sock.end();
+                        resolve();
+                    }
+                    
+                    if (connection === 'close') {
+                        const shouldReconnect = lastDisconnect?.error?.output?.statusCode !== DisconnectReason.loggedOut;
+                        if (!shouldReconnect) {
+                            reject(new Error('Verbindung fehlgeschlagen'));
+                        }
+                    }
+                });
+
+                sock.ev.on('creds.update', saveCreds);
+            });
+
+            console.log(c.green('\n✅ Session erfolgreich erstellt!'));
+            
+        } catch (error) {
+            console.log(c.red(`\n❌ Fehler: ${error.message}`));
+        }
+        
+        await this.waitForEnter();
+    }
+
+    async createSessionWithQR(sessionName) {
+        console.log(c.yellow('\n📱 QR Code Login\n'));
+        console.log(c.cyan('🔄 Generiere QR Code...\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' })
+            });
+
+            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'));
+                    }
+                }
+            });
+
+            sock.ev.on('creds.update', saveCreds);
+
+            await new Promise(resolve => setTimeout(resolve, 60000));
+            
+            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();
+            }
+            
+        } catch (error) {
+            console.log(c.red(`\n❌ Fehler: ${error.message}`));
+        }
+        
+        await this.waitForEnter();
+    }
+
+    async startAllSessions() {
+        this.clearScreen();
+        this.showBanner();
+        console.log(c.yellow('🚀 Starte alle Sessions...\n'));
+        
+        if (this.sessions.length === 0) {
+            console.log(c.red('❌ Keine Sessions vorhanden!'));
+            await this.waitForEnter();
+            return;
+        }
+
+        for (const session of this.sessions) {
+            await this.startSession(session.name);
+        }
+
+        console.log(c.green(`\n✅ ${this.activeSessions.size} Session(s) gestartet!`));
+        await this.waitForEnter();
+    }
+
+    async startSingleSession() {
+        this.clearScreen();
+        this.showBanner();
+        console.log(c.yellow('🎯 Einzelne Session starten\n'));
+        
+        if (this.sessions.length === 0) {
+            console.log(c.red('❌ Keine Sessions vorhanden!'));
+            await this.waitForEnter();
+            return;
+        }
+
+        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('');
+
+        const choice = await this.question(c.white('Session-Nummer: '));
+        const index = parseInt(choice) - 1;
+
+        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!`));
+        } else {
+            console.log(c.red('\n❌ Ungültige Auswahl!'));
+        }
+
+        await this.waitForEnter();
+    }
+
+    async startSession(sessionName) {
+        const session = this.sessions.find(s => s.name === sessionName);
+        if (!session) {
+            console.log(c.red(`❌ Session "${sessionName}" nicht gefunden!`));
+            return null;
+        }
+
+        if (this.activeSessions.has(sessionName)) {
+            console.log(c.yellow(`⚠️  ${sessionName} läuft bereits!`));
+            return this.activeSessions.get(sessionName);
+        }
+
+        try {
+            const { state, saveCreds } = await useMultiFileAuthState(session.authDir);
+            const { version } = await fetchLatestBaileysVersion();
+
+            const sock = makeWASocket({
+                version,
+                auth: state,
+                printQRInTerminal: false,
+                logger: pino({ level: 'silent' })
+            });
+
+            sock.ev.on('creds.update', saveCreds);
+            
+            sock.ev.on('connection.update', (update) => {
+                const { connection } = update;
+                if (connection === 'open') {
+                    console.log(c.green(`✅ ${sessionName} verbunden`));
+                }
+                if (connection === 'close') {
+                    this.activeSessions.delete(sessionName);
+                    console.log(c.red(`❌ ${sessionName} getrennt`));
+                }
+            });
+
+            this.activeSessions.set(sessionName, sock);
+            return sock;
+            
+        } catch (error) {
+            console.log(c.red(`❌ Fehler beim Starten von ${sessionName}: ${error.message}`));
+            return null;
+        }
+    }
+
+    async manageSessionsMenu() {
+        this.clearScreen();
+        this.showBanner();
+        console.log(c.yellow('⚙️  Sessions verwalten\n'));
+        
+        if (this.sessions.length === 0) {
+            console.log(c.red('❌ Keine Sessions vorhanden!'));
+            await this.waitForEnter();
+            return;
+        }
+
+        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(`  ${this.sessions.length + 1}. Zurück\n`));
+
+        const choice = await this.question(c.white('Session zum Löschen auswählen: '));
+        const index = parseInt(choice) - 1;
+
+        if (index >= 0 && index < this.sessions.length) {
+            const session = this.sessions[index];
+            const confirm = await this.question(c.red(`⚠️  ${session.name} wirklich löschen? (j/n): `));
+            
+            if (confirm.toLowerCase() === 'j') {
+                if (this.activeSessions.has(session.name)) {
+                    const sock = this.activeSessions.get(session.name);
+                    await sock.end();
+                    this.activeSessions.delete(session.name);
+                }
+                
+                if (fs.existsSync(session.authDir)) {
+                    fs.rmSync(session.authDir, { recursive: true, force: true });
+                }
+                
+                this.sessions.splice(index, 1);
+                this.saveSessionsConfig();
+                
+                console.log(c.green(`\n✅ ${session.name} gelöscht!`));
+            }
+        }
+
+        await this.waitForEnter();
+    }
+
+    async waitForEnter() {
+        await this.question(c.gray('\nDrücke Enter um fortzufahren...'));
+    }
+
+    async start() {
+        this.createReadline();
+        
+        let running = true;
+        while (running) {
+            this.showMainMenu();
+            const choice = await this.question(c.white('Auswahl: '));
+            
+            switch (choice) {
+                case '1':
+                    await this.showCreateSessionMenu();
+                    break;
+                case '2':
+                    await this.startAllSessions();
+                    break;
+                case '3':
+                    await this.startSingleSession();
+                    break;
+                case '4':
+                    await this.manageSessionsMenu();
+                    break;
+                case '5':
+                    running = false;
+                    break;
+                default:
+                    console.log(c.red('\n❌ Ungültige Auswahl!'));
+                    await this.waitForEnter();
+            }
+        }
+        
+        this.rl.close();
+        this.clearScreen();
+        console.log(c.cyan('👋 Auf Wiedersehen!\n'));
+    }
+
+    getActiveSessions() {
+        return this.activeSessions;
+    }
+
+    getSession(sessionName) {
+        return this.activeSessions.get(sessionName);
+    }
+}