waengine 1.0.1

package/examples/easy-bot-examples.js

@@ -0,0 +1,186 @@
+import { EasyBot, createBot, quickBot, multiBot } from "../src/index.js";
+
+// ===== BEISPIEL 1: SUPER EINFACH =====
+
+async function superEinfach() {
+    console.log("🚀 Super einfacher Bot");
+    
+    const bot = quickBot()
+        .when("hallo").reply("Hi! 👋")
+        .when("ping").reply("Pong! 🏓")
+        .command("zeit", () => new Date().toLocaleString())
+        .start();
+}
+
+// ===== BEISPIEL 2: MIT CHAINING =====
+
+async function mitChaining() {
+    console.log("🔗 Bot mit Action Chaining");
+    
+    const bot = createBot()
+        .when("wichtig").react("⚠️").type(2).reply("Das ist wichtig!")
+        .when("lustig").react("😂").reply("Haha, das ist witzig!")
+        .start();
+}
+
+// ===== BEISPIEL 3: MULTI-DEVICE =====
+
+async function multiDevice() {
+    console.log("🔧 Multi-Device Bot");
+    
+    const bot = multiBot(2)
+        .when("test").reply("Multi-Device Test!")
+        .command("status", "📊 Multi-Device läuft!")
+        .start();
+}
+
+// ===== BEISPIEL 4: ERWEITERTE TEMPLATES =====
+
+async function erweiterteTempates() {
+    console.log("📝 Bot mit erweiterten Templates");
+    
+    const bot = createBot()
+        .template("begrüßung", "Hallo {name}! Heute ist {day}, {time}")
+        .template("info", "Chat: {chat} | Sender: {sender} | Datum: {date}")
+        .when("info").useTemplate("info")
+        .when("hallo").useTemplate("begrüßung")
+        .start();
+}
+
+// ===== BEISPIEL 5: ACTION CHAINING =====
+
+async function actionChaining() {
+    console.log("🔗 Perfektes Action Chaining");
+    
+    const bot = createBot()
+        .when("wichtig")
+            .react("⚠️")
+            .type(2)
+            .reply("Das ist eine wichtige Nachricht!")
+            .react("✅")
+            .done() // Zurück zum Bot
+        .when("party")
+            .react("🎉")
+            .type(1)
+            .reply("Party Zeit!")
+            .react("🥳")
+            .done()
+        .start();
+}
+
+// ===== BEISPIEL 6: CONDITIONAL LOGIC =====
+
+async function conditionalLogic() {
+    console.log("🤔 Bot mit Conditional Logic");
+    
+    const bot = createBot()
+        .if("contains hallo").then("reply Hallo zurück!")
+        .if("starts with !").then("reply Das ist ein Command!")
+        .if("is group").then("reply Hallo Gruppe!")
+        .if("is private").then("reply Hallo im Privat-Chat!")
+        .if("has media").then("react 📷")
+        .start();
+}
+
+// ===== BEISPIEL 7: VOLLSTÄNDIGER BOT =====
+
+async function vollständigerBot() {
+    console.log("🤖 Vollständiger EasyBot");
+    
+    const bot = createBot()
+        // Templates
+        .template("willkommen", "Willkommen {name}! Heute ist {day}")
+        .template("status", "Bot läuft seit {time} | Chat: {chat}")
+        
+        // Auto Responses
+        .autoReply("hallo", "Hi! 👋")
+        .autoReply("tschüss", "Bye! 👋")
+        
+        // Rules mit Chaining
+        .when("wichtig")
+            .react("⚠️")
+            .type(2)
+            .reply("Wichtige Nachricht erkannt!")
+            .done()
+            
+        .when("willkommen")
+            .useTemplate("willkommen")
+            .react("🎉")
+            .done()
+        
+        // Commands
+        .command("hilfe", "🤖 Verfügbare Commands:\n!hilfe, !ping, !status, !zeit")
+        .command("ping", "Pong! 🏓")
+        .command("status", () => {
+            const status = bot.status();
+            return `📊 Bot Status: ${status.running ? 'Läuft' : 'Gestoppt'}`;
+        })
+        
+        // Conditional Logic
+        .if("is group").then("react 👥")
+        .if("contains bot").then("reply Ja, ich bin ein Bot! 🤖")
+        
+        // Settings
+        .enableTyping(true)
+        .enableReactions(true)
+        .addQuickCommands()
+        
+        .start();
+}
+
+// ===== BEISPIEL 8: MULTI-DEVICE ADVANCED =====
+
+async function multiDeviceAdvanced() {
+    console.log("🔧 Advanced Multi-Device Bot");
+    
+    const bot = multiBot(3)
+        .when("test")
+            .react("🧪")
+            .type(1)
+            .reply("Multi-Device Test erfolgreich!")
+            .done()
+            
+        .command("devices", () => {
+            const status = bot.status();
+            return `🔧 ${status.activeDevices}/${status.totalDevices} Devices aktiv`;
+        })
+        
+        .template("multi", "Nachricht von Device via Load Balancing! Zeit: {time}")
+        .when("multi").useTemplate("multi")
+        
+        .start();
+}
+
+// Beispiele ausführen
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const example = process.argv[2] || 'vollständig';
+    
+    switch (example) {
+        case 'einfach':
+            superEinfach();
+            break;
+        case 'chaining':
+            mitChaining();
+            break;
+        case 'multi':
+            multiDevice();
+            break;
+        case 'templates':
+            erweiterteTempates();
+            break;
+        case 'actions':
+            actionChaining();
+            break;
+        case 'conditional':
+            conditionalLogic();
+            break;
+        case 'vollständig':
+            vollständigerBot();
+            break;
+        case 'multi-advanced':
+            multiDeviceAdvanced();
+            break;
+        default:
+            console.log("Verfügbare Beispiele: einfach, chaining, multi, templates, actions, conditional, vollständig, multi-advanced");
+    }
+}

package/examples/multi-device-example.js

@@ -0,0 +1,253 @@
+import { MultiWhatsAppClient } from "../src/index.js";
+
+// ===== MULTI-DEVICE BOT EXAMPLE =====
+
+async function startMultiDeviceBot() {
+    console.log("🚀 Starte Multi-Device WhatsApp Bot...");
+    
+    // Multi-Client mit 3 Devices initialisieren
+    const multiClient = new MultiWhatsAppClient({
+        maxDevices: 3,
+        loadBalancing: 'round-robin', // round-robin, random, least-used, failover
+        syncEvents: true
+    });
+
+    // ===== DEVICES HINZUFÜGEN =====
+    
+    try {
+        // Device 1: Haupt-Bot
+        await multiClient.addDevice('main-bot', {
+            browser: ['MainBot', '1.0.0', ''],
+            logLevel: 'silent'
+        });
+
+        // Device 2: Backup-Bot  
+        await multiClient.addDevice('backup-bot', {
+            browser: ['BackupBot', '1.0.0', ''],
+            logLevel: 'silent'
+        });
+
+        // Device 3: Support-Bot
+        await multiClient.addDevice('support-bot', {
+            browser: ['SupportBot', '1.0.0', ''],
+            logLevel: 'silent'
+        });
+
+        console.log("✅ Alle 3 Devices hinzugefügt");
+
+    } catch (error) {
+        console.error("❌ Fehler beim Hinzufügen der Devices:", error.message);
+        return;
+    }
+
+    // ===== COMMAND SYSTEM =====
+    
+    const prefix = "!";
+    multiClient.setPrefix(prefix);
+
+    // Commands für alle Devices
+    multiClient.addCommand('ping', async (msg) => {
+        const deviceInfo = msg.deviceId ? ` (Device: ${msg.deviceId})` : '';
+        await msg.replyFromSameDevice(`🏓 Pong!${deviceInfo}`);
+    });
+
+    multiClient.addCommand('status', async (msg) => {
+        const status = multiClient.getStatus();
+        const health = multiClient.getHealthCheck();
+        
+        let response = `📊 **Multi-Device Status**\n\n`;
+        response += `🔧 Devices: ${status.activeDevices}/${status.totalDevices} aktiv\n`;
+        response += `💚 Health: ${health.healthPercentage}% (${health.recommendation})\n`;
+        response += `⚖️ Load Balancing: ${status.loadBalancing}\n\n`;
+        
+        response += `**Device Details:**\n`;
+        status.devices.forEach(device => {
+            const statusIcon = device.status === 'connected' ? '✅' : 
+                              device.status === 'connecting' ? '🔄' : '❌';
+            response += `${statusIcon} ${device.id}: ${device.messageCount} msgs, ${device.errors} errors\n`;
+        });
+        
+        await msg.replyFromSameDevice(response);
+    });
+
+    multiClient.addCommand('broadcast', async (msg, args) => {
+        if (args.length === 0) {
+            return msg.replyFromSameDevice('❌ Verwendung: !broadcast <nachricht>');
+        }
+        
+        const message = args.join(' ');
+        const results = await multiClient.broadcast(msg.from, { text: `📢 Broadcast: ${message}` });
+        
+        const successful = results.filter(r => r.success).length;
+        await msg.replyFromSameDevice(`✅ Broadcast an ${successful}/${results.length} Devices gesendet`);
+    });
+
+    multiClient.addCommand('device', async (msg, args) => {
+        if (args.length < 2) {
+            return msg.replyFromSameDevice('❌ Verwendung: !device <deviceId> <nachricht>');
+        }
+        
+        const [deviceId, ...messageParts] = args;
+        const message = messageParts.join(' ');
+        
+        try {
+            await multiClient.sendFromDevice(deviceId, msg.from, { text: `📱 Von ${deviceId}: ${message}` });
+            await msg.replyFromSameDevice(`✅ Nachricht von Device '${deviceId}' gesendet`);
+        } catch (error) {
+            await msg.replyFromSameDevice(`❌ Fehler: ${error.message}`);
+        }
+    });
+
+    multiClient.addCommand('failover', async (msg, args) => {
+        if (args.length === 0) {
+            return msg.replyFromSameDevice('❌ Verwendung: !failover <nachricht>');
+        }
+        
+        const message = args.join(' ');
+        
+        try {
+            await multiClient.sendWithFailover(msg.from, { text: `🔄 Failover: ${message}` });
+            await msg.replyFromSameDevice('✅ Failover-Nachricht gesendet');
+        } catch (error) {
+            await msg.replyFromSameDevice(`❌ Alle Devices fehlgeschlagen: ${error.message}`);
+        }
+    });
+
+    // ===== EVENT HANDLERS =====
+    
+    // Message Events von allen Devices
+    multiClient.on('message', async (msg) => {
+        // Ignore Commands (werden separat behandelt)
+        if (msg.isCommand) return;
+        
+        // Einfache Auto-Responses
+        if (msg.text?.toLowerCase().includes('hallo')) {
+            // Load-balanced Response
+            await multiClient.sendMessage(msg.from, { 
+                text: `Hallo! 👋 (Beantwortet von Device: ${msg.deviceId})` 
+            });
+        }
+        
+        if (msg.text?.toLowerCase().includes('hilfe')) {
+            const helpText = `🤖 **Multi-Device Bot Hilfe**\n\n` +
+                           `${prefix}ping - Ping Test\n` +
+                           `${prefix}status - Device Status\n` +
+                           `${prefix}broadcast <msg> - An alle Devices\n` +
+                           `${prefix}device <id> <msg> - Spezifisches Device\n` +
+                           `${prefix}failover <msg> - Mit Failover\n\n` +
+                           `Aktive Devices: ${multiClient.getActiveDevices().join(', ')}`;
+            
+            await msg.replyFromSameDevice(helpText);
+        }
+    });
+
+    // Device Connection Events
+    multiClient.on('device.connected', (data) => {
+        console.log(`✅ Device '${data.deviceId}' verbunden`);
+    });
+
+    multiClient.on('device.disconnected', (data) => {
+        console.log(`🔴 Device '${data.deviceId}' getrennt:`, data.reason || 'Unbekannt');
+    });
+
+    multiClient.on('device.error', (data) => {
+        console.error(`❌ Device '${data.deviceId}' Fehler:`, data.error.message);
+    });
+
+    // ===== VERBINDUNG STARTEN =====
+    
+    try {
+        console.log("🔄 Verbinde alle Devices...");
+        const connectedCount = await multiClient.connect();
+        
+        console.log(`🎉 Multi-Device Bot gestartet!`);
+        console.log(`✅ ${connectedCount} Devices erfolgreich verbunden`);
+        console.log(`🎯 Prefix: "${prefix}"`);
+        console.log(`⚖️ Load Balancing: ${multiClient.deviceManager.config.loadBalancing}`);
+        
+        // Status alle 5 Minuten loggen
+        setInterval(() => {
+            const health = multiClient.getHealthCheck();
+            console.log(`💚 Health Check: ${health.healthPercentage}% - ${health.recommendation}`);
+        }, 5 * 60 * 1000);
+        
+        // Device Rotation alle 10 Minuten (optional)
+        setInterval(() => {
+            multiClient.rotateDevices();
+        }, 10 * 60 * 1000);
+        
+    } catch (error) {
+        console.error("❌ Fehler beim Starten des Multi-Device Bots:", error.message);
+        process.exit(1);
+    }
+
+    // ===== GRACEFUL SHUTDOWN =====
+    
+    process.on('SIGINT', async () => {
+        console.log("\n🛑 Shutdown Signal empfangen...");
+        await multiClient.cleanup();
+        console.log("✅ Multi-Device Bot sauber beendet");
+        process.exit(0);
+    });
+}
+
+// ===== ADVANCED USAGE EXAMPLES =====
+
+async function advancedExamples() {
+    const multiClient = new MultiWhatsAppClient();
+    
+    // Beispiel 1: Device-spezifische Konfiguration
+    await multiClient.addDevice('premium-bot', {
+        browser: ['PremiumBot', '2.0.0', ''],
+        logLevel: 'info'
+    });
+    
+    await multiClient.configureDevice('premium-bot', {
+        maxRetries: 5,
+        timeout: 30000
+    });
+
+    // Beispiel 2: Load Balancing Strategy wechseln
+    multiClient.setLoadBalancingStrategy('least-used');
+
+    // Beispiel 3: Conditional Messaging
+    multiClient.on('message', async (msg) => {
+        if (msg.isGroup && msg.text?.includes('wichtig')) {
+            // Wichtige Nachrichten über alle Devices broadcasten
+            await multiClient.broadcast(msg.from, { 
+                text: '🚨 Wichtige Nachricht erkannt - alle Devices alarmiert!' 
+            });
+        } else {
+            // Normale Nachrichten load-balanced
+            await multiClient.sendMessage(msg.from, { 
+                text: 'Normale Antwort via Load Balancing' 
+            });
+        }
+    });
+
+    // Beispiel 4: Device Health Monitoring
+    setInterval(async () => {
+        const health = multiClient.getHealthCheck();
+        
+        if (health.healthPercentage < 50) {
+            console.warn('🚨 Kritische Device-Health! Versuche Reconnect...');
+            
+            // Versuche fehlerhafte Devices zu reconnecten
+            const status = multiClient.getStatus();
+            for (const device of status.devices) {
+                if (device.status !== 'connected') {
+                    try {
+                        await multiClient.deviceManager.connectDevice(device.id);
+                    } catch (error) {
+                        console.error(`❌ Reconnect fehlgeschlagen für ${device.id}:`, error.message);
+                    }
+                }
+            }
+        }
+    }, 2 * 60 * 1000); // Alle 2 Minuten prüfen
+}
+
+// Bot starten
+if (import.meta.url === `file://${process.argv[1]}`) {
+    startMultiDeviceBot().catch(console.error);
+}

package/examples/quick-start.js

@@ -0,0 +1,10 @@
+import { quickBot } from "../src/index.js";
+
+// 🚀 QUICKEST WAY TO START - 3 LINES!
+
+quickBot()
+    .when("hello").reply("Hi there! 👋")
+    .when("ping").reply("Pong! 🏓")
+    .start();
+
+console.log("✅ QuickBot started! Send 'hello' or 'ping' to test!");

package/examples/simple-multi-device.js

@@ -0,0 +1,42 @@
+import { MultiWhatsAppClient } from "../src/index.js";
+
+// ===== EINFACHES MULTI-DEVICE BEISPIEL =====
+
+async function simpleMultiDevice() {
+    console.log("🚀 Einfacher Multi-Device Bot");
+    
+    // Multi-Client erstellen
+    const client = new MultiWhatsAppClient({
+        maxDevices: 2,
+        loadBalancing: 'round-robin'
+    });
+
+    // 2 Devices hinzufügen
+    await client.addDevice('bot1');
+    await client.addDevice('bot2');
+
+    // Commands
+    client.setPrefix('!');
+    
+    client.addCommand('ping', async (msg) => {
+        await msg.replyFromSameDevice(`Pong von ${msg.deviceId}! 🏓`);
+    });
+
+    client.addCommand('test', async (msg) => {
+        // Nachricht über Load Balancing senden
+        await client.sendMessage(msg.from, { text: 'Test via Load Balancing!' });
+    });
+
+    // Events
+    client.on('message', async (msg) => {
+        if (msg.text === 'hallo') {
+            await client.sendMessage(msg.from, { text: `Hallo von ${msg.deviceId}! 👋` });
+        }
+    });
+
+    // Verbinden
+    await client.connect();
+    console.log("✅ Multi-Device Bot läuft!");
+}
+
+simpleMultiDevice().catch(console.error);

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "waengine",
+  "version": "1.0.1",
+  "description": "🚀 WAEngine - The most powerful WhatsApp Bot Library with Multi-Device Support & EasyBot API",
+  "main": "src/index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node examples/simple-multi-device.js",
+    "test": "node test.js",
+    "example:basic": "node examples/easy-bot-examples.js einfach",
+    "example:multi": "node examples/multi-device-example.js",
+    "example:easy": "node examples/easy-bot-examples.js vollständig"
+  },
+  "keywords": [
+    "whatsapp",
+    "bot",
+    "baileys",
+    "multi-device",
+    "automation",
+    "whatsapp-bot",
+    "whatsapp-api",
+    "easy-bot",
+    "chatbot",
+    "messaging",
+    "multi-account",
+    "load-balancing",
+    "typescript",
+    "javascript",
+    "nodejs"
+  ],
+  "author": {
+    "name": "Lia",
+    "email": "Liaia@outlook.de",
+    "url": "https://github.com/neotreydel-lab"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/neotreydel-lab/whatsapp-multi-client.git"
+  },
+  "bugs": {
+    "url": "https://github.com/neotreydel-lab/whatsapp-multi-client/issues"
+  },
+  "homepage": "https://github.com/neotreydel-lab/whatsapp-multi-client#readme",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "dependencies": {
+    "@whiskeysockets/baileys": "^7.0.0-rc.9",
+    "playwright": "^1.58.1",
+    "qrcode-terminal": "^0.12.0",
+    "pino": "^8.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0"
+  },
+  "files": [
+    "src/",
+    "examples/",
+    "README.md",
+    "LICENSE"
+  ],
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/neotreydel-lab"
+  }
+}