jsdecryptor 4.0.3

package/davexcore/owner/setGroupStatus.js

@@ -0,0 +1,315 @@
+const { downloadContentFromMessage } = require('@whiskeysockets/baileys');
+const crypto = require('crypto');
+const ffmpeg = require('fluent-ffmpeg');
+const { PassThrough } = require('stream');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+//================================================
+// Sticker conversion (simple fallback)
+//================================================
+async function convertStickerToImageSimple(stickerBuffer) {
+    if (stickerBuffer.slice(0, 12).toString('hex').includes('52494646')) { // RIFF header
+        console.log('Detected WebP sticker, using fallback conversion');
+        return stickerBuffer; 
+    }
+    return stickerBuffer;
+}
+
+async function convertStickerToImage(stickerBuffer, mimetype = 'image/webp') {
+    try {
+        return await convertStickerToImageSimple(stickerBuffer);
+    } catch (error) {
+        console.error('Sticker conversion failed:', error);
+        throw new Error(`Sticker conversion failed: ${error.message}`);
+    }
+}
+
+// ================================================
+// Main command
+// ================================================
+async function setGroupStatusCommand(sock, chatId, msg) {
+    // Create fake contact for replies
+    const fake = createFakeContact(msg?.key?.participant || chatId);
+    const botName = getBotName();
+    
+    try {
+        // Group check
+        const isGroup = chatId.endsWith('@g.us');
+        if (!isGroup) {
+            return sock.sendMessage(chatId, { 
+                text: `┌─ *${botName}* ─┐\n│\n│ ✦ This magic only works in groups!\n│\n└─────────────┘` 
+            }, { quoted: fake });
+        }
+
+        // Admin check
+        const participant = await sock.groupMetadata(chatId).then(metadata =>
+            metadata.participants.find(p => p.id === msg.key.participant || p.id === msg.key.remoteJid)
+        );
+        const isAdmin = participant && (participant.admin === 'admin' || participant.admin === 'superadmin');
+        
+        if (!isAdmin && !msg.key.fromMe) {
+            return sock.sendMessage(chatId, { 
+                text: `┌─ *${botName}* ─┐\n│\n│ ✦ Sorry, only captains can steer the ship!\n│\n└─────────────┘` 
+            }, { quoted: fake });
+        }
+
+        const messageText = msg.message?.conversation || msg.message?.extendedTextMessage?.text || '';
+        const quotedMessage = msg.message?.extendedTextMessage?.contextInfo?.quotedMessage;
+        const commandRegex = /^[.!#/]?(tosgroup|togstatus|swgc|groupstatus)\s*/i;
+
+        let textAfterCommand = '';
+        if (messageText.trim()) {
+            const match = messageText.match(commandRegex);
+            if (match) textAfterCommand = messageText.slice(match[0].length).trim();
+        }
+
+        if (!quotedMessage && !textAfterCommand) {
+            return sock.sendMessage(chatId, { 
+                text: getHelpText(botName) 
+            }, { quoted: fake });
+        }
+
+        let payload = null;
+
+        if (quotedMessage) {
+            payload = await buildPayloadFromQuoted(quotedMessage);
+            if (textAfterCommand && payload) {
+                if (payload.video || payload.image || (payload.convertedSticker && payload.image)) {
+                    payload.caption = textAfterCommand;
+                }
+            }
+        } else if (textAfterCommand) {
+            payload = { text: textAfterCommand };
+        }
+
+        if (!payload) {
+            return sock.sendMessage(chatId, { 
+                text: getHelpText(botName) 
+            }, { quoted: fake });
+        }
+
+        // Send group status
+        await sendGroupStatus(sock, chatId, payload);
+
+        // Sweet response variations
+        const mediaType = detectMediaType(quotedMessage, payload);
+        const successMessages = [
+            `┌─ *${botName}* ─┐\n│\n│ ✦ Status broadcasted! (${mediaType})`,
+            `┌─ *${botName}* ─┐\n│\n│ ✦ Your story is live! (${mediaType})`,
+            `┌─ *${botName}* ─┐\n│\n│ ✦ Everyone can see it now! (${mediaType})`,
+            `┌─ *${botName}* ─┐\n│\n│ ✦ Magic posted to group! (${mediaType})`,
+            `┌─ *${botName}* ─┐\n│\n│ ✦ Update shared with the crew! (${mediaType})`,
+            `┌─ *${botName}* ─┐\n│\n│ ✦ Status update successful! (${mediaType})`
+        ];
+        
+        let successMsg = successMessages[Math.floor(Math.random() * successMessages.length)];
+        
+        if (payload.caption) {
+            const captionMessages = [
+                `\n│ 📝 With message: "${payload.caption}"`,
+                `\n│ 📝 Caption: ${payload.caption}`,
+                `\n│ 📝 Says: ${payload.caption}`
+            ];
+            successMsg = successMsg.replace('─┐', '─┐') + captionMessages[Math.floor(Math.random() * captionMessages.length)];
+        }
+        
+        if (payload.convertedSticker) {
+            const stickerMessages = [
+                `\n│ ✨ Sticker magically transformed!`,
+                `\n│ ✨ Sticker → Image conversion complete`,
+                `\n│ ✨ Your sticker is now a picture!`
+            ];
+            successMsg = successMsg.replace('─┐', '─┐') + stickerMessages[Math.floor(Math.random() * stickerMessages.length)];
+        }
+        
+        successMsg += `\n│\n└─────────────┘`;
+        successMsg = successMsg.replace('─┐\n│\n│', '─┐');
+
+        await sock.sendMessage(chatId, { 
+            text: successMsg 
+        }, { quoted: fake });
+
+    } catch (error) {
+        console.error('Error in group status command:', error);
+        
+        // Sweet error variations
+        const errorMessages = [
+            `┌─ *${botName}* ─┐\n│\n│ ✦ Oops! Magic fizzled: ${error.message}\n│\n└─────────────┘`,
+            `┌─ *${botName}* ─┐\n│\n│ ✦ Spell failed: ${error.message}\n│\n└─────────────┘`,
+            `┌─ *${botName}* ─┐\n│\n│ ✦ Something went wrong: ${error.message}\n│\n└─────────────┘`,
+            `┌─ *${botName}* ─┐\n│\n│ ✦ Couldn't cast that spell: ${error.message}\n│\n└─────────────┘`
+        ];
+        
+        await sock.sendMessage(chatId, { 
+            text: errorMessages[Math.floor(Math.random() * errorMessages.length)]
+        }, { quoted: fake });
+    }
+}
+
+/* ------------------ Helpers ------------------ */
+
+// Magical help text
+function getHelpText(botName) {
+    const helpVariations = [
+        `┌─ *${botName}* ─┐
+│
+│ ✦ Cast your spell:
+│ • .tosgroup your message
+│ • Reply to media + .tosgroup
+│ • Reply to sticker (auto converts)
+│
+│ ✦ Works with:
+│ Images · Videos · Audio · Stickers
+│
+│ ✦ Example:
+│ Reply to a photo with .tosgroup Hello!
+│
+└────────────────────┘`,
+
+        `┌─ *${botName}* ─┐
+│
+│ ✦ Share your magic:
+│ • Text status: .tosgroup <text>
+│ • Media status: Reply + .tosgroup
+│ • Stickers become images automatically
+│
+│ ✦ Supported:
+│ 🖼️ Image · 🎬 Video · 🎧 Audio · 📦 Sticker
+│
+│ ✦ Try:
+│ Reply to a video with .tosgroup
+│
+└────────────────────┘`,
+
+        `┌─ *${botName}* ─┐
+│
+│ ✦ Group Story Magic:
+│ • Type .tosgroup + your words
+│ • Reply to any image/video/audio
+│ • Stickers transform into images
+│
+│ ✦ Compatible with:
+│ All media types welcome!
+│
+│ ✦ Example:
+│ .tosgroup Good morning everyone!
+│
+└────────────────────┘`
+    ];
+    
+    return helpVariations[Math.floor(Math.random() * helpVariations.length)];
+}
+
+// Build payload from quoted message
+async function buildPayloadFromQuoted(quotedMessage) {
+    if (quotedMessage.videoMessage) {
+        const buffer = await downloadToBuffer(quotedMessage.videoMessage, 'video');
+        return { 
+            video: buffer, 
+            caption: quotedMessage.videoMessage.caption || '',
+            gifPlayback: quotedMessage.videoMessage.gifPlayback || false,
+            mimetype: quotedMessage.videoMessage.mimetype || 'video/mp4'
+        };
+    } else if (quotedMessage.imageMessage) {
+        const buffer = await downloadToBuffer(quotedMessage.imageMessage, 'image');
+        return { 
+            image: buffer, 
+            caption: quotedMessage.imageMessage.caption || '',
+            mimetype: quotedMessage.imageMessage.mimetype || 'image/jpeg'
+        };
+    } else if (quotedMessage.audioMessage) {
+        const buffer = await downloadToBuffer(quotedMessage.audioMessage, 'audio');
+        if (quotedMessage.audioMessage.ptt) {
+            const audioVn = await toVN(buffer);
+            return { audio: audioVn, mimetype: "audio/ogg; codecs=opus", ptt: true };
+        } else {
+            return { audio: buffer, mimetype: quotedMessage.audioMessage.mimetype || 'audio/mpeg', ptt: false };
+        }
+    } else if (quotedMessage.stickerMessage) {
+        try {
+            const buffer = await downloadToBuffer(quotedMessage.stickerMessage, 'sticker');
+            const imageBuffer = await convertStickerToImage(buffer, quotedMessage.stickerMessage.mimetype);
+            return { 
+                image: imageBuffer, 
+                caption: quotedMessage.stickerMessage.caption || '',
+                mimetype: 'image/png',
+                convertedSticker: true,
+                originalMimetype: quotedMessage.stickerMessage.mimetype
+            };
+        } catch (conversionError) {
+            console.error('Sticker conversion failed:', conversionError);
+            
+            const errorMsgs = [
+                `✦ Couldn't transform that sticker (${quotedMessage.stickerMessage.mimetype || 'unknown'})`,
+                `✦ Sticker resisted the magic (${quotedMessage.stickerMessage.mimetype || 'unknown'})`,
+                `✦ Unsupported sticker format (${quotedMessage.stickerMessage.mimetype || 'unknown'})`
+            ];
+            return { text: errorMsgs[Math.floor(Math.random() * errorMsgs.length)] };
+        }
+    } else if (quotedMessage.conversation || quotedMessage.extendedTextMessage?.text) {
+        const textContent = quotedMessage.conversation || quotedMessage.extendedTextMessage?.text || '';
+        return { text: textContent };
+    }
+    return null;
+}
+
+// Detect media type
+function detectMediaType(quotedMessage, payload = null) {
+    if (!quotedMessage) return 'Text';
+    if (quotedMessage.videoMessage) return 'Video';
+    if (quotedMessage.imageMessage) return 'Image';
+    if (quotedMessage.audioMessage) return 'Audio';
+    if (quotedMessage.stickerMessage) {
+        if (payload && payload.convertedSticker) return 'Sticker ✦ Image';
+        return 'Sticker';
+    }
+    return 'Text';
+}
+
+// Download message content
+async function downloadToBuffer(message, type) {
+    const stream = await downloadContentFromMessage(message, type);
+    let buffer = Buffer.from([]);
+    for await (const chunk of stream) buffer = Buffer.concat([buffer, chunk]);
+    return buffer;
+}
+
+// Send group status
+async function sendGroupStatus(conn, jid, content) {
+    const { generateWAMessageContent, generateWAMessageFromContent } = require('@whiskeysockets/baileys');
+    
+    const inside = await generateWAMessageContent(content, { upload: conn.waUploadToServer });
+    const messageSecret = crypto.randomBytes(32);
+    const m = generateWAMessageFromContent(jid, {
+        messageContextInfo: { messageSecret },
+        groupStatusMessageV2: { message: { ...inside, messageContextInfo: { messageSecret } } }
+    }, {});
+    
+    await conn.relayMessage(jid, m.message, { messageId: m.key.id });
+    return m;
+}
+
+// Convert audio to voice note
+async function toVN(inputBuffer) {
+    return new Promise((resolve, reject) => {
+        const inStream = new PassThrough();
+        inStream.end(inputBuffer);
+        const outStream = new PassThrough();
+        const chunks = [];
+        
+        ffmpeg(inStream)
+            .noVideo()
+            .audioCodec("libopus")
+            .format("ogg")
+            .audioBitrate("48k")
+            .audioChannels(1)
+            .audioFrequency(48000)
+            .on("error", reject)
+            .on("end", () => resolve(Buffer.concat(chunks)))
+            .pipe(outStream, { end: true });
+            
+        outStream.on("data", chunk => chunks.push(chunk));
+    });
+}
+
+module.exports = setGroupStatusCommand;

package/davexcore/owner/setbotconfig.js

@@ -0,0 +1,306 @@
+const { getBotName, setBotName, getMenuImage, setMenuImage, getConfig, updateConfig } = require('../../davelib/botConfig');
+const { createFakeContact } = require('../../davelib/fakeContact');
+const { downloadContentFromMessage } = require('@whiskeysockets/baileys');
+const fs = require('fs');
+const path = require('path');
+
+async function setbotconfigCommand(sock, chatId, message) {
+    try {
+        const senderId = message.key.participant || message.key.remoteJid;
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+
+        if (!message.key.fromMe) {
+            await sock.sendMessage(chatId, { 
+                text: `┌─ *${botName}* ─┐\n│\n│ ✦ This magic is only for the owner!\n│\n└─────────────┘` 
+            }, { quoted: fake });
+            return;
+        }
+
+        const text = message.message?.conversation || message.message?.extendedTextMessage?.text || '';
+        const args = text.trim().split(' ').slice(1);
+        const action = args[0]?.toLowerCase();
+
+        if (!action) {
+            const config = getConfig();
+            const usage = `┌─ *${botName} CONFIG* ─┐
+│
+│ ✦ Current Settings:
+│ • Bot Name: ${config.botName}
+│ • Menu Image: ${config.menuImage ? '✓ Set' : '✗ Not set'}
+│ • Antidelete Private: ${config.antideletePrivate ? '✓ ON' : '✗ OFF'}
+│
+│ ✦ Available Spells:
+│ • .setbotname <name> - Change bot's name
+│ • .setmenuimage - Set menu image (reply to image)
+│ • .botconfig get - View full configuration
+│
+│ ✦ Example:
+│ .setbotname MyAwesomeBot
+│
+└────────────────────┘`;
+            await sock.sendMessage(chatId, { text: usage }, { quoted: fake });
+            return;
+        }
+
+        if (action === 'get') {
+            const config = getConfig();
+            const statusText = `┌─ *${botName} CONFIG* ─┐
+│
+│ ✦ Current Configuration:
+│ • Bot Name: ${config.botName}
+│ • Owner Name: ${config.ownerName || 'Not set'}
+│ • Menu Image: ${config.menuImage ? '✓ Set' : '✗ Not set'}
+│ • Antidelete Private: ${config.antideletePrivate ? '✓ ON' : '✗ OFF'}
+│
+└────────────────────┘`;
+            await sock.sendMessage(chatId, { text: statusText }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Error in setbotconfig command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        await sock.sendMessage(chatId, { 
+            text: `┌─ *${botName}* ─┐\n│\n│ ✦ Oops! Magic fizzled: ${error.message}\n│\n└─────────────┘` 
+        }, { quoted: fake });
+    }
+}
+
+async function setbotnameCommand(sock, chatId, message, fullArgs) {
+    try {
+        const senderId = message.key.participant || message.key.remoteJid;
+        const fake = createFakeContact(senderId);
+        const currentBotName = getBotName();
+
+        if (!message.key.fromMe) {
+            await sock.sendMessage(chatId, { 
+                text: `┌─ *${currentBotName}* ─┐\n│\n│ ✦ Only the captain can rename the ship!\n│\n└─────────────┘` 
+            }, { quoted: fake });
+            return;
+        }
+
+        // Use fullArgs from command parser (handles prefix+space correctly)
+        // Fallback: parse raw text but skip the command word itself
+        let name = (fullArgs || '').trim();
+        if (!name) {
+            const text = message.message?.conversation || message.message?.extendedTextMessage?.text || '';
+            const parts = text.trim().split(/\s+/);
+            // Skip prefix+command (first token), rest is the name
+            name = parts.slice(1).join(' ').trim();
+        }
+
+        if (!name) {
+            await sock.sendMessage(chatId, { 
+                text: `┌─ *${currentBotName}* ─┐
+│
+│ ✦ What shall we name the bot?
+│
+│ ✦ Usage:
+│ .setbotname YourBotName
+│
+│ ✦ Example:
+│ .setbotname MagicBot
+│
+└────────────────────┘` 
+            }, { quoted: fake });
+            return;
+        }
+
+        setBotName(name);
+        
+        const successMessages = [
+            `┌─ *✨ NAME CHANGED* ─┐
+│
+│ ✦ The bot shall now be known as:
+│ • *${name}*
+│
+│ ✦ A new identity, a new adventure!
+│
+└────────────────────┘`,
+            
+            `┌─ *✨ TRANSFORMATION* ─┐
+│
+│ ✦ Old name fades away...
+│ ✦ New name rises: *${name}*
+│
+│ ✦ The bot has been reborn!
+│
+└────────────────────┘`,
+            
+            `┌─ *✨ RENAMED* ─┐
+│
+│ ✦ The magic now flows through:
+│ • *${name}*
+│
+│ ✦ Great choice, captain!
+│
+└────────────────────┘`
+        ];
+        
+        await sock.sendMessage(chatId, { 
+            text: successMessages[Math.floor(Math.random() * successMessages.length)] 
+        }, { quoted: fake });
+        
+    } catch (error) {
+        console.error('Error in setbotname command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        await sock.sendMessage(chatId, { 
+            text: `┌─ *${currentBotName}* ─┐\n│\n│ ✦ Name change spell failed: ${error.message}\n│\n└─────────────┘` 
+        }, { quoted: fake });
+    }
+}
+
+async function setmenuimageCommand(sock, chatId, message) {
+    try {
+        const senderId = message.key.participant || message.key.remoteJid;
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+
+        if (!message.key.fromMe) {
+            await sock.sendMessage(chatId, { 
+                text: `┌─ *${botName}* ─┐\n│\n│ ✦ Only the owner can change the menu image!\n│\n└─────────────┘` 
+            }, { quoted: fake });
+            return;
+        }
+
+        const quotedMessage = message.message?.extendedTextMessage?.contextInfo?.quotedMessage;
+        const text = message.message?.conversation || message.message?.extendedTextMessage?.text || '';
+        const args = text.split(' ').slice(1).join(' ').trim();
+
+        if (args && (args.startsWith('http://') || args.startsWith('https://'))) {
+            setMenuImage(args);
+            
+            const urlSuccessMessages = [
+                `┌─ *✨ MENU IMAGE* ─┐
+│
+│ ✦ Image URL captured!
+│ ✦ Menu will now wear new clothes
+│
+│ ✦ URL: ${args.substring(0, 30)}...
+│
+└────────────────────┘`,
+                
+                `┌─ *✨ IMAGE SET* ─┐
+│
+│ ✦ Menu image URL has been stored
+│ ✦ Beauty from the web, now yours
+│
+│ ✦ The menu has been adorned!
+│
+└────────────────────┘`
+            ];
+            
+            await sock.sendMessage(chatId, { 
+                text: urlSuccessMessages[Math.floor(Math.random() * urlSuccessMessages.length)] 
+            }, { quoted: fake });
+            return;
+        }
+
+        const hasImage = !!quotedMessage?.imageMessage;
+        const hasVideo = !!quotedMessage?.videoMessage;
+
+        if (!hasImage && !hasVideo) {
+            await sock.sendMessage(chatId, { 
+                text: `┌─ *${botName}* ─┐
+│
+│ ✦ What image shall grace the menu?
+│
+│ ✦ Ways to cast this spell:
+│ • Reply to an image with .setmenuimage
+│ • Reply to a video with .setmenuimage
+│ • .setmenuimage https://example.com/image.jpg
+│
+│ ✦ Example:
+│ (Reply to a photo or video) .setmenuimage
+│
+└────────────────────┘` 
+            }, { quoted: fake });
+            return;
+        }
+
+        try {
+            // Show typing indicator while processing
+            await sock.sendPresenceUpdate('composing', chatId);
+            
+            const assetsDir = path.join(__dirname, '..', 'assets');
+            if (!fs.existsSync(assetsDir)) {
+                fs.mkdirSync(assetsDir, { recursive: true });
+            }
+
+            if (hasVideo) {
+                // Handle video: download and save as menu video (used with style 7)
+                const stream = await downloadContentFromMessage(quotedMessage.videoMessage, 'video');
+                let buffer = Buffer.from([]);
+                for await (const chunk of stream) {
+                    buffer = Buffer.concat([buffer, chunk]);
+                }
+                const videoPath = path.join(assetsDir, 'menuvideo.mp4');
+                fs.writeFileSync(videoPath, buffer);
+                // Also save as GIF path reference for compatibility
+                const { setMenuVideo } = require('../../davelib/botConfig');
+                setMenuVideo(videoPath);
+                await sock.sendMessage(chatId, { 
+                    text: `┌─ *✨ VIDEO CAPTURED* ─┐\n│\n│ ✦ Menu video has been set!\n│ ✦ Use style 7 to display it\n│\n│ ✦ Stored at: assets/menuvideo.mp4\n│\n└────────────────────┘`
+                }, { quoted: fake });
+                return;
+            }
+
+            const stream = await downloadContentFromMessage(quotedMessage.imageMessage, 'image');
+            let buffer = Buffer.from([]);
+            for await (const chunk of stream) {
+                buffer = Buffer.concat([buffer, chunk]);
+            }
+
+            const imagePath = path.join(assetsDir, 'menuimage.jpg');
+            fs.writeFileSync(imagePath, buffer);
+
+            setMenuImage(imagePath);
+            
+            const successMessages = [
+                `┌─ *✨ IMAGE CAPTURED* ─┐
+│
+│ ✦ Menu image has been updated!
+│ ✦ Your bot looks more fabulous than ever
+│
+│ ✦ Magic stored at: assets/menuimage.jpg
+│
+└────────────────────┘`,
+                
+                `┌─ *✨ VISUAL UPGRADE* ─┐
+│
+│ ✦ New menu image locked in!
+│ ✦ Beauty has been added to the bot
+│
+│ ✦ The menu has been enchanted!
+│
+└────────────────────┘`,
+                
+                `┌─ *✨ IMAGE SET* ─┐
+│
+│ ✦ Your chosen image now graces the menu
+│ ✦ Every .menu command will show it
+│
+│ ✦ Perfect choice, captain!
+│
+└────────────────────┘`
+            ];
+            
+            await sock.sendMessage(chatId, { 
+                text: successMessages[Math.floor(Math.random() * successMessages.length)] 
+            }, { quoted: fake });
+            
+        } catch (downloadError) {
+            await sock.sendMessage(chatId, { 
+                text: `┌─ *${botName}* ─┐\n│\n│ ✦ Failed to download image: ${downloadError.message}\n│\n└─────────────┘` 
+            }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Error in setmenuimage command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        await sock.sendMessage(chatId, { 
+            text: `┌─ *${botName}* ─┐\n│\n│ ✦ Image spell failed: ${error.message}\n│\n└─────────────┘` 
+        }, { quoted: fake });
+    }
+}
+
+module.exports = {
+    setbotconfigCommand,
+    setbotnameCommand,
+    setmenuimageCommand
+};

package/davexcore/owner/setfont.js

@@ -0,0 +1,79 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+const { getBotFont, setBotFont } = require('../../davelib/botConfig');
+const { FONT_STYLES, applyBotFont, getStyleList } = require('../../davelib/fontStyles');
+
+async function setfontCommand(sock, chatId, message, args, fullArgs) {
+    const senderId = message.key.participant || message.key.remoteJid;
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+
+    if (!message.key.fromMe) {
+        await sock.sendMessage(chatId, {
+            text: `*${botName}*\n❌ Only the bot owner can change the font style.`
+        }, { quoted: fake });
+        return;
+    }
+
+    const sub = (args[0] || '').toLowerCase().trim();
+
+    // Show font list
+    if (!sub || sub === 'list' || sub === 'styles' || sub === 'help') {
+        const currentFont = getBotFont();
+        const styles = getStyleList();
+        let text = `*${botName} — FONT STYLES*\n\n`;
+        text += `Current style: *${FONT_STYLES[currentFont]?.name || 'Default'}*\n\n`;
+        text += `*Available Styles:*\n`;
+        text += `━━━━━━━━━━━━━━━━━━━━\n`;
+        for (const s of styles) {
+            const isCurrent = s.key === currentFont;
+            text += `${isCurrent ? '✅' : '▸'} *${s.key}*\n`;
+            text += `   ${s.name} — ${s.description}\n`;
+            text += `   Preview: ${s.preview}\n`;
+        }
+        text += `━━━━━━━━━━━━━━━━━━━━\n`;
+        text += `\nUsage: .setfont <style>\n`;
+        text += `Example: .setfont sans_bold\n`;
+        text += `Reset: .setfont none`;
+        await sock.sendMessage(chatId, { text }, { quoted: fake });
+        return;
+    }
+
+    // Preview a specific style
+    if (sub === 'preview' && args[1]) {
+        const styleName = args[1].toLowerCase();
+        if (!FONT_STYLES[styleName]) {
+            await sock.sendMessage(chatId, {
+                text: `*${botName}*\n❌ Unknown style: "${styleName}"\nUse .setfont list to see all styles.`
+            }, { quoted: fake });
+            return;
+        }
+        const style = FONT_STYLES[styleName];
+        const sampleText = `This is a preview of ${style.name} style.\nThe bot would respond like this!`;
+        const converted = applyBotFont(sampleText, styleName);
+        await sock.sendMessage(chatId, {
+            text: `*${botName} — PREVIEW: ${style.name}*\n\n${converted}\n\nSet it with: .setfont ${styleName}`
+        }, { quoted: fake });
+        return;
+    }
+
+    // Set a style
+    const styleName = sub;
+    if (!FONT_STYLES[styleName]) {
+        await sock.sendMessage(chatId, {
+            text: `*${botName}*\n❌ Unknown style: "${styleName}"\n\nUse .setfont list to see all available styles.`
+        }, { quoted: fake });
+        return;
+    }
+
+    setBotFont(styleName);
+    const style = FONT_STYLES[styleName];
+    const confirmText = styleName === 'none'
+        ? `✅ Font style reset to default.`
+        : `✅ Font style set to *${style.name}*!\n\nPreview: ${style.preview}\n\nAll bot responses will now use this style.`;
+
+    await sock.sendMessage(chatId, {
+        text: `*${botName}*\n${confirmText}`
+    }, { quoted: fake });
+}
+
+module.exports = setfontCommand;