waengine 1.0.8 → 1.0.9

package/plugins/music-plugin/index.js

@@ -0,0 +1,221 @@
+// 🎵 Music Plugin mit yt-dlp
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+export default class MusicPlugin {
+    constructor(client) {
+        this.client = client;
+        this.name = 'music-plugin';
+        this.version = '1.0.0';
+        this.description = 'Music System mit YouTube Download und Spotify Integration';
+    }
+
+    async searchYouTube(query) {
+        try {
+            const { stdout } = await execAsync(`yt-dlp --dump-json "ytsearch5:${query}"`);
+            const results = stdout.trim().split('\n').map(line => JSON.parse(line));
+            
+            return results.map(video => ({
+                id: video.id,
+                title: video.title,
+                duration: video.duration,
+                uploader: video.uploader,
+                url: video.webpage_url,
+                thumbnail: video.thumbnail
+            }));
+        } catch (error) {
+            console.error('YouTube Search Error:', error);
+            return [];
+        }
+    }
+
+    async getVideoInfo(url) {
+        try {
+            const { stdout } = await execAsync(`yt-dlp --dump-json "${url}"`);
+            const info = JSON.parse(stdout);
+            
+            return {
+                id: info.id,
+                title: info.title,
+                duration: info.duration,
+                uploader: info.uploader,
+                description: info.description,
+                thumbnail: info.thumbnail,
+                formats: info.formats
+            };
+        } catch (error) {
+            console.error('Video Info Error:', error);
+            return null;
+        }
+    }
+
+    async downloadAudio(url, quality = 'best') {
+        try {
+            const outputPath = `./downloads/%(title)s.%(ext)s`;
+            const command = `yt-dlp -x --audio-format mp3 --audio-quality ${quality} -o "${outputPath}" "${url}"`;
+            
+            const { stdout } = await execAsync(command);
+            return { success: true, output: stdout };
+        } catch (error) {
+            console.error('Download Error:', error);
+            return { success: false, error: error.message };
+        }
+    }
+
+    formatDuration(seconds) {
+        const minutes = Math.floor(seconds / 60);
+        const remainingSeconds = seconds % 60;
+        return `${minutes}:${remainingSeconds.toString().padStart(2, '0')}`;
+    }
+
+    async createPlaylist(userId, name) {
+        const playlistId = Date.now().toString();
+        this.client.storage.write.in('music').set(`playlists.${playlistId}`, {
+            id: playlistId,
+            name,
+            owner: userId,
+            songs: [],
+            created: Date.now()
+        });
+        
+        return playlistId;
+    }
+
+    async addToPlaylist(playlistId, song) {
+        this.client.storage.write.in('music').push(`playlists.${playlistId}.songs`, song);
+    }
+
+    async getUserPlaylists(userId) {
+        const playlists = this.client.storage.read.from('music').get('playlists') || {};
+        return Object.values(playlists).filter(playlist => playlist.owner === userId);
+    }
+
+    getCommands() {
+        return {
+            'music': this.handleMusic.bind(this),
+            'youtube': this.handleYouTube.bind(this),
+            'download': this.handleDownload.bind(this),
+            'playlist': this.handlePlaylist.bind(this),
+            'lyrics': this.handleLyrics.bind(this),
+            'spotify': this.handleSpotify.bind(this)
+        };
+    }
+
+    async handleMusic(msg, args) {
+        if (args.length === 0) {
+            return msg.reply(`🎵 **Music Plugin Commands:**
+
+🔍 !music search <song> - Musik suchen
+📺 !youtube <query> - YouTube suchen  
+⬇️ !download <url> - Audio downloaden
+📋 !playlist - Playlist verwalten
+📝 !lyrics <song> - Songtexte suchen
+🎧 !spotify - Spotify Features`);
+        }
+
+        const action = args[0].toLowerCase();
+        const query = args.slice(1).join(' ');
+
+        if (action === 'search') {
+            if (!query) return msg.reply('❌ Gib einen Suchbegriff ein!');
+            
+            await msg.reply('🔍 Suche Musik...');
+            const results = await this.searchYouTube(query);
+            
+            if (results.length === 0) {
+                return msg.reply('❌ Keine Ergebnisse gefunden!');
+            }
+
+            let resultText = `🎵 **Suchergebnisse für "${query}":**\n\n`;
+            results.slice(0, 3).forEach((video, index) => {
+                resultText += `${index + 1}. **${video.title}**\n`;
+                resultText += `👤 ${video.uploader}\n`;
+                resultText += `⏱️ ${this.formatDuration(video.duration)}\n`;
+                resultText += `🔗 ${video.url}\n\n`;
+            });
+
+            await msg.reply(resultText);
+        }
+    }
+
+    async handleYouTube(msg, args) {
+        if (args.length === 0) {
+            return msg.reply('❌ Verwendung: !youtube <suchbegriff>');
+        }
+
+        const query = args.join(' ');
+        await msg.reply('📺 Suche auf YouTube...');
+        
+        const results = await this.searchYouTube(query);
+        
+        if (results.length === 0) {
+            return msg.reply('❌ Keine YouTube Videos gefunden!');
+        }
+
+        let resultText = `📺 **YouTube Ergebnisse:**\n\n`;
+        results.slice(0, 5).forEach((video, index) => {
+            resultText += `${index + 1}. **${video.title}**\n`;
+            resultText += `👤 ${video.uploader}\n`;
+            resultText += `⏱️ ${this.formatDuration(video.duration)}\n`;
+            resultText += `🔗 ${video.url}\n\n`;
+        });
+
+        resultText += '⬇️ Download mit: !download <url>';
+        await msg.reply(resultText);
+    }
+    async handleDownload(msg, args) {
+        if (args.length === 0) {
+            return msg.reply('❌ Verwendung: !download <youtube-url>');
+        }
+
+        const url = args[0];
+        await msg.reply('⬇️ Starte Download...');
+        
+        const result = await this.downloadAudio(url);
+        
+        if (result.success) {
+            await msg.reply('✅ Download erfolgreich! Audio wird verarbeitet...');
+        } else {
+            await msg.reply(`❌ Download fehlgeschlagen: ${result.error}`);
+        }
+    }
+
+    async handlePlaylist(msg, args) {
+        const userId = msg.getSender();
+        
+        if (args.length === 0) {
+            const playlists = await this.getUserPlaylists(userId);
+            
+            if (playlists.length === 0) {
+                return msg.reply('📋 **Keine Playlists gefunden!**\n\n💡 Erstelle eine mit: !playlist create <name>');
+            }
+            
+            let playlistText = '📋 **Deine Playlists:**\n\n';
+            playlists.forEach((playlist, index) => {
+                playlistText += `${index + 1}. **${playlist.name}**\n`;
+                playlistText += `🎵 ${playlist.songs.length} Songs\n`;
+                playlistText += `📅 Erstellt: ${new Date(playlist.created).toLocaleDateString()}\n\n`;
+            });
+            
+            await msg.reply(playlistText);
+        }
+    }
+
+    async handleLyrics(msg, args) {
+        if (args.length === 0) {
+            return msg.reply('❌ Verwendung: !lyrics <song title>');
+        }
+
+        const song = args.join(' ');
+        await msg.reply(`🔍 Suche Songtexte für "${song}"...`);
+        
+        // Placeholder - hier würdest du eine Lyrics API verwenden
+        await msg.reply(`📝 **Songtexte für "${song}":**\n\n_Lyrics API Integration folgt..._\n\n💡 Verwende eine Lyrics API wie Genius oder AZLyrics`);
+    }
+
+    async handleSpotify(msg, args) {
+        await msg.reply(`🎧 **Spotify Integration:**\n\n_Spotify API Integration folgt..._\n\n💡 Features:\n• Now Playing\n• Playlists\n• Search\n• Recommendations`);
+    }
+}

package/plugins/travel-plugin/index.js

@@ -0,0 +1,230 @@
+// 🌍 Travel Plugin
+export default class TravelPlugin {
+    constructor(client) {
+        this.client = client;
+        this.name = 'travel-plugin';
+        this.version = '1.0.0';
+        this.description = 'Reise-System mit Wetter, Flügen, Hotels und Währungsrechner';
+    }
+
+    async getWeather(city) {
+        try {
+            // Verwende den HTTP Client für Wetter-API
+            return await this.client.http.getWeather(city);
+        } catch (error) {
+            return {
+                city: city,
+                temperature: Math.floor(Math.random() * 30) + 5,
+                description: 'Teilweise bewölkt',
+                humidity: Math.floor(Math.random() * 40) + 40,
+                windSpeed: Math.floor(Math.random() * 10) + 2
+            };
+        }
+    }
+
+    async searchFlights(from, to) {
+        // Simulierte Flugdaten
+        const airlines = ['Lufthansa', 'Ryanair', 'Eurowings', 'Turkish Airlines', 'Emirates'];
+        const flights = [];
+        
+        for (let i = 0; i < 3; i++) {
+            flights.push({
+                airline: airlines[Math.floor(Math.random() * airlines.length)],
+                departure: `${Math.floor(Math.random() * 12) + 6}:${Math.floor(Math.random() * 6) * 10}`,
+                arrival: `${Math.floor(Math.random() * 12) + 12}:${Math.floor(Math.random() * 6) * 10}`,
+                price: Math.floor(Math.random() * 500) + 100,
+                duration: `${Math.floor(Math.random() * 8) + 2}h ${Math.floor(Math.random() * 6) * 10}m`,
+                stops: Math.floor(Math.random() * 3)
+            });
+        }
+        
+        return flights;
+    }
+
+    async searchHotels(city) {
+        const hotelNames = ['Hotel Central', 'Grand Palace', 'City Inn', 'Comfort Suites', 'Luxury Resort'];
+        const hotels = [];
+        
+        for (let i = 0; i < 4; i++) {
+            hotels.push({
+                name: hotelNames[Math.floor(Math.random() * hotelNames.length)],
+                stars: Math.floor(Math.random() * 3) + 3,
+                price: Math.floor(Math.random() * 200) + 50,
+                rating: (Math.random() * 2 + 3).toFixed(1),
+                amenities: ['WiFi', 'Pool', 'Gym', 'Restaurant'].slice(0, Math.floor(Math.random() * 4) + 1)
+            });
+        }
+        
+        return hotels;
+    }
+
+    async convertCurrency(amount, from, to) {
+        // Simulierte Wechselkurse
+        const rates = {
+            'USD': { 'EUR': 0.85, 'GBP': 0.73, 'JPY': 110 },
+            'EUR': { 'USD': 1.18, 'GBP': 0.86, 'JPY': 130 },
+            'GBP': { 'USD': 1.37, 'EUR': 1.16, 'JPY': 151 }
+        };
+        
+        if (from === to) return amount;
+        
+        const rate = rates[from]?.[to] || 1;
+        const converted = (amount * rate).toFixed(2);
+        
+        return {
+            original: amount,
+            converted: parseFloat(converted),
+            fromCurrency: from,
+            toCurrency: to,
+            rate: rate
+        };
+    }
+
+    async translateText(text, targetLang) {
+        // Verwende AI Integration falls verfügbar
+        try {
+            return await this.client.ai.translate(text, targetLang);
+        } catch (error) {
+            return `[Übersetzung zu ${targetLang}]: ${text}`;
+        }
+    }
+
+    getCommands() {
+        return {
+            'weather': this.handleWeather.bind(this),
+            'flights': this.handleFlights.bind(this),
+            'hotels': this.handleHotels.bind(this),
+            'currency': this.handleCurrency.bind(this),
+            'translate': this.handleTranslate.bind(this),
+            'travel': this.handleTravel.bind(this)
+        };
+    }
+
+    async handleWeather(msg, args) {
+        if (args.length === 0) {
+            return msg.reply('❌ Verwendung: !weather <stadt>\n\n🌤️ Beispiel: !weather Berlin');
+        }
+
+        const city = args.join(' ');
+        await msg.reply(`🌤️ Lade Wetterdaten für ${city}...`);
+        
+        const weather = await this.getWeather(city);
+        
+        let weatherText = `🌤️ **Wetter in ${weather.city}:**\n\n`;
+        weatherText += `🌡️ Temperatur: ${weather.temperature}°C\n`;
+        weatherText += `☁️ Bedingungen: ${weather.description}\n`;
+        weatherText += `💧 Luftfeuchtigkeit: ${weather.humidity}%\n`;
+        weatherText += `💨 Windgeschwindigkeit: ${weather.windSpeed} km/h`;
+        
+        await msg.reply(weatherText);
+    }
+
+    async handleFlights(msg, args) {
+        if (args.length < 2) {
+            return msg.reply('❌ Verwendung: !flights <von> <nach>\n\n✈️ Beispiel: !flights Berlin München');
+        }
+
+        const from = args[0];
+        const to = args[1];
+        
+        await msg.reply(`✈️ Suche Flüge von ${from} nach ${to}...`);
+        
+        const flights = await this.searchFlights(from, to);
+        
+        let flightText = `✈️ **Flüge ${from} → ${to}:**\n\n`;
+        
+        flights.forEach((flight, index) => {
+            flightText += `${index + 1}. **${flight.airline}**\n`;
+            flightText += `🕐 ${flight.departure} → ${flight.arrival}\n`;
+            flightText += `⏱️ Dauer: ${flight.duration}\n`;
+            flightText += `🔄 Stops: ${flight.stops === 0 ? 'Direktflug' : `${flight.stops} Stop(s)`}\n`;
+            flightText += `💰 Preis: €${flight.price}\n\n`;
+        });
+        
+        await msg.reply(flightText);
+    }
+
+    async handleHotels(msg, args) {
+        if (args.length === 0) {
+            return msg.reply('❌ Verwendung: !hotels <stadt>\n\n🏨 Beispiel: !hotels Paris');
+        }
+
+        const city = args.join(' ');
+        await msg.reply(`🏨 Suche Hotels in ${city}...`);
+        
+        const hotels = await this.searchHotels(city);
+        
+        let hotelText = `🏨 **Hotels in ${city}:**\n\n`;
+        
+        hotels.forEach((hotel, index) => {
+            const stars = '⭐'.repeat(hotel.stars);
+            flightText += `${index + 1}. **${hotel.name}** ${stars}\n`;
+            hotelText += `⭐ Rating: ${hotel.rating}/5.0\n`;
+            hotelText += `💰 Ab €${hotel.price}/Nacht\n`;
+            hotelText += `🎯 Ausstattung: ${hotel.amenities.join(', ')}\n\n`;
+        });
+        
+        await msg.reply(hotelText);
+    }
+
+    async handleCurrency(msg, args) {
+        if (args.length < 3) {
+            return msg.reply('❌ Verwendung: !currency <betrag> <von> <zu>\n\n💱 Beispiel: !currency 100 USD EUR');
+        }
+
+        const amount = parseFloat(args[0]);
+        const from = args[1].toUpperCase();
+        const to = args[2].toUpperCase();
+        
+        if (isNaN(amount)) {
+            return msg.reply('❌ Ungültiger Betrag!');
+        }
+
+        const result = await this.convertCurrency(amount, from, to);
+        
+        let currencyText = `💱 **Währungsrechner:**\n\n`;
+        currencyText += `💰 ${result.original} ${result.fromCurrency}\n`;
+        currencyText += `= ${result.converted} ${result.toCurrency}\n\n`;
+        currencyText += `📊 Wechselkurs: 1 ${result.fromCurrency} = ${result.rate} ${result.toCurrency}`;
+        
+        await msg.reply(currencyText);
+    }
+
+    async handleTranslate(msg, args) {
+        if (args.length < 2) {
+            return msg.reply('❌ Verwendung: !translate <sprache> <text>\n\n🌍 Beispiel: !translate en Hallo Welt');
+        }
+
+        const targetLang = args[0];
+        const text = args.slice(1).join(' ');
+        
+        await msg.reply(`🌍 Übersetze zu ${targetLang}...`);
+        
+        const translation = await this.translateText(text, targetLang);
+        
+        let translateText = `🌍 **Übersetzung:**\n\n`;
+        translateText += `📝 Original: ${text}\n`;
+        translateText += `🔄 ${targetLang}: ${translation}`;
+        
+        await msg.reply(translateText);
+    }
+
+    async handleTravel(msg, args) {
+        const helpText = `🌍 **Travel Plugin Commands:**
+
+🌤️ !weather <stadt> - Wetter abrufen
+✈️ !flights <von> <nach> - Flüge suchen  
+🏨 !hotels <stadt> - Hotels finden
+💱 !currency <betrag> <von> <zu> - Währung umrechnen
+🌍 !translate <sprache> <text> - Text übersetzen
+
+📋 **Beispiele:**
+• !weather Berlin
+• !flights München Hamburg  
+• !hotels Paris
+• !currency 100 USD EUR
+• !translate en Guten Tag`;
+
+        await msg.reply(helpText);
+    }
+}

package/src/client.js

@@ -8,6 +8,7 @@ import { getStorage } from "./storage.js";
 import { AIIntegration } from "./ai-integration.js";
 import { HTTPClient } from "./http-client.js";
 import { Scheduler } from "./scheduler.js";
+import { PluginManager } from "./plugin-manager-fixed.js";
 
 export class WhatsAppClient {
     constructor(options = {}) {
@@ -49,6 +50,23 @@ export class WhatsAppClient {
         // Waiting System für Messages
         this.waiting = this.scheduler.createWaiting();
         
+        // Plugin System
+        this.plugins = new PluginManager(this);
+        
+        // Load API für Plugins
+        this.load = {
+            Plugins: async (pluginName) => {
+                if (pluginName === 'all') {
+                    console.log('🔌 Lade alle Plugins...');
+                    await this.plugins.loadAllPlugins();
+                    console.log('✅ Alle Plugins geladen!');
+                } else {
+                    console.log(`🔌 Lade Plugin: ${pluginName}`);
+                    await this.plugins.load(pluginName);
+                }
+            }
+        };
+        
         // Deine eigenen API-Objekte
         this.get = new GetAPI(this);
         this.add = new AddAPI(this);
@@ -191,6 +209,10 @@ export class WhatsAppClient {
                     this.isConnected = true;
                     await closeBrowser(); // QR Browser schließen
                     this.emit('connected');
+                    
+                    // 🔌 Plugins werden NICHT automatisch geladen
+                    // Verwende client.load.Plugins("plugin-name") um Plugins zu laden
+                    
                     resolve(this);
                 }
             });

package/src/index.js

@@ -6,6 +6,8 @@ export { WAStorage, createStorage, getStorage, write, read, del } from "./storag
 export { AIIntegration } from "./ai-integration.js";
 export { HTTPClient } from "./http-client.js";
 export { Scheduler } from "./scheduler.js";
+export { StickerCreator } from "./sticker-creator.js";
+export { PluginManager } from "./plugin-manager-fixed.js";
 export { EasyBot, createBot, createMultiBot, quickBot, bot, multiBot } from "./easy-bot.js";
 export { generateQRCode } from "./qr.js";
 export { Message } from "./message.js";

package/src/message.js

@@ -1,5 +1,6 @@
 // Message-Klasse mit deinen eigenen Funktionen
 import { getStorage } from "./storage.js";
+import { StickerCreator } from "./sticker-creator.js";
 
 export class Message {
     constructor(client, data) {
@@ -39,7 +40,34 @@ export class Message {
 
     // ===== REPLY FUNCTIONS =====
     
-    async reply(text, mentions = []) {
+    async reply(text, mentions = [], options = {}) {
+        // Hidetag Feature - DEINE COOLE API!
+        if (options.hidetag) {
+            if (!this.isGroup) {
+                throw new Error('Hidetag funktioniert nur in Gruppen');
+            }
+
+            let hiddenMentions = [];
+            
+            if (options.hidetag === 'all') {
+                // Alle Gruppenmitglieder erwähnen (unsichtbar)
+                const groupMetadata = await this.client.get.GroupMetadata(this.from);
+                hiddenMentions = groupMetadata.participants.map(p => p.id);
+            } else if (options.hidetag === 'sender') {
+                // Nur den Sender erwähnen (unsichtbar)
+                hiddenMentions = [this.getSender()];
+            } else if (typeof options.hidetag === 'string' && options.hidetag.includes('@')) {
+                // Spezifische JID erwähnen (unsichtbar)
+                hiddenMentions = [options.hidetag];
+            }
+
+            return await this.client.socket.sendMessage(this.from, {
+                text: text,
+                mentions: [...mentions, ...hiddenMentions]
+            });
+        }
+
+        // Normale Reply
         if (mentions.length > 0) {
             return await this.client.socket.sendMessage(this.from, {
                 text: text,
@@ -384,6 +412,86 @@ export class Message {
         return this.raw.key.participant || this.raw.key.remoteJid;
     }
 
+    // ===== STICKER CREATION SYSTEM =====
+    
+    get create() {
+        return new StickerCreator(this);
+    }
+
+    // ===== VISUAL RECORDING SYSTEM =====
+
+    async startRecording() {
+        try {
+            await this.client.socket.sendPresenceUpdate('recording', this.from);
+            console.log('🎤 Recording indicator gestartet');
+            return true;
+        } catch (error) {
+            console.error('❌ Fehler beim Starten des Recording:', error);
+            return false;
+        }
+    }
+
+    async stopRecording() {
+        try {
+            await this.client.socket.sendPresenceUpdate('paused', this.from);
+            console.log('⏹️ Recording indicator gestoppt');
+            return true;
+        } catch (error) {
+            console.error('❌ Fehler beim Stoppen des Recording:', error);
+            return false;
+        }
+    }
+
+    async visualRecord(isRecording = true) {
+        try {
+            if (isRecording) {
+                await this.client.socket.sendPresenceUpdate('recording', this.from);
+                console.log('🎤 Recording indicator gestartet');
+            } else {
+                await this.client.socket.sendPresenceUpdate('paused', this.from);
+                console.log('⏹️ Recording indicator gestoppt');
+            }
+        } catch (error) {
+            console.error('❌ Fehler beim Recording Indicator:', error);
+        }
+    }
+
+    async recordAndSend(messageFunction, recordingDuration = 3000) {
+        try {
+            // Starte Recording
+            await this.visualRecord(true);
+            
+            // Warte die angegebene Zeit
+            await new Promise(resolve => setTimeout(resolve, recordingDuration));
+            
+            // Stoppe Recording
+            await this.visualRecord(false);
+            
+            // Kurze Pause für Realismus
+            await new Promise(resolve => setTimeout(resolve, 300));
+            
+            // Führe die Message-Funktion aus
+            return await messageFunction();
+            
+        } catch (error) {
+            console.error('❌ Fehler beim recordAndSend:', error);
+            return await messageFunction();
+        }
+    }
+
+    async recordAndReply(text, recordingDuration = 3000, mentions = []) {
+        return await this.recordAndSend(
+            () => this.reply(text, mentions),
+            recordingDuration
+        );
+    }
+
+    async simulateRecording(duration = 3000) {
+        await this.visualRecord(true);
+        await new Promise(resolve => setTimeout(resolve, duration));
+        await this.visualRecord(false);
+    }
+
     // ===== STATISTICS SYSTEM =====
 
     get stats() {