waengine 2.3.8 → 2.3.10

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
+- **Interactive Carousel** - REAL swipeable carousel in ONE message 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.10",
   "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,45 +237,109 @@ export class AdvancedMessage {
 
     async sendCarouselMessage(cards) {
         try {
-            // WhatsApp Carousel ist experimentell
+            // REAL WhatsApp Interactive Carousel - ONE message with swipeable cards!
             const carouselMessage = {
                 interactiveMessage: {
+                    header: {
+                        title: 'Carousel',
+                        hasMediaAttachment: false
+                    },
+                    body: {
+                        text: 'Swipe to see all options'
+                    },
                     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 || []
+                        cards: cards.map((card, index) => {
+                            const carouselCard = {
+                                body: {
+                                    text: card.body || ''
+                                },
+                                footer: {
+                                    text: card.footer || `${index + 1}/${cards.length}`
+                                },
+                                nativeFlowMessage: {
+                                    buttons: []
+                                }
+                            };
+                            
+                            // Add header with media (video or image)
+                            if (card.video) {
+                                carouselCard.header = {
+                                    title: card.title,
+                                    subtitle: card.subtitle || '',
+                                    hasMediaAttachment: true,
+                                    videoMessage: {
+                                        url: card.video,
+                                        gifPlayback: card.gifPlayback || false
+                                    }
+                                };
+                            } else if (card.image) {
+                                carouselCard.header = {
+                                    title: card.title,
+                                    subtitle: card.subtitle || '',
+                                    hasMediaAttachment: true,
+                                    imageMessage: {
+                                        url: card.image
+                                    }
+                                };
+                            } else {
+                                carouselCard.header = {
+                                    title: card.title,
+                                    subtitle: card.subtitle || '',
+                                    hasMediaAttachment: false
+                                };
                             }
-                        }))
+                            
+                            // Add buttons
+                            if (card.buttons && card.buttons.length > 0) {
+                                carouselCard.nativeFlowMessage.buttons = card.buttons.map(btn => ({
+                                    name: 'quick_reply',
+                                    buttonParamsJson: JSON.stringify({
+                                        display_text: btn.text || btn.title,
+                                        id: btn.id || `btn_${index}`
+                                    })
+                                }));
+                            }
+                            
+                            return carouselCard;
+                        })
                     }
                 }
             };
-
+            
             return await this.socket.sendMessage(this.msg.from, carouselMessage);
+            
         } catch (error) {
-            console.error('❌ Carousel Message fehlgeschlagen:', error);
-            // Fallback: Sende Cards einzeln
-            const results = [];
-            for (const card of cards) {
-                try {
-                    let cardText = `🎴 **${card.title}**\n`;
-                    if (card.subtitle) cardText += `${card.subtitle}\n\n`;
-                    cardText += card.body;
-                    if (card.footer) cardText += `\n\n_${card.footer}_`;
-                    
-                    const result = await this.msg.reply(cardText);
-                    results.push(result);
-                } catch (cardError) {
-                    console.error('❌ Card fehlgeschlagen:', cardError);
-                }
+            console.error('❌ Interactive Carousel fehlgeschlagen:', error);
+            
+            // Fallback: List Message (closest to carousel)
+            try {
+                const listMessage = {
+                    text: 'Select an option',
+                    footer: `${cards.length} options available`,
+                    title: 'Carousel',
+                    buttonText: 'View Options',
+                    sections: [{
+                        title: 'All Options',
+                        rows: cards.map((card, i) => ({
+                            title: card.title,
+                            description: card.body || card.subtitle || '',
+                            rowId: `carousel_${i}`
+                        }))
+                    }]
+                };
+                
+                return await this.socket.sendMessage(this.msg.from, listMessage);
+                
+            } catch (listError) {
+                console.error('❌ List fallback fehlgeschlagen:', listError);
+                
+                // Final fallback: Text
+                const fallbackText = cards.map((card, i) => 
+                    `${i + 1}. **${card.title}**\n${card.body || ''}`
+                ).join('\n\n');
+                
+                return await this.msg.reply(fallbackText);
             }
-            return results;
         }
     }
 }

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

@@ -6,54 +6,173 @@ export class UIComponents {
     // ===== CAROUSEL MESSAGES =====
     
     /**
-     * Send carousel message with multiple cards
+     * Send REAL carousel message with swipeable cards in ONE message
+     * Uses WhatsApp Interactive Message API
      */
     async sendCarousel(chatId, cards, options = {}) {
         try {
-            // WhatsApp doesn't support native carousels, so we create a rich text alternative
-            let carouselText = `🎠 **${options.title || 'Carousel'}**\n\n`;
-            
-            cards.forEach((card, index) => {
-                carouselText += `**${index + 1}. ${card.title}**\n`;
-                if (card.subtitle) carouselText += `${card.subtitle}\n`;
-                if (card.body) carouselText += `${card.body}\n`;
-                if (card.price) carouselText += `💰 ${card.price}\n`;
-                
-                // Add buttons as text options
-                if (card.buttons && card.buttons.length > 0) {
-                    carouselText += `Options: `;
-                    card.buttons.forEach((btn, btnIndex) => {
-                        carouselText += `[${btnIndex + 1}] ${btn.title} `;
-                    });
-                    carouselText += `\n`;
+            // Build proper WhatsApp Interactive Carousel Message
+            const carouselMessage = {
+                interactiveMessage: {
+                    header: {
+                        title: options.title || 'Carousel',
+                        hasMediaAttachment: false
+                    },
+                    body: {
+                        text: options.body || 'Swipe to see all options'
+                    },
+                    footer: {
+                        text: options.footer || ''
+                    },
+                    carouselMessage: {
+                        cards: cards.map((card, index) => {
+                            const carouselCard = {
+                                body: {
+                                    text: card.body || card.description || ''
+                                },
+                                footer: {
+                                    text: card.footer || `${index + 1}/${cards.length}`
+                                },
+                                nativeFlowMessage: {
+                                    buttons: []
+                                }
+                            };
+                            
+                            // Add header with media
+                            if (card.video) {
+                                carouselCard.header = {
+                                    title: card.title,
+                                    subtitle: card.subtitle || '',
+                                    hasMediaAttachment: true,
+                                    videoMessage: {
+                                        url: card.video,
+                                        gifPlayback: card.gifPlayback || false
+                                    }
+                                };
+                            } else if (card.image) {
+                                carouselCard.header = {
+                                    title: card.title,
+                                    subtitle: card.subtitle || '',
+                                    hasMediaAttachment: true,
+                                    imageMessage: {
+                                        url: card.image
+                                    }
+                                };
+                            } else {
+                                carouselCard.header = {
+                                    title: card.title,
+                                    subtitle: card.subtitle || '',
+                                    hasMediaAttachment: false
+                                };
+                            }
+                            
+                            // Add buttons
+                            if (card.buttons && card.buttons.length > 0) {
+                                carouselCard.nativeFlowMessage.buttons = card.buttons.map(btn => ({
+                                    name: 'quick_reply',
+                                    buttonParamsJson: JSON.stringify({
+                                        display_text: btn.title || btn.text,
+                                        id: btn.id || `btn_${index}_${btn.title}`
+                                    })
+                                }));
+                            }
+                            
+                            return carouselCard;
+                        })
+                    }
                 }
-                
-                carouselText += `\n`;
-            });
-            
-            if (options.footer) {
-                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 the carousel
+            const result = await this.client.socket.sendMessage(chatId, carouselMessage);
             
-            return { success: true, type: 'carousel', cards: cards.length };
+            return { 
+                success: true, 
+                type: 'interactive_carousel', 
+                cards: cards.length,
+                messageId: result.key.id,
+                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) {
-            // Fallback to simple text
-            const fallbackText = `📋 **${options.title || 'Options'}**\n\n` +
-                cards.map((card, i) => `${i + 1}. ${card.title}`).join('\n');
+            console.error('❌ Interactive Carousel failed, trying fallback:', error);
             
-            await this.client.socket.sendMessage(chatId, { text: fallbackText });
-            return { success: true, type: 'fallback', cards: cards.length };
+            // Fallback 1: Try native carousel format
+            try {
+                const nativeCarousel = {
+                    viewOnceMessage: {
+                        message: {
+                            messageContextInfo: {
+                                deviceListMetadata: {},
+                                deviceListMetadataVersion: 2
+                            },
+                            interactiveMessage: {
+                                nativeFlowMessage: {
+                                    buttons: cards.map((card, i) => ({
+                                        name: 'single_select',
+                                        buttonParamsJson: JSON.stringify({
+                                            title: card.title,
+                                            sections: [{
+                                                title: card.subtitle || '',
+                                                rows: [{
+                                                    title: card.title,
+                                                    description: card.body,
+                                                    id: `card_${i}`
+                                                }]
+                                            }]
+                                        })
+                                    }))
+                                }
+                            }
+                        }
+                    }
+                };
+                
+                const result = await this.client.socket.sendMessage(chatId, nativeCarousel);
+                return { success: true, type: 'native_carousel', cards: cards.length };
+                
+            } catch (nativeError) {
+                console.error('❌ Native carousel also failed, using list fallback:', nativeError);
+                
+                // Fallback 2: Use List Message (closest to carousel)
+                try {
+                    const listMessage = {
+                        text: options.title || 'Select an option',
+                        footer: options.footer || `${cards.length} options available`,
+                        title: options.title || 'Carousel',
+                        buttonText: 'View Options',
+                        sections: [{
+                            title: 'All Options',
+                            rows: cards.map((card, i) => ({
+                                title: card.title,
+                                description: card.body || card.subtitle || '',
+                                rowId: `carousel_${i}`
+                            }))
+                        }]
+                    };
+                    
+                    const result = await this.client.socket.sendMessage(chatId, listMessage);
+                    return { success: true, type: 'list_fallback', cards: cards.length };
+                    
+                } catch (listError) {
+                    console.error('❌ List fallback failed, using text:', listError);
+                    
+                    // Fallback 3: Simple text with emojis
+                    const fallbackText = `🎠 **${options.title || 'Carousel'}**\n\n` +
+                        cards.map((card, i) => 
+                            `${i + 1}️⃣ **${card.title}**\n` +
+                            `${card.subtitle ? `   ${card.subtitle}\n` : ''}` +
+                            `   ${card.body || ''}\n`
+                        ).join('\n');
+                    
+                    await this.client.socket.sendMessage(chatId, { text: fallbackText });
+                    return { success: true, type: 'text_fallback', cards: cards.length };
+                }
+            }
         }
     }