waengine 1.9.8 → 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.8",
+  "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/device-detector.js

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

package/src/index.js

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