jsdecryptor 4.0.3

package/davexcore/games/slot.js

@@ -0,0 +1,21 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function slotCommand(sock, chatId, message) {
+    const fakeContact = createFakeContact(message);
+    const botName = getBotName();
+    const symbols = ['🍒', '🍋', '🍊', '🍇', '💎', '7️⃣', '🔔', '⭐'];
+    
+    const s1 = symbols[Math.floor(Math.random() * symbols.length)];
+    const s2 = symbols[Math.floor(Math.random() * symbols.length)];
+    const s3 = symbols[Math.floor(Math.random() * symbols.length)];
+    
+    let result;
+    if (s1 === s2 && s2 === s3) result = 'JACKPOT! You hit the jackpot!';
+    else if (s1 === s2 || s2 === s3 || s1 === s3) result = 'Nice! Two matching symbols!';
+    else result = 'Better luck next time!';
+    
+    const text = `*${botName} SLOT MACHINE*\n\n┏━━━━━━━━━┓\n┃  ${s1}  ${s2}  ${s3}  ┃\n┗━━━━━━━━━┛\n\n*${result}*`;
+    await sock.sendMessage(chatId, { text }, { quoted: fakeContact });
+}
+
+module.exports = slotCommand;

package/davexcore/games/tictactoe.js

@@ -0,0 +1,263 @@
+const TicTacToe = require('../../davelib/tictactoe');
+
+const games = {};
+const gameTimeouts = {};
+const BOT_JID = 'bot@s.whatsapp.net';
+
+function renderBoard(arr) {
+    const emojiMap = {
+        'X': '❌', 'O': '⭕',
+        '1': '1️⃣', '2': '2️⃣', '3': '3️⃣',
+        '4': '4️⃣', '5': '5️⃣', '6': '6️⃣',
+        '7': '7️⃣', '8': '8️⃣', '9': '9️⃣',
+    };
+    const mapped = arr.map(v => emojiMap[v] || v);
+    return `${mapped.slice(0, 3).join('')}\n${mapped.slice(3, 6).join('')}\n${mapped.slice(6).join('')}`;
+}
+
+function clearGameTimeout(chatId) {
+    if (gameTimeouts[chatId]) {
+        clearTimeout(gameTimeouts[chatId]);
+        delete gameTimeouts[chatId];
+    }
+}
+
+function getPlayerName(jid) {
+    return (jid || '').split(':')[0].split('@')[0];
+}
+
+async function tictactoeCommand(sock, chatId, senderId, text, fake) {
+    try {
+        if (Object.values(games).find(room =>
+            room.id.startsWith('tictactoe') &&
+            [room.game.playerX, room.game.playerO].includes(senderId)
+        )) {
+            await sock.sendMessage(chatId, {
+                text: '❌ You are still in a game. Type *surrender* to quit.'
+            }, { quoted: fake });
+            return;
+        }
+
+        let room = Object.values(games).find(room =>
+            room.state === 'WAITING' && room.chatId === chatId &&
+            (text ? room.name === text : true)
+        );
+
+        if (room) {
+            room.game.playerO = senderId;
+            room.state = 'PLAYING';
+            clearGameTimeout(chatId);
+
+            const arr = room.game.render();
+            const boardStr = renderBoard(arr);
+
+            await sock.sendMessage(chatId, {
+                text: `🎮 *TIC TAC TOE - Game Started!*\n\nPlayer ❌: @${getPlayerName(room.game.playerX)}\nPlayer ⭕: @${getPlayerName(senderId)}\n\nWaiting for @${getPlayerName(room.game.currentTurn)} to play...\n\n${boardStr}\n\n_Type a number (1-9) to place your symbol_\n_Type *surrender* to give up_`,
+                mentions: [room.game.playerX, senderId, room.game.currentTurn]
+            });
+        } else {
+            room = {
+                id: 'tictactoe-' + (+new Date),
+                chatId: chatId,
+                game: new TicTacToe(senderId, 'o'),
+                state: 'WAITING',
+                isAI: false,
+            };
+            if (text) room.name = text;
+
+            await sock.sendMessage(chatId, {
+                text: `🎮 *TIC TAC TOE*\n\n@${getPlayerName(senderId)} wants to play!\n\n*Type "join" within 60 seconds to play!*\n\nPlayer ❌: @${getPlayerName(senderId)}\nPlayer ⭕: Waiting...\n\n${renderBoard(room.game.render())}\n\n_Auto-cancels in 60 seconds if no one joins_`,
+                mentions: [senderId]
+            }, { quoted: fake });
+
+            games[room.id] = room;
+
+            gameTimeouts[chatId] = setTimeout(async () => {
+                const r = Object.values(games).find(g => g.chatId === chatId && g.state === 'WAITING');
+                if (r) {
+                    delete games[r.id];
+                    await sock.sendMessage(chatId, {
+                        text: `⏰ *TIC TAC TOE - TIMEOUT*\n\nNo one joined within 60 seconds.\nGame cancelled!\n\n@${getPlayerName(r.game.playerX)} can start a new game with *.ttt*`,
+                        mentions: [r.game.playerX]
+                    });
+                }
+            }, 60000);
+        }
+    } catch (error) {
+        console.error('Error in tictactoe command:', error);
+        await sock.sendMessage(chatId, { text: '❌ Error starting game. Please try again.' });
+    }
+}
+
+async function tictactoeAICommand(sock, chatId, senderId, fake) {
+    try {
+        if (Object.values(games).find(room =>
+            room.id.startsWith('tictactoe') &&
+            [room.game.playerX, room.game.playerO].includes(senderId)
+        )) {
+            await sock.sendMessage(chatId, {
+                text: '❌ You are still in a game. Type *surrender* to quit.'
+            }, { quoted: fake });
+            return;
+        }
+
+        const room = {
+            id: 'tictactoe-ai-' + (+new Date),
+            chatId: chatId,
+            game: new TicTacToe(senderId, BOT_JID),
+            state: 'PLAYING',
+            isAI: true,
+        };
+
+        games[room.id] = room;
+
+        const arr = room.game.render();
+        await sock.sendMessage(chatId, {
+            text: `🎮 *TIC TAC TOE vs AI* 🤖\n\nPlayer ❌: @${getPlayerName(senderId)}\nPlayer ⭕: DAVE-X Bot 🤖\n\nYour turn! Type a number (1-9)\n\n${renderBoard(arr)}\n\n_Type *surrender* to give up_`,
+            mentions: [senderId]
+        }, { quoted: fake });
+    } catch (error) {
+        console.error('Error in tictactoe AI command:', error);
+        await sock.sendMessage(chatId, { text: '❌ Error starting AI game.' });
+    }
+}
+
+async function handleTicTacToeJoin(sock, chatId, senderId) {
+    const room = Object.values(games).find(room =>
+        room.state === 'WAITING' && room.chatId === chatId &&
+        room.game.playerX !== senderId
+    );
+    if (!room) return false;
+
+    room.game.playerO = senderId;
+    room.state = 'PLAYING';
+    clearGameTimeout(chatId);
+
+    const arr = room.game.render();
+    await sock.sendMessage(chatId, {
+        text: `🎮 *TIC TAC TOE - Game Started!*\n\nPlayer ❌: @${getPlayerName(room.game.playerX)}\nPlayer ⭕: @${getPlayerName(senderId)}\n\nWaiting for @${getPlayerName(room.game.currentTurn)} to play...\n\n${renderBoard(arr)}\n\n_Type a number (1-9) to place your symbol_\n_Type *surrender* to give up_`,
+        mentions: [room.game.playerX, senderId, room.game.currentTurn]
+    });
+    return true;
+}
+
+async function handleTicTacToeMove(sock, chatId, senderId, text) {
+    try {
+        const room = Object.values(games).find(room =>
+            room.id.startsWith('tictactoe') &&
+            [room.game.playerX, room.game.playerO].includes(senderId) &&
+            room.state === 'PLAYING'
+        );
+        if (!room) return false;
+
+        const isSurrender = /^(surrender|give\s?up)$/i.test(text);
+        if (!isSurrender && !/^[1-9]$/.test(text)) return false;
+
+        if (isSurrender) {
+            const winner = senderId === room.game.playerX ? room.game.playerO : room.game.playerX;
+            const winnerLabel = room.isAI && winner === BOT_JID ? 'DAVE-X Bot 🤖' : `@${getPlayerName(winner)}`;
+            await sock.sendMessage(chatId, {
+                text: `🏳️ @${getPlayerName(senderId)} has surrendered! ${winnerLabel} wins!`,
+                mentions: [senderId, winner]
+            });
+            delete games[room.id];
+            return true;
+        }
+
+        if (senderId !== room.game.currentTurn) {
+            await sock.sendMessage(chatId, { text: '❌ Not your turn!' });
+            return true;
+        }
+
+        const isO = senderId === room.game.playerO;
+        const ok = room.game.turn(isO, parseInt(text) - 1);
+        if (!ok) {
+            await sock.sendMessage(chatId, { text: '❌ Invalid move! That position is already taken.' });
+            return true;
+        }
+
+        let winner = room.game.winner;
+        let isTie = room.game.isDraw;
+
+        if (!winner && !isTie && room.isAI && room.game.currentTurn === BOT_JID) {
+            const aiMove = room.game.findBestMove();
+            if (aiMove >= 0) {
+                room.game.turn(true, aiMove);
+                winner = room.game.winner;
+                isTie = room.game.isDraw;
+            }
+        }
+
+        const arr = room.game.render();
+        let gameStatus;
+        if (winner) {
+            if (room.isAI && winner === BOT_JID) {
+                gameStatus = '🤖 DAVE-X Bot wins! Better luck next time!';
+            } else {
+                gameStatus = `🎉 @${getPlayerName(winner)} wins the game!`;
+            }
+        } else if (isTie) {
+            gameStatus = '🤝 Game ended in a draw!';
+        } else {
+            const nextPlayer = room.isAI && room.game.currentTurn === BOT_JID
+                ? 'DAVE-X Bot 🤖' : `@${getPlayerName(room.game.currentTurn)}`;
+            gameStatus = `Turn: ${nextPlayer}`;
+        }
+
+        const p1Label = `@${getPlayerName(room.game.playerX)}`;
+        const p2Label = room.isAI ? 'DAVE-X Bot 🤖' : `@${getPlayerName(room.game.playerO)}`;
+
+        await sock.sendMessage(chatId, {
+            text: `🎮 *TIC TAC TOE${room.isAI ? ' vs AI' : ''}*\n\n${gameStatus}\n\n${renderBoard(arr)}\n\nPlayer ❌: ${p1Label}\nPlayer ⭕: ${p2Label}\n\n${!winner && !isTie ? '_Type a number (1-9) to make your move_\n_Type *surrender* to give up_' : ''}`,
+            mentions: [room.game.playerX, room.game.playerO, ...(winner && winner !== BOT_JID ? [winner] : []), room.game.currentTurn]
+        });
+
+        if (winner || isTie) {
+            delete games[room.id];
+        }
+        return true;
+    } catch (error) {
+        console.error('Error in tictactoe move:', error);
+        return false;
+    }
+}
+
+async function tictactoeEndCommand(sock, chatId, senderId, fake) {
+    const room = Object.values(games).find(room =>
+        room.id.startsWith('tictactoe') &&
+        (room.chatId === chatId) &&
+        (room.game.playerX === senderId || room.game.playerO === senderId || room.state === 'WAITING')
+    );
+    if (!room) {
+        await sock.sendMessage(chatId, { text: '❌ No active TicTacToe game to end!' }, { quoted: fake });
+        return;
+    }
+    clearGameTimeout(chatId);
+    delete games[room.id];
+    await sock.sendMessage(chatId, {
+        text: `🛑 TicTacToe game ended by @${getPlayerName(senderId)}!`,
+        mentions: [senderId]
+    });
+}
+
+function hasTTTGame(chatId) {
+    return !!Object.values(games).find(room =>
+        room.chatId === chatId && room.state === 'PLAYING'
+    );
+}
+
+function hasWaitingTTTGame(chatId) {
+    return !!Object.values(games).find(room =>
+        room.chatId === chatId && room.state === 'WAITING'
+    );
+}
+
+module.exports = {
+    tictactoeCommand,
+    tictactoeAICommand,
+    handleTicTacToeMove,
+    handleTicTacToeJoin,
+    tictactoeEndCommand,
+    hasTTTGame,
+    hasWaitingTTTGame,
+};

package/davexcore/games/trivia.js

@@ -0,0 +1,46 @@
+const axios = require('axios');
+
+let triviaGames = {};
+
+async function startTrivia(sock, chatId) {
+    if (triviaGames[chatId]) {
+        sock.sendMessage(chatId, { text: 'A trivia game is already in progress!' });
+        return;
+    }
+
+    try {
+        const response = await axios.get('https://opentdb.com/api.php?amount=1&type=multiple');
+        const questionData = response.data.results[0];
+
+        triviaGames[chatId] = {
+            question: questionData.question,
+            correctAnswer: questionData.correct_answer,
+            options: [...questionData.incorrect_answers, questionData.correct_answer].sort(),
+        };
+
+        sock.sendMessage(chatId, {
+            text: `Trivia Time!\n\nQuestion: ${triviaGames[chatId].question}\nOptions:\n${triviaGames[chatId].options.join('\n')}`
+        });
+    } catch (error) {
+        sock.sendMessage(chatId, { text: 'Error fetching trivia question. Try again later.' });
+    }
+}
+
+function answerTrivia(sock, chatId, answer) {
+    if (!triviaGames[chatId]) {
+        sock.sendMessage(chatId, { text: 'No trivia game is in progress.' });
+        return;
+    }
+
+    const game = triviaGames[chatId];
+
+    if (answer.toLowerCase() === game.correctAnswer.toLowerCase()) {
+        sock.sendMessage(chatId, { text: `Correct! The answer is ${game.correctAnswer}` });
+    } else {
+        sock.sendMessage(chatId, { text: `Wrong! The correct answer was ${game.correctAnswer}` });
+    }
+
+    delete triviaGames[chatId];
+}
+
+module.exports = { startTrivia, answerTrivia };

package/davexcore/games/wordchain.js

@@ -0,0 +1,242 @@
+const WordChainGame = require('../../davelib/wordchain');
+
+const games = {};
+const gameTimeouts = {};
+const BOT_JID = 'bot@s.whatsapp.net';
+
+function getPlayerName(jid) {
+    return (jid || '').split(':')[0].split('@')[0];
+}
+
+function clearWcgTimeout(chatId) {
+    if (gameTimeouts[chatId]) {
+        clearTimeout(gameTimeouts[chatId]);
+        delete gameTimeouts[chatId];
+    }
+}
+
+async function wcgCommand(sock, chatId, senderId, fake) {
+    try {
+        if (games[chatId]) {
+            await sock.sendMessage(chatId, {
+                text: '❌ There is already a Word Chain game in this chat!\nUse *.wcgend* to end it first.'
+            }, { quoted: fake });
+            return;
+        }
+
+        const game = new WordChainGame(senderId);
+        games[chatId] = game;
+
+        await sock.sendMessage(chatId, {
+            text: `🔤 *WORD CHAIN GAME*\n\n@${getPlayerName(senderId)} started a Word Chain game!\n\n*Type "join" within 60 seconds to play!*\n\nPlayers: 1 (need at least 2)\n\n_Rules:_\n- Each word must start with the last letter of the previous word\n- No repeating words\n- Longer words = more points\n- Host types *.wcgbegin* to start when ready\n\n_Auto-cancels in 60 seconds if not enough players_`,
+            mentions: [senderId]
+        }, { quoted: fake });
+
+        gameTimeouts[chatId] = setTimeout(async () => {
+            if (games[chatId] && games[chatId].state === 'WAITING') {
+                delete games[chatId];
+                await sock.sendMessage(chatId, {
+                    text: '⏰ *WORD CHAIN - TIMEOUT*\n\nNot enough players joined. Game cancelled!'
+                });
+            }
+        }, 60000);
+    } catch (error) {
+        console.error('Error in wcg command:', error);
+        await sock.sendMessage(chatId, { text: '❌ Error starting game.' });
+    }
+}
+
+async function wcgAICommand(sock, chatId, senderId, fake) {
+    try {
+        if (games[chatId]) {
+            await sock.sendMessage(chatId, {
+                text: '❌ There is already a Word Chain game in this chat!\nUse *.wcgend* to end it first.'
+            }, { quoted: fake });
+            return;
+        }
+
+        const game = new WordChainGame(senderId);
+        game.addPlayer(BOT_JID);
+        game.isAI = true;
+        game.start();
+        games[chatId] = game;
+
+        await sock.sendMessage(chatId, {
+            text: `🔤 *WORD CHAIN vs AI* 🤖\n\n@${getPlayerName(senderId)} vs DAVE-X Bot\n\nYou go first! Type any word to start.\n\n_Rules:_\n- Each word must start with the last letter of the previous word\n- No repeating words\n- Longer words = more points`,
+            mentions: [senderId]
+        }, { quoted: fake });
+    } catch (error) {
+        console.error('Error in wcgai command:', error);
+        await sock.sendMessage(chatId, { text: '❌ Error starting AI game.' });
+    }
+}
+
+async function wcgBeginCommand(sock, chatId, senderId, fake) {
+    const game = games[chatId];
+    if (!game) {
+        await sock.sendMessage(chatId, { text: '❌ No Word Chain game to start!' }, { quoted: fake });
+        return;
+    }
+    if (game.host !== senderId) {
+        await sock.sendMessage(chatId, { text: '❌ Only the host can start the game!' }, { quoted: fake });
+        return;
+    }
+    if (!game.start()) {
+        await sock.sendMessage(chatId, { text: '❌ Need at least 2 players to start!' }, { quoted: fake });
+        return;
+    }
+    clearWcgTimeout(chatId);
+
+    const playerList = game.players.map((p, i) => `${i + 1}. @${getPlayerName(p)}`).join('\n');
+    await sock.sendMessage(chatId, {
+        text: `🔤 *WORD CHAIN - Game Started!*\n\nPlayers:\n${playerList}\n\n@${getPlayerName(game.currentPlayer)} goes first! Type any word to start.\n\n_60 seconds per turn or you're eliminated!_`,
+        mentions: game.players
+    });
+
+    setTurnTimeout(sock, chatId);
+}
+
+function setTurnTimeout(sock, chatId) {
+    clearWcgTimeout(chatId);
+    const game = games[chatId];
+    if (!game || game.state !== 'PLAYING') return;
+
+    gameTimeouts[chatId] = setTimeout(async () => {
+        const g = games[chatId];
+        if (!g || g.state !== 'PLAYING') return;
+
+        const eliminated = g.currentPlayer;
+        g.eliminateCurrentPlayer();
+
+        if (g.state === 'ENDED') {
+            const winner = g.winner;
+            await sock.sendMessage(chatId, {
+                text: `⏰ @${getPlayerName(eliminated)} took too long and is eliminated!\n\n🏆 @${getPlayerName(winner)} wins the Word Chain!\n\n*Scores:*\n${g.getScoreboard()}`,
+                mentions: [eliminated, winner]
+            });
+            delete games[chatId];
+        } else {
+            await sock.sendMessage(chatId, {
+                text: `⏰ @${getPlayerName(eliminated)} took too long and is eliminated!\n\n@${getPlayerName(g.currentPlayer)}'s turn!${g.lastWord ? ` Word must start with "${g.lastWord.charAt(g.lastWord.length - 1).toUpperCase()}"` : ''}`,
+                mentions: [eliminated, g.currentPlayer]
+            });
+            setTurnTimeout(sock, chatId);
+        }
+    }, 60000);
+}
+
+async function handleWcgJoin(sock, chatId, senderId) {
+    const game = games[chatId];
+    if (!game || game.state !== 'WAITING') return false;
+    if (game.players.includes(senderId)) return false;
+
+    if (game.addPlayer(senderId)) {
+        await sock.sendMessage(chatId, {
+            text: `🔤 @${getPlayerName(senderId)} joined the Word Chain!\n\nPlayers: ${game.players.length}\nHost can type *.wcgbegin* to start.`,
+            mentions: [senderId]
+        });
+        return true;
+    }
+    return false;
+}
+
+async function handleWcgWord(sock, chatId, senderId, text) {
+    const game = games[chatId];
+    if (!game || game.state !== 'PLAYING') return false;
+    if (!game.players.includes(senderId)) return false;
+
+    const word = text.toLowerCase().trim();
+    if (word.length < 2 || word.includes(' ')) return false;
+
+    const result = game.submitWord(senderId, word);
+    if (!result.ok) {
+        await sock.sendMessage(chatId, {
+            text: `❌ @${getPlayerName(senderId)}: ${result.reason}`,
+            mentions: [senderId]
+        });
+        return true;
+    }
+
+    clearWcgTimeout(chatId);
+
+    if (game.isAI && game.currentPlayer === BOT_JID) {
+        const lastChar = word.charAt(word.length - 1);
+        const aiWord = WordChainGame.findAIWord(lastChar, game.usedWords);
+
+        if (aiWord) {
+            const aiResult = game.submitWord(BOT_JID, aiWord);
+            if (aiResult.ok) {
+                const nextChar = aiWord.charAt(aiWord.length - 1).toUpperCase();
+                await sock.sendMessage(chatId, {
+                    text: `🔤 @${getPlayerName(senderId)}: *${word}* (+${word.length}pts)\n🤖 Bot: *${aiWord}* (+${aiWord.length}pts)\n\nYour turn! Word must start with "${nextChar}"\n\n*Scores:*\n${game.getScoreboard()}`,
+                    mentions: [senderId]
+                });
+                setTurnTimeout(sock, chatId);
+                return true;
+            }
+        }
+
+        game.state = 'ENDED';
+        await sock.sendMessage(chatId, {
+            text: `🔤 @${getPlayerName(senderId)}: *${word}* (+${word.length}pts)\n🤖 Bot can't find a word! You win!\n\n🏆 *Final Scores:*\n${game.getScoreboard()}`,
+            mentions: [senderId]
+        });
+        delete games[chatId];
+        return true;
+    }
+
+    const nextChar = word.charAt(word.length - 1).toUpperCase();
+    await sock.sendMessage(chatId, {
+        text: `🔤 @${getPlayerName(senderId)}: *${word}* (+${word.length}pts)\n\n@${getPlayerName(game.currentPlayer)}'s turn! Word must start with "${nextChar}"\n\n*Scores:*\n${game.getScoreboard()}`,
+        mentions: [senderId, game.currentPlayer]
+    });
+
+    setTurnTimeout(sock, chatId);
+    return true;
+}
+
+async function wcgEndCommand(sock, chatId, senderId, fake) {
+    const game = games[chatId];
+    if (!game) {
+        await sock.sendMessage(chatId, { text: '❌ No Word Chain game to end!' }, { quoted: fake });
+        return;
+    }
+    clearWcgTimeout(chatId);
+    const scores = game.getScoreboard();
+    delete games[chatId];
+    await sock.sendMessage(chatId, {
+        text: `🛑 Word Chain ended by @${getPlayerName(senderId)}!\n\n*Final Scores:*\n${scores || 'No scores yet'}`,
+        mentions: [senderId]
+    });
+}
+
+async function wcgScoresCommand(sock, chatId, fake) {
+    const game = games[chatId];
+    if (!game) {
+        await sock.sendMessage(chatId, { text: '❌ No active Word Chain game!' }, { quoted: fake });
+        return;
+    }
+    await sock.sendMessage(chatId, {
+        text: `🔤 *Word Chain Scores*\n\n${game.getScoreboard()}\n\nWords used: ${game.usedWords.size}\nRounds: ${game.rounds}`,
+    });
+}
+
+function hasWcgGame(chatId) {
+    return !!games[chatId] && games[chatId].state === 'PLAYING';
+}
+
+function hasWaitingWcgGame(chatId) {
+    return !!games[chatId] && games[chatId].state === 'WAITING';
+}
+
+module.exports = {
+    wcgCommand,
+    wcgAICommand,
+    wcgBeginCommand,
+    wcgEndCommand,
+    wcgScoresCommand,
+    handleWcgJoin,
+    handleWcgWord,
+    hasWcgGame,
+    hasWaitingWcgGame,
+};

package/davexcore/group/addmember.js

@@ -0,0 +1,101 @@
+const isAdmin = require('../../davelib/isAdmin');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function addMemberCommand(sock, chatId, message, text) {
+    const senderId = message.key.participant || message.key.remoteJid;
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+
+    try {
+        if (!chatId.endsWith('@g.us')) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nGroup command only!`
+            }, { quoted: fake });
+            return;
+        }
+
+        const adminStatus = await isAdmin(sock, chatId, senderId);
+
+        if (!adminStatus.isBotAdmin) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nBot needs admin!`
+            }, { quoted: fake });
+            return;
+        }
+
+        if (!adminStatus.isSenderAdmin && !message.key.fromMe && !db.isSudo(senderId)) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nAdmin only command!`
+            }, { quoted: fake });
+            return;
+        }
+
+        if (!text || text.trim() === '') {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nUsage: .add 6281234567890\n(Include country code, no + sign)`
+            }, { quoted: fake });
+            return;
+        }
+
+        const phoneNumber = text.replace(/[^0-9]/g, '');
+        if (!phoneNumber) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nInvalid phone number!`
+            }, { quoted: fake });
+            return;
+        }
+
+        const userJid = phoneNumber + '@s.whatsapp.net';
+
+        try {
+            const result = await sock.groupParticipantsUpdate(chatId, [userJid], 'add');
+            
+            if (result && result[0] && result[0].status === 200) {
+                await sock.sendMessage(chatId, { 
+                    text: `*${botName}*\n\n+${phoneNumber} added to the group!`
+                }, { quoted: fake });
+                return;
+            }
+
+            const groupMetadata = await sock.groupMetadata(chatId);
+            const inviteCode = await sock.groupInviteCode(chatId);
+            const inviteLink = `https://chat.whatsapp.com/${inviteCode}`;
+            
+            try {
+                await sock.sendMessage(userJid, {
+                    text: `Hello! You're invited to join:\n\n*${groupMetadata.subject}*\n\n${inviteLink}\n\nInvited by: ${message.pushName || 'Admin'}`
+                });
+                
+                await sock.sendMessage(chatId, {
+                    text: `*${botName}*\n\nInvite sent to +${phoneNumber}`
+                }, { quoted: fake });
+            } catch (inviteError) {
+                await sock.sendMessage(chatId, {
+                    text: `*${botName}*\n\nGroup link:\n${inviteLink}\n\nShare with +${phoneNumber}`
+                }, { quoted: fake });
+            }
+
+        } catch (error) {
+            console.error('Add member error:', error.message, 'Line:', error.stack?.split('\n')[1]);
+            
+            try {
+                const inviteCode = await sock.groupInviteCode(chatId);
+                const inviteLink = `https://chat.whatsapp.com/${inviteCode}`;
+                
+                await sock.sendMessage(chatId, {
+                    text: `*${botName}*\n\nFailed to add. Share this link:\n${inviteLink}`
+                }, { quoted: fake });
+            } catch (linkError) {
+                await sock.sendMessage(chatId, {
+                    text: `*${botName}*\nFailed to add member.`
+                }, { quoted: fake });
+            }
+        }
+
+    } catch (error) {
+        console.error('Error in add command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+module.exports = { addMemberCommand };