waengine 2.3.8 → 2.3.9

package/README.md

@@ -100,7 +100,7 @@ client.on('truly_connected', (data) => {
 - **Button Messages** - Interactive buttons with callbacks
 - **List Messages** - Organized lists with sections
 - **Template Messages** - Reusable message templates
-- **Carousel Messages** - Swipeable card carousels
+- **Carousel Messages** - Swipeable card carousels with VIDEO support! 🎬
 
 ### 👥 **Advanced Group Features**
 - **Group Settings** - Control who can send messages

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waengine",
-  "version": "2.3.8",
+  "version": "2.3.9",
   "description": "🚀 WAEngine - The most powerful WhatsApp Bot Library with 860+ Working Features, Complete Baileys Integration & Production-Ready Stability",
   "main": "src/index.js",
   "type": "module",

package/src/advanced-features.js

@@ -237,30 +237,58 @@ export class AdvancedMessage {
 
     async sendCarouselMessage(cards) {
         try {
-            // WhatsApp Carousel ist experimentell
-            const carouselMessage = {
-                interactiveMessage: {
-                    carouselMessage: {
-                        cards: cards.map(card => ({
-                            header: {
-                                title: card.title,
-                                subtitle: card.subtitle,
-                                imageMessage: card.image ? { url: card.image } : undefined
-                            },
-                            body: { text: card.body },
-                            footer: { text: card.footer || "" },
-                            nativeFlowMessage: {
-                                buttons: card.buttons || []
-                            }
-                        }))
-                    }
+            // WhatsApp Carousel mit Video & Image Support
+            const results = [];
+            
+            for (let i = 0; i < cards.length; i++) {
+                const card = cards[i];
+                
+                // Build card text
+                let cardText = `🎴 **${i + 1}/${cards.length}: ${card.title}**\n`;
+                if (card.subtitle) cardText += `${card.subtitle}\n\n`;
+                if (card.body) cardText += `${card.body}`;
+                if (card.footer) cardText += `\n\n_${card.footer}_`;
+                
+                // Add buttons as text
+                if (card.buttons && card.buttons.length > 0) {
+                    cardText += `\n\n**Options:**\n`;
+                    card.buttons.forEach((btn, btnIndex) => {
+                        cardText += `${btnIndex + 1}. ${btn.text || btn.title}\n`;
+                    });
                 }
-            };
-
-            return await this.socket.sendMessage(this.msg.from, carouselMessage);
+                
+                // Send with appropriate media type
+                let result;
+                if (card.video) {
+                    // Video card
+                    result = await this.socket.sendMessage(this.msg.from, {
+                        video: { url: card.video },
+                        caption: cardText,
+                        gifPlayback: card.gifPlayback || false
+                    });
+                } else if (card.image) {
+                    // Image card
+                    result = await this.socket.sendMessage(this.msg.from, {
+                        image: { url: card.image },
+                        caption: cardText
+                    });
+                } else {
+                    // Text-only card
+                    result = await this.msg.reply(cardText);
+                }
+                
+                results.push(result);
+                
+                // Small delay between cards
+                if (i < cards.length - 1) {
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                }
+            }
+            
+            return results;
         } catch (error) {
             console.error('❌ Carousel Message fehlgeschlagen:', error);
-            // Fallback: Sende Cards einzeln
+            // Fallback: Sende Cards als Text
             const results = [];
             for (const card of cards) {
                 try {

package/src/console-renderer.js

@@ -0,0 +1,282 @@
+// ===== CONSOLE RENDERER - Schöne Console Outputs mit Prefix & Farben =====
+
+// ANSI Color Codes
+const colors = {
+    // Basic Colors
+    black: '\x1b[30m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    
+    // Bright Colors
+    brightBlack: '\x1b[90m',
+    brightRed: '\x1b[91m',
+    brightGreen: '\x1b[92m',
+    brightYellow: '\x1b[93m',
+    brightBlue: '\x1b[94m',
+    brightMagenta: '\x1b[95m',
+    brightCyan: '\x1b[96m',
+    brightWhite: '\x1b[97m',
+    
+    // Background Colors
+    bgBlack: '\x1b[40m',
+    bgRed: '\x1b[41m',
+    bgGreen: '\x1b[42m',
+    bgYellow: '\x1b[43m',
+    bgBlue: '\x1b[44m',
+    bgMagenta: '\x1b[45m',
+    bgCyan: '\x1b[46m',
+    bgWhite: '\x1b[47m',
+    
+    // Styles
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    italic: '\x1b[3m',
+    underline: '\x1b[4m',
+    blink: '\x1b[5m',
+    reverse: '\x1b[7m',
+    hidden: '\x1b[8m',
+    
+    // Reset
+    reset: '\x1b[0m'
+};
+
+// Global Config
+let globalConfig = {
+    prefix: null,
+    prefixColor: 'cyan',
+    defaultColor: 'white',
+    errorColor: 'red',
+    warnColor: 'yellow',
+    infoColor: 'blue',
+    successColor: 'green',
+    enabled: true
+};
+
+// Original console methods
+const originalConsole = {
+    log: console.log,
+    error: console.error,
+    warn: console.warn,
+    info: console.info
+};
+
+// Helper: Get color code
+function getColor(colorName) {
+    return colors[colorName] || colors.white;
+}
+
+// Helper: Format prefix
+function formatPrefix(prefix, color) {
+    if (!prefix) return '';
+    const colorCode = getColor(color);
+    return `${colorCode}[${prefix}]${colors.reset} `;
+}
+
+// Helper: Apply color to text
+function colorize(text, color) {
+    const colorCode = getColor(color);
+    return `${colorCode}${text}${colors.reset}`;
+}
+
+// Patch console.log
+console.log = function(...args) {
+    if (!globalConfig.enabled) {
+        return originalConsole.log(...args);
+    }
+    
+    const prefix = formatPrefix(globalConfig.prefix, globalConfig.prefixColor);
+    const colorCode = getColor(globalConfig.defaultColor);
+    
+    if (prefix) {
+        originalConsole.log(prefix + colorCode, ...args, colors.reset);
+    } else {
+        originalConsole.log(colorCode, ...args, colors.reset);
+    }
+};
+
+// Patch console.error
+console.error = function(...args) {
+    if (!globalConfig.enabled) {
+        return originalConsole.error(...args);
+    }
+    
+    const prefix = formatPrefix(globalConfig.prefix, globalConfig.prefixColor);
+    const colorCode = getColor(globalConfig.errorColor);
+    
+    if (prefix) {
+        originalConsole.error(prefix + colorCode, ...args, colors.reset);
+    } else {
+        originalConsole.error(colorCode, ...args, colors.reset);
+    }
+};
+
+// Patch console.warn
+console.warn = function(...args) {
+    if (!globalConfig.enabled) {
+        return originalConsole.warn(...args);
+    }
+    
+    const prefix = formatPrefix(globalConfig.prefix, globalConfig.prefixColor);
+    const colorCode = getColor(globalConfig.warnColor);
+    
+    if (prefix) {
+        originalConsole.warn(prefix + colorCode, ...args, colors.reset);
+    } else {
+        originalConsole.warn(colorCode, ...args, colors.reset);
+    }
+};
+
+// Patch console.info
+console.info = function(...args) {
+    if (!globalConfig.enabled) {
+        return originalConsole.info(...args);
+    }
+    
+    const prefix = formatPrefix(globalConfig.prefix, globalConfig.prefixColor);
+    const colorCode = getColor(globalConfig.infoColor);
+    
+    if (prefix) {
+        originalConsole.info(prefix + colorCode, ...args, colors.reset);
+    } else {
+        originalConsole.info(colorCode, ...args, colors.reset);
+    }
+};
+
+// ===== PUBLIC API =====
+
+export const render = {
+    // Set prefix name
+    consolePrefix(name) {
+        globalConfig.prefix = name;
+        console.log(`✅ Console Prefix gesetzt: [${name}]`);
+    },
+    
+    // Set prefix color
+    consolePrefixColor(color) {
+        if (!colors[color]) {
+            console.warn(`⚠️ Unbekannte Farbe: ${color}`);
+            return;
+        }
+        globalConfig.prefixColor = color;
+        console.log(`🎨 Prefix Farbe gesetzt: ${color}`);
+    },
+    
+    // Set default console.log color
+    consoleColor(color) {
+        if (!colors[color]) {
+            console.warn(`⚠️ Unbekannte Farbe: ${color}`);
+            return;
+        }
+        globalConfig.defaultColor = color;
+        console.log(`🎨 Console Farbe gesetzt: ${color}`);
+    },
+    
+    // Set console.error color
+    consoleError(color) {
+        if (!colors[color]) {
+            console.warn(`⚠️ Unbekannte Farbe: ${color}`);
+            return;
+        }
+        globalConfig.errorColor = color;
+        console.log(`🎨 Error Farbe gesetzt: ${color}`);
+    },
+    
+    // Set console.warn color
+    consoleWarn(color) {
+        if (!colors[color]) {
+            console.warn(`⚠️ Unbekannte Farbe: ${color}`);
+            return;
+        }
+        globalConfig.warnColor = color;
+        console.log(`🎨 Warn Farbe gesetzt: ${color}`);
+    },
+    
+    // Set console.info color
+    consoleInfo(color) {
+        if (!colors[color]) {
+            console.warn(`⚠️ Unbekannte Farbe: ${color}`);
+            return;
+        }
+        globalConfig.infoColor = color;
+        console.log(`🎨 Info Farbe gesetzt: ${color}`);
+    },
+    
+    // Enable/Disable rendering
+    enable() {
+        globalConfig.enabled = true;
+        console.log('✅ Console Rendering aktiviert');
+    },
+    
+    disable() {
+        globalConfig.enabled = false;
+        originalConsole.log('⚠️ Console Rendering deaktiviert');
+    },
+    
+    // Reset to defaults
+    reset() {
+        globalConfig = {
+            prefix: null,
+            prefixColor: 'cyan',
+            defaultColor: 'white',
+            errorColor: 'red',
+            warnColor: 'yellow',
+            infoColor: 'blue',
+            successColor: 'green',
+            enabled: true
+        };
+        console.log('🔄 Console Rendering zurückgesetzt');
+    },
+    
+    // Get current config
+    getConfig() {
+        return { ...globalConfig };
+    },
+    
+    // Custom colored output
+    print(text, color = 'white') {
+        const prefix = formatPrefix(globalConfig.prefix, globalConfig.prefixColor);
+        const colored = colorize(text, color);
+        originalConsole.log(prefix + colored);
+    },
+    
+    // Success message
+    success(text) {
+        const prefix = formatPrefix(globalConfig.prefix, globalConfig.prefixColor);
+        const colored = colorize(text, globalConfig.successColor);
+        originalConsole.log(prefix + colored);
+    },
+    
+    // Available colors
+    colors: Object.keys(colors).filter(c => c !== 'reset'),
+    
+    // Show color palette
+    showColors() {
+        originalConsole.log('\n🎨 Verfügbare Farben:\n');
+        
+        const colorList = Object.keys(colors).filter(c => c !== 'reset');
+        
+        colorList.forEach(colorName => {
+            const sample = `${colors[colorName]}${colorName}${colors.reset}`;
+            originalConsole.log(`  ${sample}`);
+        });
+        
+        originalConsole.log('');
+    }
+};
+
+// Export colors for direct use
+export { colors };
+
+// Auto-initialize message
+if (globalConfig.enabled) {
+    originalConsole.log(
+        `${colors.brightCyan}╔════════════════════════════════════════╗${colors.reset}\n` +
+        `${colors.brightCyan}║  🎨 Console Renderer aktiviert!       ║${colors.reset}\n` +
+        `${colors.brightCyan}╚════════════════════════════════════════╝${colors.reset}`
+    );
+}

package/src/http-advanced.js

@@ -0,0 +1,299 @@
+// ===== ADVANCED HTTP CLIENT - Axios-Style für WAEngine =====
+// Wie curl, aber besser! 🚀
+
+import axios from 'axios';
+
+export class HTTP {
+    constructor(config = {}) {
+        this.config = {
+            timeout: config.timeout || 30000,
+            retries: config.retries || 3,
+            headers: config.headers || {},
+            baseURL: config.baseURL || '',
+            ...config
+        };
+        
+        // Axios Instance
+        this.client = axios.create(this.config);
+        
+        // Request/Response Interceptors
+        this.setupInterceptors();
+    }
+    
+    setupInterceptors() {
+        // Request Interceptor
+        this.client.interceptors.request.use(
+            (config) => {
+                console.log(`🌐 ${config.method.toUpperCase()} ${config.url}`);
+                return config;
+            },
+            (error) => Promise.reject(error)
+        );
+        
+        // Response Interceptor
+        this.client.interceptors.response.use(
+            (response) => {
+                console.log(`✅ ${response.status} ${response.config.url}`);
+                return response;
+            },
+            (error) => {
+                console.error(`❌ ${error.response?.status || 'ERROR'} ${error.config?.url}`);
+                return Promise.reject(error);
+            }
+        );
+    }
+    
+    // ===== BASIC METHODS (Axios-Style) =====
+    
+    async get(url, config = {}) {
+        try {
+            const response = await this.client.get(url, config);
+            return response.data;
+        } catch (error) {
+            throw this.handleError(error);
+        }
+    }
+    
+    async post(url, data = {}, config = {}) {
+        try {
+            const response = await this.client.post(url, data, config);
+            return response.data;
+        } catch (error) {
+            throw this.handleError(error);
+        }
+    }
+    
+    async put(url, data = {}, config = {}) {
+        try {
+            const response = await this.client.put(url, data, config);
+            return response.data;
+        } catch (error) {
+            throw this.handleError(error);
+        }
+    }
+    
+    async patch(url, data = {}, config = {}) {
+        try {
+            const response = await this.client.patch(url, data, config);
+            return response.data;
+        } catch (error) {
+            throw this.handleError(error);
+        }
+    }
+    
+    async delete(url, config = {}) {
+        try {
+            const response = await this.client.delete(url, config);
+            return response.data;
+        } catch (error) {
+            throw this.handleError(error);
+        }
+    }
+    
+    async head(url, config = {}) {
+        try {
+            const response = await this.client.head(url, config);
+            return response.headers;
+        } catch (error) {
+            throw this.handleError(error);
+        }
+    }
+    
+    async options(url, config = {}) {
+        try {
+            const response = await this.client.options(url, config);
+            return response.data;
+        } catch (error) {
+            throw this.handleError(error);
+        }
+    }
+    
+    // ===== CURL-STYLE REQUEST =====
+    
+    async curl(options) {
+        /*
+        Curl-Style Request:
+        
+        await http.curl({
+            url: 'https://api.example.com/data',
+            method: 'POST',
+            headers: { 'Authorization': 'Bearer token' },
+            data: { key: 'value' },
+            params: { page: 1 },
+            timeout: 5000
+        });
+        */
+        
+        try {
+            const response = await this.client(options);
+            return response.data;
+        } catch (error) {
+            throw this.handleError(error);
+        }
+    }
+    
+    // ===== ADVANCED FEATURES =====
+    
+    // Download File
+    async download(url, savePath) {
+        try {
+            const response = await this.client.get(url, {
+                responseType: 'arraybuffer'
+            });
+            
+            const fs = await import('fs');
+            await fs.promises.writeFile(savePath, response.data);
+            
+            return {
+                success: true,
+                path: savePath,
+                size: response.data.length,
+                contentType: response.headers['content-type']
+            };
+        } catch (error) {
+            throw this.handleError(error);
+        }
+    }
+    
+    // Upload File
+    async upload(url, filePath, fieldName = 'file') {
+        try {
+            const fs = await import('fs');
+            const FormData = (await import('form-data')).default;
+            
+            const form = new FormData();
+            form.append(fieldName, fs.createReadStream(filePath));
+            
+            const response = await this.client.post(url, form, {
+                headers: form.getHeaders()
+            });
+            
+            return response.data;
+        } catch (error) {
+            throw this.handleError(error);
+        }
+    }
+    
+    // JSON Request
+    async json(url, data = null, method = 'GET') {
+        const config = {
+            headers: {
+                'Content-Type': 'application/json',
+                'Accept': 'application/json'
+            }
+        };
+        
+        if (method === 'GET') {
+            return await this.get(url, config);
+        } else {
+            return await this.post(url, data, config);
+        }
+    }
+    
+    // Form Data Request
+    async form(url, data = {}) {
+        const FormData = (await import('form-data')).default;
+        const form = new FormData();
+        
+        for (const [key, value] of Object.entries(data)) {
+            form.append(key, value);
+        }
+        
+        return await this.post(url, form, {
+            headers: form.getHeaders()
+        });
+    }
+    
+    // Parallel Requests
+    async all(requests) {
+        try {
+            const promises = requests.map(req => {
+                if (typeof req === 'string') {
+                    return this.get(req);
+                } else {
+                    return this.curl(req);
+                }
+            });
+            
+            return await Promise.all(promises);
+        } catch (error) {
+            throw this.handleError(error);
+        }
+    }
+    
+    // Retry Request
+    async retry(fn, retries = 3, delay = 1000) {
+        for (let i = 0; i < retries; i++) {
+            try {
+                return await fn();
+            } catch (error) {
+                if (i === retries - 1) throw error;
+                console.log(`🔄 Retry ${i + 1}/${retries}...`);
+                await this.sleep(delay * (i + 1));
+            }
+        }
+    }
+    
+    // Stream Response
+    async stream(url, onData, onEnd) {
+        try {
+            const response = await this.client.get(url, {
+                responseType: 'stream'
+            });
+            
+            response.data.on('data', onData);
+            response.data.on('end', onEnd);
+            
+            return response.data;
+        } catch (error) {
+            throw this.handleError(error);
+        }
+    }
+    
+    // ===== HELPER METHODS =====
+    
+    handleError(error) {
+        if (error.response) {
+            // Server responded with error
+            return new Error(`HTTP ${error.response.status}: ${error.response.statusText}`);
+        } else if (error.request) {
+            // No response received
+            return new Error('No response from server');
+        } else {
+            // Request setup error
+            return new Error(error.message);
+        }
+    }
+    
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    
+    // Set Default Headers
+    setHeader(key, value) {
+        this.client.defaults.headers.common[key] = value;
+    }
+    
+    // Set Authorization
+    setAuth(token, type = 'Bearer') {
+        this.setHeader('Authorization', `${type} ${token}`);
+    }
+    
+    // Set Base URL
+    setBaseURL(url) {
+        this.client.defaults.baseURL = url;
+    }
+}
+
+// ===== GLOBAL HTTP INSTANCE =====
+export const http = new HTTP();
+
+// ===== QUICK METHODS =====
+export const get = (url, config) => http.get(url, config);
+export const post = (url, data, config) => http.post(url, data, config);
+export const put = (url, data, config) => http.put(url, data, config);
+export const patch = (url, data, config) => http.patch(url, data, config);
+export const del = (url, config) => http.delete(url, config);
+export const curl = (options) => http.curl(options);
+export const download = (url, path) => http.download(url, path);
+export const upload = (url, file, field) => http.upload(url, file, field);

package/src/index.js

@@ -15,6 +15,9 @@ export { Message } from "./message.js";
 export { ConsoleLogger, logger } from "./console-logger.js";
 export { ErrorHandler, defaultErrorHandler } from "./error-handler.js";
 
+// ===== CONSOLE RENDERER - NEU! =====
+export { render, colors } from "./console-renderer.js";
+
 // ===== ULTRA-ROBUSTE RECOVERY SYSTEME - NEU v2.0.0! =====
 export { ConnectionRecovery } from "./connection-recovery.js";
 export { AuthRecovery } from "./auth-recovery.js";

package/src/message.js

@@ -727,6 +727,100 @@ export class Message {
         }
     }
 
+    // ===== MESSAGE DEL - Lösche beliebige Message (Admin erforderlich in Gruppen) =====
+    async MessageDel(messageId, participantJid = null) {
+        try {
+            // Wenn keine Parameter, lösche die aktuelle Message
+            if (!messageId) {
+                return await this.deleteMessage();
+            }
+            
+            // Prüfe in Gruppen ob Bot Admin ist
+            if (this.isGroup) {
+                const isBotAdmin = await this.isGroupAdmin(this.client.socket.user.id);
+                if (!isBotAdmin) {
+                    console.log('⚠️ Bot ist kein Admin - kann nur eigene Messages löschen');
+                    return {
+                        success: false,
+                        reason: 'not_admin',
+                        error: 'Bot muss Admin sein um Messages von anderen zu löschen'
+                    };
+                }
+            }
+            
+            // Bot JID ermitteln
+            const botJid = this.client.socket.user?.id;
+            const botNumber = botJid?.split('@')[0]?.split(':')[0];
+            
+            // Prüfe ob Message vom Bot ist
+            let isFromBot = false;
+            if (participantJid) {
+                const participantNumber = participantJid?.split('@')[0]?.split(':')[0];
+                isFromBot = botNumber === participantNumber;
+            }
+            
+            // Erstelle Message Key
+            const messageKey = {
+                remoteJid: this.from,
+                id: messageId,
+                fromMe: isFromBot
+            };
+            
+            // In Gruppen: participant hinzufügen wenn nicht vom Bot
+            if (this.isGroup && participantJid && !isFromBot) {
+                messageKey.participant = participantJid;
+            }
+            
+            console.log('🗑️ MessageDel - Lösche Message:', {
+                messageId: messageId,
+                participant: participantJid,
+                isFromBot: isFromBot,
+                isGroup: this.isGroup,
+                key: messageKey
+            });
+            
+            // Sende Delete Request
+            const result = await this.client.socket.sendMessage(this.from, {
+                delete: messageKey
+            });
+            
+            console.log('✅ MessageDel erfolgreich:', result);
+            return {
+                success: true,
+                messageId: messageId,
+                participant: participantJid,
+                wasFromBot: isFromBot,
+                result: result
+            };
+            
+        } catch (error) {
+            console.error('❌ MessageDel Fehler:', error.message);
+            
+            // Spezifische Fehlerbehandlung
+            if (error.message?.includes('not-found') || error.message?.includes('404')) {
+                return {
+                    success: false,
+                    reason: 'message_not_found',
+                    error: 'Message nicht gefunden oder zu alt'
+                };
+            }
+            
+            if (error.message?.includes('forbidden') || error.message?.includes('403')) {
+                return {
+                    success: false,
+                    reason: 'no_permission',
+                    error: 'Keine Berechtigung - Bot muss Admin sein'
+                };
+            }
+            
+            return {
+                success: false,
+                reason: 'unknown_error',
+                error: error.message
+            };
+        }
+    }
+
     // ===== MEDIA DOWNLOAD - NEU in v1.7.9! =====
     
     async downloadMedia(options = {}) {

package/src/ui-components.js

@@ -7,10 +7,11 @@ export class UIComponents {
     
     /**
      * Send carousel message with multiple cards
+     * Supports: images, videos, and text-only cards
      */
     async sendCarousel(chatId, cards, options = {}) {
         try {
-            // WhatsApp doesn't support native carousels, so we create a rich text alternative
+            // WhatsApp doesn't support native carousels, so we create a rich media alternative
             let carouselText = `🎠 **${options.title || 'Carousel'}**\n\n`;
             
             cards.forEach((card, index) => {
@@ -35,19 +36,68 @@ export class UIComponents {
                 carouselText += `\n_${options.footer}_`;
             }
             
-            // Send with image if provided
-            if (cards[0]?.image) {
-                await this.client.socket.sendMessage(chatId, {
-                    image: { url: cards[0].image },
-                    caption: carouselText
-                });
-            } else {
-                await this.client.socket.sendMessage(chatId, { text: carouselText });
+            // Send each card with its media (image or video)
+            for (let i = 0; i < cards.length; i++) {
+                const card = cards[i];
+                
+                // Build card text
+                let cardText = `**${i + 1}/${cards.length}: ${card.title}**\n`;
+                if (card.subtitle) cardText += `${card.subtitle}\n`;
+                if (card.body) cardText += `${card.body}\n`;
+                if (card.price) cardText += `💰 ${card.price}\n`;
+                
+                if (card.buttons && card.buttons.length > 0) {
+                    cardText += `\nOptions: `;
+                    card.buttons.forEach((btn, btnIndex) => {
+                        cardText += `[${btnIndex + 1}] ${btn.title} `;
+                    });
+                }
+                
+                if (options.footer) {
+                    cardText += `\n\n_${options.footer}_`;
+                }
+                
+                // Send with appropriate media type
+                if (card.video) {
+                    // Video card
+                    await this.client.socket.sendMessage(chatId, {
+                        video: { url: card.video },
+                        caption: cardText,
+                        gifPlayback: card.gifPlayback || false
+                    });
+                } else if (card.image) {
+                    // Image card
+                    await this.client.socket.sendMessage(chatId, {
+                        image: { url: card.image },
+                        caption: cardText
+                    });
+                } else {
+                    // Text-only card
+                    await this.client.socket.sendMessage(chatId, { 
+                        text: cardText 
+                    });
+                }
+                
+                // Small delay between cards to prevent spam
+                if (i < cards.length - 1) {
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                }
             }
             
-            return { success: true, type: 'carousel', cards: cards.length };
+            return { 
+                success: true, 
+                type: 'carousel', 
+                cards: cards.length,
+                mediaTypes: {
+                    videos: cards.filter(c => c.video).length,
+                    images: cards.filter(c => c.image).length,
+                    text: cards.filter(c => !c.video && !c.image).length
+                }
+            };
             
         } catch (error) {
+            console.error('❌ Carousel error:', error);
+            
             // Fallback to simple text
             const fallbackText = `📋 **${options.title || 'Options'}**\n\n` +
                 cards.map((card, i) => `${i + 1}. ${card.title}`).join('\n');