waengine 1.0.7 → 1.0.9

package/src/http-client.js

@@ -0,0 +1,276 @@
+// HTTP Client für WAEngine
+import axios from 'axios';
+
+export class HTTPClient {
+    constructor(options = {}) {
+        this.timeout = options.timeout || 10000;
+        this.retries = options.retries || 3;
+        this.baseHeaders = options.headers || {};
+        
+        // Axios Instance erstellen
+        this.axios = axios.create({
+            timeout: this.timeout,
+            headers: this.baseHeaders
+        });
+        
+        console.log('🌐 HTTP Client initialisiert');
+    }
+
+    // ===== BASIC HTTP METHODS =====
+    
+    async get(url, options = {}) {
+        return await this.request('GET', url, null, options);
+    }
+
+    async post(url, data = null, options = {}) {
+        return await this.request('POST', url, data, options);
+    }
+
+    async put(url, data = null, options = {}) {
+        return await this.request('PUT', url, data, options);
+    }
+
+    async delete(url, options = {}) {
+        return await this.request('DELETE', url, null, options);
+    }
+
+    // ===== CORE REQUEST METHOD =====
+    
+    async request(method, url, data = null, options = {}) {
+        let lastError;
+        
+        for (let attempt = 1; attempt <= this.retries; attempt++) {
+            try {
+                const config = {
+                    method,
+                    url,
+                    ...options
+                };
+                
+                if (data) {
+                    config.data = data;
+                }
+                
+                const response = await this.axios(config);
+                return response.data;
+                
+            } catch (error) {
+                lastError = error;
+                
+                if (attempt < this.retries && this.shouldRetry(error)) {
+                    console.log(`🔄 HTTP Retry ${attempt}/${this.retries} für ${url}`);
+                    await this.delay(1000 * attempt); // Exponential backoff
+                } else {
+                    break;
+                }
+            }
+        }
+        
+        throw new Error(`HTTP Request failed: ${lastError.message}`);
+    }
+
+    shouldRetry(error) {
+        // Retry bei Netzwerk-Fehlern oder 5xx Status Codes
+        return !error.response || error.response.status >= 500;
+    }
+
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    // ===== API WRAPPERS =====
+    
+    // Weather API
+    async getWeather(city, apiKey = process.env.WEATHER_API_KEY) {
+        if (!apiKey) {
+            throw new Error('❌ Weather API Key fehlt! Setze WEATHER_API_KEY');
+        }
+        
+        try {
+            const data = await this.get(`https://api.openweathermap.org/data/2.5/weather`, {
+                params: {
+                    q: city,
+                    appid: apiKey,
+                    units: 'metric',
+                    lang: 'de'
+                }
+            });
+            
+            return {
+                city: data.name,
+                country: data.sys.country,
+                temperature: Math.round(data.main.temp),
+                description: data.weather[0].description,
+                humidity: data.main.humidity,
+                windSpeed: data.wind.speed,
+                icon: data.weather[0].icon
+            };
+        } catch (error) {
+            throw new Error(`Wetter-Fehler: ${error.message}`);
+        }
+    }
+
+    // News API
+    async getNews(category = 'general', apiKey = process.env.NEWS_API_KEY) {
+        if (!apiKey) {
+            throw new Error('❌ News API Key fehlt! Setze NEWS_API_KEY');
+        }
+        
+        try {
+            const data = await this.get(`https://newsapi.org/v2/top-headlines`, {
+                params: {
+                    country: 'de',
+                    category: category,
+                    apiKey: apiKey,
+                    pageSize: 5
+                }
+            });
+            
+            return data.articles.map(article => ({
+                title: article.title,
+                description: article.description,
+                url: article.url,
+                source: article.source.name,
+                publishedAt: new Date(article.publishedAt).toLocaleDateString('de-DE')
+            }));
+        } catch (error) {
+            throw new Error(`News-Fehler: ${error.message}`);
+        }
+    }
+
+    // Crypto Prices
+    async getCryptoPrice(symbol = 'bitcoin') {
+        try {
+            const data = await this.get(`https://api.coingecko.com/api/v3/simple/price`, {
+                params: {
+                    ids: symbol,
+                    vs_currencies: 'eur,usd',
+                    include_24hr_change: true
+                }
+            });
+            
+            const coin = data[symbol];
+            return {
+                symbol: symbol,
+                priceEUR: coin.eur,
+                priceUSD: coin.usd,
+                change24h: coin.eur_24h_change?.toFixed(2) || 0
+            };
+        } catch (error) {
+            throw new Error(`Crypto-Fehler: ${error.message}`);
+        }
+    }
+
+    // QR Code Generator
+    async generateQRCode(text, size = 200) {
+        try {
+            const url = `https://api.qrserver.com/v1/create-qr-code/?size=${size}x${size}&data=${encodeURIComponent(text)}`;
+            
+            // Return URL instead of downloading
+            return {
+                url: url,
+                text: text,
+                size: size
+            };
+        } catch (error) {
+            throw new Error(`QR-Code-Fehler: ${error.message}`);
+        }
+    }
+
+    // URL Shortener
+    async shortenUrl(longUrl, apiKey = process.env.BITLY_API_KEY) {
+        if (!apiKey) {
+            // Fallback zu kostenlosem Service
+            try {
+                const data = await this.post('https://is.gd/create.php', null, {
+                    params: {
+                        format: 'json',
+                        url: longUrl
+                    }
+                });
+                
+                return {
+                    shortUrl: data.shorturl,
+                    longUrl: longUrl,
+                    service: 'is.gd'
+                };
+            } catch (error) {
+                throw new Error(`URL-Shortener-Fehler: ${error.message}`);
+            }
+        }
+        
+        // Bitly API
+        try {
+            const data = await this.post('https://api-ssl.bitly.com/v4/shorten', {
+                long_url: longUrl
+            }, {
+                headers: {
+                    'Authorization': `Bearer ${apiKey}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            
+            return {
+                shortUrl: data.link,
+                longUrl: longUrl,
+                service: 'bitly'
+            };
+        } catch (error) {
+            throw new Error(`Bitly-Fehler: ${error.message}`);
+        }
+    }
+
+    // Random Facts
+    async getRandomFact() {
+        try {
+            const data = await this.get('https://uselessfacts.jsph.pl/random.json?language=en');
+            return data.text;
+        } catch (error) {
+            throw new Error(`Random-Fact-Fehler: ${error.message}`);
+        }
+    }
+
+    // Random Joke
+    async getRandomJoke() {
+        try {
+            const data = await this.get('https://official-joke-api.appspot.com/random_joke');
+            return `${data.setup}\n\n${data.punchline}`;
+        } catch (error) {
+            throw new Error(`Joke-Fehler: ${error.message}`);
+        }
+    }
+
+    // IP Info
+    async getIPInfo(ip = '') {
+        try {
+            const url = ip ? `http://ip-api.com/json/${ip}` : 'http://ip-api.com/json/';
+            const data = await this.get(url);
+            
+            return {
+                ip: data.query,
+                country: data.country,
+                city: data.city,
+                region: data.regionName,
+                timezone: data.timezone,
+                isp: data.isp
+            };
+        } catch (error) {
+            throw new Error(`IP-Info-Fehler: ${error.message}`);
+        }
+    }
+
+    // Website Screenshot (via API)
+    async getWebsiteScreenshot(url, width = 1280, height = 720) {
+        try {
+            const screenshotUrl = `https://api.screenshotmachine.com/?key=${process.env.SCREENSHOT_API_KEY}&url=${encodeURIComponent(url)}&dimension=${width}x${height}`;
+            
+            return {
+                screenshotUrl: screenshotUrl,
+                originalUrl: url,
+                dimensions: `${width}x${height}`
+            };
+        } catch (error) {
+            throw new Error(`Screenshot-Fehler: ${error.message}`);
+        }
+    }
+}

package/src/index.js

@@ -2,6 +2,12 @@ export { WhatsAppClient } from "./client.js";
 export { MultiWhatsAppClient } from "./multi-client.js";
 export { DeviceManager } from "./device-manager.js";
 export { PrefixManager } from "./prefix-manager.js";
+export { WAStorage, createStorage, getStorage, write, read, del } from "./storage.js";
+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,4 +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) {
@@ -17,11 +19,55 @@ export class Message {
         this.command = null;
         this.args = [];
         this.commandText = null;
+        
+        // Storage System
+        this.storage = getStorage();
+        this.write = this.storage.write;
+        this.read = this.storage.read;
+        this.delete = this.storage.delete;
+        
+        // Waiting System - DEINE COOLE API!
+        this.waiting = {
+            after: {
+                message: (ms) => {
+                    return new Promise(resolve => {
+                        setTimeout(resolve, ms);
+                    });
+                }
+            }
+        };
     }
 
     // ===== 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,
@@ -366,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() {

package/src/plugin-manager-fixed.js

@@ -0,0 +1,116 @@
+// 🔌 WAEngine Plugin Manager - Auto-Plugin System
+import { existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { pathToFileURL } from 'url';
+
+export class PluginManager {
+    constructor(client) {
+        this.client = client;
+        this.plugins = new Map();
+        this.pluginsDir = './plugins';
+        this.availablePlugins = [
+            'economy-system',
+            'games-plugin',
+            'music-plugin',
+            'travel-plugin',
+            'education-plugin',
+            'moderation-plugin',
+            'creative-plugin',
+            'analytics-plugin'
+        ];
+        
+        this.ensurePluginsDirectory();
+    }
+
+    ensurePluginsDirectory() {
+        if (!existsSync(this.pluginsDir)) {
+            mkdirSync(this.pluginsDir, { recursive: true });
+            console.log('📁 Plugins Ordner erstellt');
+        }
+    }
+
+    async load(pluginName) {
+        try {
+            console.log(`🔌 Lade Plugin: ${pluginName}`);
+            
+            // Plugin importieren mit korrekter Windows file:// URL
+            const pluginPath = join(process.cwd(), this.pluginsDir, pluginName, 'index.js');
+            
+            if (!existsSync(pluginPath)) {
+                console.log(`📝 Plugin ${pluginName} nicht gefunden - wird übersprungen`);
+                return null;
+            }
+            
+            // Windows-kompatible file:// URL erstellen
+            const pluginUrl = pathToFileURL(pluginPath).href;
+            console.log(`📂 Plugin Pfad: ${pluginUrl}`);
+            
+            const { default: PluginClass } = await import(pluginUrl);
+            
+            // Plugin instanziieren
+            const plugin = new PluginClass(this.client);
+            this.plugins.set(pluginName, plugin);
+            
+            // Commands registrieren
+            await this.registerPluginCommands(plugin);
+            
+            console.log(`✅ Plugin geladen: ${pluginName} v${plugin.version}`);
+            return plugin;
+            
+        } catch (error) {
+            console.error(`❌ Plugin Fehler: ${pluginName}`, error.message);
+            return null;
+        }
+    }
+
+    async loadAllPlugins() {
+        console.log('🚀 Lade alle verfügbaren Plugins...');
+        
+        for (const pluginName of this.availablePlugins) {
+            await this.load(pluginName);
+        }
+        
+        console.log(`✅ ${this.plugins.size} Plugins geladen`);
+    }
+
+    async registerPluginCommands(plugin) {
+        const commands = plugin.getCommands();
+        
+        Object.entries(commands).forEach(([commandName, handler]) => {
+            this.client.addCommand(commandName, async (msg, args) => {
+                try {
+                    // Plugin-Context zu Message hinzufügen
+                    msg.plugin = this.getPluginContext();
+                    await handler(msg, args);
+                } catch (error) {
+                    console.error(`❌ Plugin Command Fehler: ${commandName}`, error);
+                    await msg.reply(`❌ Plugin Fehler: ${error.message}`);
+                }
+            });
+        });
+    }
+
+    getPluginContext() {
+        const context = {};
+        this.plugins.forEach((plugin, name) => {
+            context[name.replace('-', '_')] = plugin;
+        });
+        return context;
+    }
+
+    get(pluginName) {
+        return this.plugins.get(pluginName);
+    }
+
+    list() {
+        return Array.from(this.plugins.keys());
+    }
+
+    getStats() {
+        return {
+            loaded: this.plugins.size,
+            available: this.availablePlugins.length,
+            plugins: this.list()
+        };
+    }
+}

package/src/plugin-manager.js

@@ -0,0 +1,105 @@
+// 🔌 WAEngine Plugin Manager - Auto-Plugin System
+import { existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+export class PluginManager {
+    constructor(client) {
+        this.client = client;
+        this.plugins = new Map();
+        this.pluginsDir = './plugins';
+        this.availablePlugins = [
+            'economy-system',
+            'games-plugin'
+        ];
+        
+        this.ensurePluginsDirectory();
+    }
+
+    ensurePluginsDirectory() {
+        if (!existsSync(this.pluginsDir)) {
+            mkdirSync(this.pluginsDir, { recursive: true });
+            console.log('📁 Plugins Ordner erstellt');
+        }
+    }
+
+    async load(pluginName) {
+        try {
+            console.log(`🔌 Lade Plugin: ${pluginName}`);
+            
+            // Plugin importieren
+            const pluginPath = join(process.cwd(), this.pluginsDir, pluginName, 'index.js');
+            
+            if (!existsSync(pluginPath)) {
+                console.log(`📝 Plugin ${pluginName} nicht gefunden - wird übersprungen`);
+                return null;
+            }
+            
+            const { default: PluginClass } = await import(pluginPath);
+            
+            // Plugin instanziieren
+            const plugin = new PluginClass(this.client);
+            this.plugins.set(pluginName, plugin);
+            
+            // Commands registrieren
+            await this.registerPluginCommands(plugin);
+            
+            console.log(`✅ Plugin geladen: ${pluginName} v${plugin.version}`);
+            return plugin;
+            
+        } catch (error) {
+            console.error(`❌ Plugin Fehler: ${pluginName}`, error.message);
+            return null;
+        }
+    }
+
+    async loadAllPlugins() {
+        console.log('🚀 Lade alle verfügbaren Plugins...');
+        
+        for (const pluginName of this.availablePlugins) {
+            await this.load(pluginName);
+        }
+        
+        console.log(`✅ ${this.plugins.size} Plugins geladen`);
+    }
+
+    async registerPluginCommands(plugin) {
+        const commands = plugin.getCommands();
+        
+        Object.entries(commands).forEach(([commandName, handler]) => {
+            this.client.addCommand(commandName, async (msg, args) => {
+                try {
+                    // Plugin-Context zu Message hinzufügen
+                    msg.plugin = this.getPluginContext();
+                    await handler(msg, args);
+                } catch (error) {
+                    console.error(`❌ Plugin Command Fehler: ${commandName}`, error);
+                    await msg.reply(`❌ Plugin Fehler: ${error.message}`);
+                }
+            });
+        });
+    }
+
+    getPluginContext() {
+        const context = {};
+        this.plugins.forEach((plugin, name) => {
+            context[name.replace('-', '_')] = plugin;
+        });
+        return context;
+    }
+
+    get(pluginName) {
+        return this.plugins.get(pluginName);
+    }
+
+    list() {
+        return Array.from(this.plugins.keys());
+    }
+
+    getStats() {
+        return {
+            loaded: this.plugins.size,
+            available: this.availablePlugins.length,
+            plugins: this.list()
+        };
+    }
+}