waengine 1.0.7 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waengine",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "🚀 WAEngine - The most powerful WhatsApp Bot Library with Multi-Device Support & EasyBot API",
   "main": "src/index.js",
   "type": "module",
@@ -50,6 +50,8 @@
   },
   "dependencies": {
     "@whiskeysockets/baileys": "^7.0.0-rc.9",
+    "axios": "^1.13.4",
+    "node-cron": "^3.0.3",
     "pino": "^8.0.0",
     "playwright": "^1.58.1",
     "qrcode": "^1.5.4",

package/src/ai-integration.js

@@ -0,0 +1,185 @@
+// AI Integration für WAEngine
+import axios from 'axios';
+
+export class AIIntegration {
+    constructor(options = {}) {
+        this.apiKey = options.apiKey || process.env.OPENAI_API_KEY;
+        this.baseURL = options.baseURL || 'https://api.openai.com/v1';
+        this.model = options.model || 'gpt-3.5-turbo';
+        this.enabled = !!this.apiKey;
+        
+        if (!this.enabled) {
+            console.log('⚠️ AI Integration deaktiviert - Kein API Key gefunden');
+        } else {
+            console.log('🤖 AI Integration aktiviert');
+        }
+    }
+
+    // ===== CHAT COMPLETION =====
+    
+    async chat(prompt, options = {}) {
+        if (!this.enabled) {
+            throw new Error('❌ AI Integration nicht konfiguriert! Setze OPENAI_API_KEY');
+        }
+
+        try {
+            const response = await axios.post(`${this.baseURL}/chat/completions`, {
+                model: options.model || this.model,
+                messages: [
+                    {
+                        role: 'system',
+                        content: options.systemPrompt || 'Du bist ein hilfreicher WhatsApp Bot Assistent. Antworte kurz und freundlich auf Deutsch.'
+                    },
+                    {
+                        role: 'user',
+                        content: prompt
+                    }
+                ],
+                max_tokens: options.maxTokens || 500,
+                temperature: options.temperature || 0.7
+            }, {
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+
+            return response.data.choices[0].message.content.trim();
+        } catch (error) {
+            console.error('❌ AI Chat Fehler:', error.response?.data || error.message);
+            throw new Error(`AI Fehler: ${error.response?.data?.error?.message || error.message}`);
+        }
+    }
+
+    // ===== SMART RESPONSES =====
+    
+    async smartReply(message, context = {}) {
+        const prompt = `
+Kontext: WhatsApp Bot Nachricht
+User schrieb: "${message}"
+Chat-Type: ${context.isGroup ? 'Gruppe' : 'Privat'}
+${context.userName ? `User: ${context.userName}` : ''}
+
+Antworte natürlich und hilfreich. Maximal 2 Sätze.
+        `.trim();
+
+        return await this.chat(prompt, {
+            systemPrompt: 'Du bist ein freundlicher WhatsApp Bot. Antworte natürlich und kurz.',
+            maxTokens: 200
+        });
+    }
+
+    // ===== TEXT ANALYSIS =====
+    
+    async analyzeMessage(text) {
+        const prompt = `
+Analysiere diese Nachricht:
+"${text}"
+
+Gib zurück als JSON:
+{
+  "sentiment": "positive/negative/neutral",
+  "language": "de/en/es/fr/etc",
+  "category": "question/command/greeting/complaint/other",
+  "toxicity": "low/medium/high",
+  "confidence": 0.0-1.0
+}
+        `.trim();
+
+        try {
+            const response = await this.chat(prompt, {
+                systemPrompt: 'Du bist ein Text-Analyse-Experte. Antworte nur mit gültigem JSON.',
+                maxTokens: 150
+            });
+            
+            return JSON.parse(response);
+        } catch (error) {
+            return {
+                sentiment: 'neutral',
+                language: 'unknown',
+                category: 'other',
+                toxicity: 'low',
+                confidence: 0.5
+            };
+        }
+    }
+
+    // ===== MODERATION =====
+    
+    async moderateContent(text) {
+        try {
+            const response = await axios.post(`${this.baseURL}/moderations`, {
+                input: text
+            }, {
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+
+            const result = response.data.results[0];
+            
+            return {
+                flagged: result.flagged,
+                categories: result.categories,
+                scores: result.category_scores,
+                safe: !result.flagged
+            };
+        } catch (error) {
+            console.error('❌ Moderation Fehler:', error.message);
+            return { flagged: false, safe: true };
+        }
+    }
+
+    // ===== TRANSLATION =====
+    
+    async translate(text, targetLang = 'de') {
+        const prompt = `Übersetze folgenden Text nach ${targetLang}. Antworte nur mit der Übersetzung:\n\n"${text}"`;
+        
+        return await this.chat(prompt, {
+            systemPrompt: 'Du bist ein professioneller Übersetzer. Antworte nur mit der Übersetzung.',
+            maxTokens: 300
+        });
+    }
+
+    // ===== SUMMARIZATION =====
+    
+    async summarize(text, maxLength = 100) {
+        const prompt = `Fasse folgenden Text in maximal ${maxLength} Zeichen zusammen:\n\n"${text}"`;
+        
+        return await this.chat(prompt, {
+            systemPrompt: 'Du bist ein Experte für Textzusammenfassungen. Sei präzise und kurz.',
+            maxTokens: Math.ceil(maxLength / 2)
+        });
+    }
+
+    // ===== QUESTION ANSWERING =====
+    
+    async answerQuestion(question, context = '') {
+        const prompt = context ? 
+            `Kontext: ${context}\n\nFrage: ${question}` : 
+            question;
+            
+        return await this.chat(prompt, {
+            systemPrompt: 'Du bist ein hilfreicher Assistent. Beantworte Fragen präzise und verständlich.',
+            maxTokens: 400
+        });
+    }
+
+    // ===== CREATIVE WRITING =====
+    
+    async generateText(prompt, style = 'normal') {
+        const stylePrompts = {
+            funny: 'Schreibe lustig und humorvoll',
+            formal: 'Schreibe formal und professionell',
+            casual: 'Schreibe locker und umgangssprachlich',
+            creative: 'Schreibe kreativ und fantasievoll',
+            normal: 'Schreibe natürlich und verständlich'
+        };
+
+        return await this.chat(prompt, {
+            systemPrompt: `Du bist ein kreativer Schreiber. ${stylePrompts[style] || stylePrompts.normal}.`,
+            maxTokens: 600
+        });
+    }
+}

package/src/client.js

@@ -4,6 +4,10 @@ import { generateQRCode, closeBrowser } from "./qr.js";
 import { Message } from "./message.js";
 import { SessionManager } from "./session-manager.js";
 import { PrefixManager } from "./prefix-manager.js";
+import { getStorage } from "./storage.js";
+import { AIIntegration } from "./ai-integration.js";
+import { HTTPClient } from "./http-client.js";
+import { Scheduler } from "./scheduler.js";
 
 export class WhatsAppClient {
     constructor(options = {}) {
@@ -30,6 +34,21 @@ export class WhatsAppClient {
         this.prefixManager = new PrefixManager('./data');
         this.commands = new Map();
         
+        // Storage System
+        this.storage = getStorage();
+        
+        // AI Integration
+        this.ai = new AIIntegration(options.ai || {});
+        
+        // HTTP Client
+        this.http = new HTTPClient(options.http || {});
+        
+        // Scheduler System
+        this.scheduler = new Scheduler(this);
+        
+        // Waiting System für Messages
+        this.waiting = this.scheduler.createWaiting();
+        
         // Deine eigenen API-Objekte
         this.get = new GetAPI(this);
         this.add = new AddAPI(this);

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,10 @@ 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 { 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,5 @@
 // Message-Klasse mit deinen eigenen Funktionen
+import { getStorage } from "./storage.js";
 
 export class Message {
     constructor(client, data) {
@@ -17,6 +18,23 @@ 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 =====

package/src/scheduler.js

@@ -0,0 +1,322 @@
+// Scheduler System für WAEngine
+import cron from 'node-cron';
+
+export class Scheduler {
+    constructor(client) {
+        this.client = client;
+        this.jobs = new Map();
+        this.storage = client.storage;
+        
+        // Gespeicherte Jobs beim Start laden
+        this.loadScheduledJobs();
+        
+        console.log('📅 Scheduler initialisiert');
+    }
+
+    // ===== CRON SCHEDULING =====
+    
+    schedule(cronExpression, chatId, message, options = {}) {
+        const jobId = options.id || `job_${Date.now()}`;
+        
+        if (!cron.validate(cronExpression)) {
+            throw new Error(`❌ Ungültiger Cron-Ausdruck: ${cronExpression}`);
+        }
+
+        const job = cron.schedule(cronExpression, async () => {
+            try {
+                await this.executeJob(chatId, message, options);
+            } catch (error) {
+                console.error(`❌ Scheduled Job Fehler (${jobId}):`, error);
+            }
+        }, {
+            scheduled: false,
+            timezone: options.timezone || 'Europe/Berlin'
+        });
+
+        // Job speichern
+        const jobData = {
+            id: jobId,
+            type: 'cron',
+            cronExpression,
+            chatId,
+            message,
+            options,
+            createdAt: new Date().toISOString(),
+            active: true
+        };
+
+        this.jobs.set(jobId, { job, data: jobData });
+        this.saveJob(jobData);
+        
+        // Job starten
+        job.start();
+        
+        console.log(`📅 Cron Job erstellt: ${jobId} (${cronExpression})`);
+        return jobId;
+    }
+
+    // ===== ONE-TIME SCHEDULING =====
+    
+    scheduleOnce(date, chatId, message, options = {}) {
+        const jobId = options.id || `once_${Date.now()}`;
+        const targetDate = new Date(date);
+        const now = new Date();
+        
+        if (targetDate <= now) {
+            throw new Error('❌ Datum muss in der Zukunft liegen!');
+        }
+
+        const delay = targetDate - now;
+        
+        const timeout = setTimeout(async () => {
+            try {
+                await this.executeJob(chatId, message, options);
+                this.removeJob(jobId); // Job nach Ausführung entfernen
+            } catch (error) {
+                console.error(`❌ Scheduled Job Fehler (${jobId}):`, error);
+            }
+        }, delay);
+
+        // Job speichern
+        const jobData = {
+            id: jobId,
+            type: 'once',
+            scheduledFor: targetDate.toISOString(),
+            chatId,
+            message,
+            options,
+            createdAt: new Date().toISOString(),
+            active: true
+        };
+
+        this.jobs.set(jobId, { timeout, data: jobData });
+        this.saveJob(jobData);
+        
+        console.log(`📅 One-time Job erstellt: ${jobId} (${targetDate})`);
+        return jobId;
+    }
+
+    // ===== CONVENIENCE METHODS =====
+    
+    daily(time, chatId, message, options = {}) {
+        const [hour, minute] = time.split(':');
+        const cronExpression = `${minute || 0} ${hour} * * *`;
+        return this.schedule(cronExpression, chatId, message, { ...options, type: 'daily' });
+    }
+
+    weekly(day, time, chatId, message, options = {}) {
+        const [hour, minute] = time.split(':');
+        const dayMap = {
+            'monday': 1, 'tuesday': 2, 'wednesday': 3, 'thursday': 4,
+            'friday': 5, 'saturday': 6, 'sunday': 0
+        };
+        const dayNum = dayMap[day.toLowerCase()] ?? day;
+        const cronExpression = `${minute || 0} ${hour} * * ${dayNum}`;
+        return this.schedule(cronExpression, chatId, message, { ...options, type: 'weekly' });
+    }
+
+    monthly(day, time, chatId, message, options = {}) {
+        const [hour, minute] = time.split(':');
+        const cronExpression = `${minute || 0} ${hour} ${day} * *`;
+        return this.schedule(cronExpression, chatId, message, { ...options, type: 'monthly' });
+    }
+
+    // ===== WAITING SYSTEM =====
+    
+    createWaiting() {
+        return {
+            after: {
+                message: (ms) => {
+                    return new Promise(resolve => {
+                        setTimeout(resolve, ms);
+                    });
+                }
+            }
+        };
+    }
+
+    // ===== JOB EXECUTION =====
+    
+    async executeJob(chatId, message, options = {}) {
+        try {
+            // Message kann String oder Function sein
+            let finalMessage = message;
+            
+            if (typeof message === 'function') {
+                finalMessage = await message();
+            }
+            
+            // Template-Variablen ersetzen
+            if (typeof finalMessage === 'string') {
+                finalMessage = this.processTemplate(finalMessage);
+            }
+
+            // Nachricht senden
+            await this.client.socket.sendMessage(chatId, { text: finalMessage });
+            
+            console.log(`📅 Scheduled message sent to ${chatId}: ${finalMessage.substring(0, 50)}...`);
+            
+            // Statistik speichern
+            this.storage.write.in("scheduler-stats").increment("totalExecuted", 1);
+            
+        } catch (error) {
+            console.error('❌ Job Execution Fehler:', error);
+            throw error;
+        }
+    }
+
+    // ===== TEMPLATE PROCESSING =====
+    
+    processTemplate(text) {
+        const now = new Date();
+        
+        return text
+            .replace('{time}', now.toLocaleTimeString('de-DE'))
+            .replace('{date}', now.toLocaleDateString('de-DE'))
+            .replace('{datetime}', now.toLocaleString('de-DE'))
+            .replace('{day}', now.toLocaleDateString('de-DE', { weekday: 'long' }))
+            .replace('{timestamp}', now.getTime());
+    }
+
+    // ===== JOB MANAGEMENT =====
+    
+    removeJob(jobId) {
+        const jobEntry = this.jobs.get(jobId);
+        
+        if (!jobEntry) {
+            return false;
+        }
+
+        // Job stoppen
+        if (jobEntry.job) {
+            jobEntry.job.stop();
+        } else if (jobEntry.timeout) {
+            clearTimeout(jobEntry.timeout);
+        }
+
+        // Aus Memory und Storage entfernen
+        this.jobs.delete(jobId);
+        this.deleteJob(jobId);
+        
+        console.log(`📅 Job entfernt: ${jobId}`);
+        return true;
+    }
+
+    pauseJob(jobId) {
+        const jobEntry = this.jobs.get(jobId);
+        
+        if (jobEntry?.job) {
+            jobEntry.job.stop();
+            jobEntry.data.active = false;
+            this.saveJob(jobEntry.data);
+            return true;
+        }
+        
+        return false;
+    }
+
+    resumeJob(jobId) {
+        const jobEntry = this.jobs.get(jobId);
+        
+        if (jobEntry?.job) {
+            jobEntry.job.start();
+            jobEntry.data.active = true;
+            this.saveJob(jobEntry.data);
+            return true;
+        }
+        
+        return false;
+    }
+
+    // ===== STORAGE METHODS =====
+    
+    saveJob(jobData) {
+        const jobs = this.storage.read.from("scheduled-jobs").all() || [];
+        const existingIndex = jobs.findIndex(job => job.id === jobData.id);
+        
+        if (existingIndex >= 0) {
+            jobs[existingIndex] = jobData;
+        } else {
+            jobs.push(jobData);
+        }
+        
+        this.storage.write.in("scheduled-jobs").data(jobs);
+    }
+
+    deleteJob(jobId) {
+        const jobs = this.storage.read.from("scheduled-jobs").all() || [];
+        const updatedJobs = jobs.filter(job => job.id !== jobId);
+        this.storage.write.in("scheduled-jobs").data(updatedJobs);
+    }
+
+    loadScheduledJobs() {
+        const jobs = this.storage.read.from("scheduled-jobs").all() || [];
+        
+        for (const jobData of jobs) {
+            try {
+                if (jobData.type === 'cron' && jobData.active) {
+                    // Cron Jobs wieder starten
+                    const job = cron.schedule(jobData.cronExpression, async () => {
+                        await this.executeJob(jobData.chatId, jobData.message, jobData.options);
+                    }, {
+                        scheduled: true,
+                        timezone: jobData.options.timezone || 'Europe/Berlin'
+                    });
+                    
+                    this.jobs.set(jobData.id, { job, data: jobData });
+                    console.log(`📅 Cron Job wiederhergestellt: ${jobData.id}`);
+                    
+                } else if (jobData.type === 'once') {
+                    // One-time Jobs prüfen ob noch gültig
+                    const targetDate = new Date(jobData.scheduledFor);
+                    const now = new Date();
+                    
+                    if (targetDate > now) {
+                        const delay = targetDate - now;
+                        const timeout = setTimeout(async () => {
+                            await this.executeJob(jobData.chatId, jobData.message, jobData.options);
+                            this.removeJob(jobData.id);
+                        }, delay);
+                        
+                        this.jobs.set(jobData.id, { timeout, data: jobData });
+                        console.log(`📅 One-time Job wiederhergestellt: ${jobData.id}`);
+                    } else {
+                        // Abgelaufene Jobs entfernen
+                        this.deleteJob(jobData.id);
+                    }
+                }
+            } catch (error) {
+                console.error(`❌ Fehler beim Laden von Job ${jobData.id}:`, error);
+            }
+        }
+    }
+
+    // ===== STATISTICS =====
+    
+    getStats() {
+        const jobs = Array.from(this.jobs.values());
+        const scheduledJobs = this.storage.read.from("scheduled-jobs").all() || [];
+        const stats = this.storage.read.from("scheduler-stats").all() || {};
+        
+        return {
+            activeJobs: jobs.length,
+            totalJobs: scheduledJobs.length,
+            cronJobs: jobs.filter(j => j.data.type === 'cron').length,
+            onceJobs: jobs.filter(j => j.data.type === 'once').length,
+            totalExecuted: stats.totalExecuted || 0,
+            jobs: jobs.map(j => ({
+                id: j.data.id,
+                type: j.data.type,
+                chatId: j.data.chatId,
+                active: j.data.active,
+                createdAt: j.data.createdAt
+            }))
+        };
+    }
+
+    // ===== JOB LISTING =====
+    
+    listJobs() {
+        return Array.from(this.jobs.values()).map(jobEntry => jobEntry.data);
+    }
+}

package/src/storage.js

@@ -0,0 +1,421 @@
+// WAEngine Storage System - Einfaches Daten-Management
+import fs from 'fs';
+import path from 'path';
+
+export class WAStorage {
+    constructor(baseDir = './waengine-data') {
+        this.baseDir = baseDir;
+        this.cache = new Map();
+        this.ensureBaseDir();
+        
+        console.log(`💾 WAStorage initialisiert: ${baseDir}`);
+    }
+
+    // ===== SETUP =====
+    
+    ensureBaseDir() {
+        if (!fs.existsSync(this.baseDir)) {
+            fs.mkdirSync(this.baseDir, { recursive: true });
+            console.log(`📁 Storage Directory erstellt: ${this.baseDir}`);
+        }
+    }
+
+    getFilePath(fileName) {
+        // Automatisch .json hinzufügen falls nicht vorhanden
+        if (!fileName.endsWith('.json')) {
+            fileName += '.json';
+        }
+        return path.join(this.baseDir, fileName);
+    }
+
+    // ===== WRITE SYSTEM =====
+    
+    write = {
+        // write.in("datei") - Schreibt Daten in Datei
+        in: (fileName) => {
+            return {
+                // write.in("datei").data(object)
+                data: (data) => {
+                    return this.writeData(fileName, data);
+                },
+                
+                // write.in("datei").append(object)
+                append: (data) => {
+                    return this.appendData(fileName, data);
+                },
+                
+                // write.in("datei").set(key, value)
+                set: (key, value) => {
+                    return this.setKey(fileName, key, value);
+                },
+                
+                // write.in("datei").push(value) - Für Arrays
+                push: (value) => {
+                    return this.pushToArray(fileName, value);
+                },
+                
+                // write.in("datei").increment(key, amount)
+                increment: (key, amount = 1) => {
+                    return this.incrementKey(fileName, key, amount);
+                }
+            };
+        }
+    };
+
+    // ===== READ SYSTEM =====
+    
+    read = {
+        // read.from("datei")
+        from: (fileName) => {
+            return {
+                // read.from("datei").all()
+                all: () => {
+                    return this.readData(fileName);
+                },
+                
+                // read.from("datei").get(key)
+                get: (key) => {
+                    return this.getKey(fileName, key);
+                },
+                
+                // read.from("datei").keys()
+                keys: () => {
+                    const data = this.readData(fileName);
+                    return data ? Object.keys(data) : [];
+                },
+                
+                // read.from("datei").values()
+                values: () => {
+                    const data = this.readData(fileName);
+                    return data ? Object.values(data) : [];
+                },
+                
+                // read.from("datei").length() - Für Arrays
+                length: () => {
+                    const data = this.readData(fileName);
+                    return Array.isArray(data) ? data.length : 0;
+                },
+                
+                // read.from("datei").exists()
+                exists: () => {
+                    return this.fileExists(fileName);
+                }
+            };
+        }
+    };
+
+    // ===== DELETE SYSTEM =====
+    
+    delete = {
+        // delete.from("datei")
+        from: (fileName) => {
+            return {
+                // delete.from("datei").all()
+                all: () => {
+                    return this.deleteFile(fileName);
+                },
+                
+                // delete.from("datei").key(key)
+                key: (key) => {
+                    return this.deleteKey(fileName, key);
+                },
+                
+                // delete.from("datei").where(condition)
+                where: (condition) => {
+                    return this.deleteWhere(fileName, condition);
+                }
+            };
+        }
+    };
+
+    // ===== CORE METHODS =====
+    
+    writeData(fileName, data) {
+        try {
+            const filePath = this.getFilePath(fileName);
+            fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+            this.cache.set(fileName, data);
+            console.log(`💾 Daten geschrieben: ${fileName}`);
+            return true;
+        } catch (error) {
+            console.error(`❌ Fehler beim Schreiben in ${fileName}:`, error);
+            return false;
+        }
+    }
+
+    readData(fileName) {
+        try {
+            // Cache prüfen
+            if (this.cache.has(fileName)) {
+                return this.cache.get(fileName);
+            }
+            
+            const filePath = this.getFilePath(fileName);
+            
+            if (!fs.existsSync(filePath)) {
+                return null;
+            }
+            
+            const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+            this.cache.set(fileName, data);
+            return data;
+        } catch (error) {
+            console.error(`❌ Fehler beim Lesen von ${fileName}:`, error);
+            return null;
+        }
+    }
+
+    appendData(fileName, newData) {
+        const existingData = this.readData(fileName) || [];
+        
+        if (Array.isArray(existingData)) {
+            existingData.push(newData);
+        } else {
+            // Wenn Object, merge
+            Object.assign(existingData, newData);
+        }
+        
+        return this.writeData(fileName, existingData);
+    }
+
+    setKey(fileName, key, value) {
+        let data = this.readData(fileName) || {};
+        
+        // Nested keys unterstützen (z.B. "user.settings.theme")
+        if (key.includes('.')) {
+            const keys = key.split('.');
+            let current = data;
+            
+            for (let i = 0; i < keys.length - 1; i++) {
+                if (!current[keys[i]]) {
+                    current[keys[i]] = {};
+                }
+                current = current[keys[i]];
+            }
+            
+            current[keys[keys.length - 1]] = value;
+        } else {
+            data[key] = value;
+        }
+        
+        return this.writeData(fileName, data);
+    }
+
+    getKey(fileName, key) {
+        const data = this.readData(fileName);
+        if (!data) return null;
+        
+        // Nested keys unterstützen
+        if (key.includes('.')) {
+            const keys = key.split('.');
+            let current = data;
+            
+            for (const k of keys) {
+                if (current[k] === undefined) {
+                    return null;
+                }
+                current = current[k];
+            }
+            
+            return current;
+        }
+        
+        return data[key];
+    }
+
+    pushToArray(fileName, value) {
+        let data = this.readData(fileName);
+        
+        if (!data) {
+            data = [];
+        } else if (!Array.isArray(data)) {
+            console.error(`❌ ${fileName} ist kein Array!`);
+            return false;
+        }
+        
+        data.push(value);
+        return this.writeData(fileName, data);
+    }
+
+    incrementKey(fileName, key, amount = 1) {
+        const currentValue = this.getKey(fileName, key) || 0;
+        const newValue = currentValue + amount;
+        return this.setKey(fileName, key, newValue);
+    }
+
+    deleteFile(fileName) {
+        try {
+            const filePath = this.getFilePath(fileName);
+            
+            if (fs.existsSync(filePath)) {
+                fs.unlinkSync(filePath);
+                this.cache.delete(fileName);
+                console.log(`🗑️ Datei gelöscht: ${fileName}`);
+                return true;
+            }
+            
+            return false;
+        } catch (error) {
+            console.error(`❌ Fehler beim Löschen von ${fileName}:`, error);
+            return false;
+        }
+    }
+
+    deleteKey(fileName, key) {
+        let data = this.readData(fileName);
+        if (!data) return false;
+        
+        if (key.includes('.')) {
+            // Nested key löschen
+            const keys = key.split('.');
+            let current = data;
+            
+            for (let i = 0; i < keys.length - 1; i++) {
+                if (!current[keys[i]]) {
+                    return false;
+                }
+                current = current[keys[i]];
+            }
+            
+            delete current[keys[keys.length - 1]];
+        } else {
+            delete data[key];
+        }
+        
+        return this.writeData(fileName, data);
+    }
+
+    deleteWhere(fileName, condition) {
+        let data = this.readData(fileName);
+        if (!data) return false;
+        
+        if (Array.isArray(data)) {
+            // Array filtern
+            const originalLength = data.length;
+            data = data.filter(item => !condition(item));
+            
+            if (data.length !== originalLength) {
+                return this.writeData(fileName, data);
+            }
+        } else {
+            // Object filtern
+            let changed = false;
+            
+            for (const [key, value] of Object.entries(data)) {
+                if (condition(value, key)) {
+                    delete data[key];
+                    changed = true;
+                }
+            }
+            
+            if (changed) {
+                return this.writeData(fileName, data);
+            }
+        }
+        
+        return false;
+    }
+
+    fileExists(fileName) {
+        const filePath = this.getFilePath(fileName);
+        return fs.existsSync(filePath);
+    }
+
+    // ===== UTILITY METHODS =====
+    
+    // Alle Dateien auflisten
+    listFiles() {
+        try {
+            const files = fs.readdirSync(this.baseDir);
+            return files.filter(file => file.endsWith('.json')).map(file => file.replace('.json', ''));
+        } catch (error) {
+            console.error('❌ Fehler beim Auflisten der Dateien:', error);
+            return [];
+        }
+    }
+
+    // Cache leeren
+    clearCache() {
+        this.cache.clear();
+        console.log('🧹 Storage Cache geleert');
+    }
+
+    // Backup erstellen
+    backup(backupDir = './waengine-backup') {
+        try {
+            if (!fs.existsSync(backupDir)) {
+                fs.mkdirSync(backupDir, { recursive: true });
+            }
+            
+            const files = fs.readdirSync(this.baseDir);
+            let backedUp = 0;
+            
+            for (const file of files) {
+                const srcPath = path.join(this.baseDir, file);
+                const destPath = path.join(backupDir, file);
+                fs.copyFileSync(srcPath, destPath);
+                backedUp++;
+            }
+            
+            console.log(`💾 Backup erstellt: ${backedUp} Dateien in ${backupDir}`);
+            return backupDir;
+        } catch (error) {
+            console.error('❌ Backup Fehler:', error);
+            return false;
+        }
+    }
+
+    // Storage Statistics
+    getStats() {
+        const files = this.listFiles();
+        let totalSize = 0;
+        
+        for (const file of files) {
+            try {
+                const filePath = this.getFilePath(file);
+                const stats = fs.statSync(filePath);
+                totalSize += stats.size;
+            } catch (error) {
+                // Ignore
+            }
+        }
+        
+        return {
+            totalFiles: files.length,
+            totalSize: totalSize,
+            totalSizeFormatted: this.formatBytes(totalSize),
+            cacheSize: this.cache.size,
+            baseDir: this.baseDir,
+            files: files
+        };
+    }
+
+    formatBytes(bytes) {
+        if (bytes === 0) return '0 Bytes';
+        const k = 1024;
+        const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+    }
+}
+
+// ===== GLOBAL STORAGE INSTANCE =====
+
+let globalStorage = null;
+
+export function createStorage(baseDir) {
+    return new WAStorage(baseDir);
+}
+
+export function getStorage() {
+    if (!globalStorage) {
+        globalStorage = new WAStorage();
+    }
+    return globalStorage;
+}
+
+// ===== SHORTHAND FUNCTIONS =====
+
+export const write = getStorage().write;
+export const read = getStorage().read;
+export const del = getStorage().delete;