waengine 1.0.8 → 1.0.10

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() {

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()
+        };
+    }
+}