jsdecryptor 4.0.3

package/davexcore/anti/antigroupmention.js

@@ -0,0 +1,206 @@
+const { getGroupConfig, setGroupConfig, deleteGroupToggle } = require('../../Database/settingsStore');
+const isAdmin = require('../../davelib/isAdmin');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+const { getPrefix } = require('../owner/setprefix');
+
+async function handleAntiStatusMention(sock, m) {
+    try {
+        if (!m?.message) return;
+        if (m.key.fromMe) return;
+        
+        const chatId = m.key.remoteJid;
+        if (!chatId?.endsWith('@g.us')) return;
+
+        const config = getGroupConfig(chatId, 'antigroupmention');
+        if (!config || !config.enabled) return;
+
+        const mode = config.action || 'delete';
+        if (mode === 'off') return;
+
+        const isGroupStatusMention = m.message?.groupStatusMentionMessage;
+        
+        if (!isGroupStatusMention) {
+            const isForwarded = m.message?.extendedTextMessage?.contextInfo?.isForwarded;
+            const forwardingScore = m.message?.extendedTextMessage?.contextInfo?.forwardingScore || 0;
+            
+            if (!isForwarded && forwardingScore === 0) return;
+            
+            let text = m.message?.extendedTextMessage?.text || m.message?.conversation || '';
+            const groupIdPart = chatId.split('@')[0];
+            if (!text.includes(groupIdPart)) return;
+        }
+
+        const sender = m.key.participant || m.key.remoteJid;
+        const botName = getBotName();
+        
+        const adminStatus = await isAdmin(sock, chatId, sender);
+        const isSenderAdmin = adminStatus.isSenderAdmin;
+        const isBotAdmin = adminStatus.isBotAdmin;
+
+        if (isSenderAdmin || db.isSudo(sender)) {
+            return;
+        }
+
+        if (!isBotAdmin) {
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐\n│\n│ Cannot delete - need admin!\n│\n└─────────────┘`,
+            });
+            return;
+        }
+
+        await sock.sendMessage(chatId, {
+            delete: {
+                remoteJid: chatId,
+                fromMe: false,
+                id: m.key.id,
+                participant: sender,
+            },
+        });
+
+        const userTag = `@${sender.split('@')[0]}`;
+
+        if (mode === 'delete') {
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐
+│
+│ ${userTag}
+│ Status mention deleted!
+│ Don't mention this group
+│
+└─────────────┘`,
+                mentions: [sender],
+            });
+        } else if (mode === 'kick' || mode === 'remove') {
+            try {
+                await sock.groupParticipantsUpdate(chatId, [sender], 'remove');
+                await sock.sendMessage(chatId, {
+                    text: `┌─ *${botName}* ─┐
+│
+│ ${userTag}
+│ Kicked for status mention!
+│
+└─────────────┘`,
+                    mentions: [sender],
+                });
+            } catch (err) {
+                console.error('Failed to remove user:', err.message, 'Line:', err.stack?.split('\n')[1]);
+            }
+        }
+    } catch (err) {
+        console.error('Error in handleAntiStatusMention:', err.message, 'Line:', err.stack?.split('\n')[1]);
+    }
+}
+
+async function antigroupmentionCommand(sock, chatId, message, senderId) {
+    try {
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+        const prefix = getPrefix();
+
+        const userMessage = message.message?.conversation || 
+                           message.message?.extendedTextMessage?.text || '';
+        const args = userMessage.split(' ');
+        const subCmd = args[1]?.toLowerCase();
+
+        if (!chatId.endsWith('@g.us')) {
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐\n│\n│ Group command only!\n│\n└─────────────┘`
+            }, { quoted: fake });
+            return;
+        }
+
+        const adminStatus = await isAdmin(sock, chatId, senderId);
+        const isSenderAdmin = adminStatus.isSenderAdmin;
+        const isBotAdmin = adminStatus.isBotAdmin;
+
+        if (!isBotAdmin) {
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐\n│\n│ Bot needs to be admin!\n│\n└─────────────┘`
+            }, { quoted: fake });
+            return;
+        }
+
+        if (!subCmd || subCmd === 'help') {
+            const config = getGroupConfig(chatId, 'antigroupmention') || { enabled: false };
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐
+│
+│ Status: ${config.enabled ? 'ON' : 'OFF'}
+│
+│ Commands:
+│ ${prefix}antigroupmention on
+│ ${prefix}antigroupmention off
+│ ${prefix}antigroupmention delete
+│ ${prefix}antigroupmention kick
+│ ${prefix}antigroupmention status
+│
+└─────────────┘`
+            }, { quoted: fake });
+            return;
+        }
+
+        if (subCmd === 'status') {
+            const config = getGroupConfig(chatId, 'antigroupmention') || { enabled: false };
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐
+│
+│ Anti-Group Mention:
+│ ${config.enabled ? 'ACTIVE' : 'INACTIVE'}
+│ ${config.enabled ? 'Mode: ' + (config.action || 'delete').toUpperCase() : ''}
+│
+└─────────────┘`
+            }, { quoted: fake });
+            return;
+        }
+
+        if (!isSenderAdmin && !message.key.fromMe && !db.isSudo(senderId)) {
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐\n│\n│ Admin only command!\n│\n└─────────────┘`
+            }, { quoted: fake });
+            return;
+        }
+
+        const validActions = ['on', 'off', 'delete', 'kick', 'remove'];
+        if (!validActions.includes(subCmd)) {
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐
+│
+│ Invalid option!
+│ Use: on, off, delete, kick
+│
+└─────────────┘`
+            }, { quoted: fake });
+            return;
+        }
+
+        if (subCmd === 'off') {
+            deleteGroupToggle(chatId, 'antigroupmention');
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐
+│
+│ Anti-Group Mention DISABLED
+│
+└─────────────┘`
+            }, { quoted: fake });
+        } else {
+            const action = subCmd === 'on' ? 'delete' : subCmd;
+            setGroupConfig(chatId, 'antigroupmention', { enabled: true, action: action });
+            await sock.sendMessage(chatId, {
+                text: `┌─ *${botName}* ─┐
+│
+│ Anti-Group Mention ENABLED
+│ Mode: ${action.toUpperCase()}
+│
+└─────────────┘`
+            }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Error in antigroupmentionCommand:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+module.exports = {
+    handleAntiStatusMention,
+    antigroupmentionCommand
+};

package/davexcore/anti/antiimage.js

@@ -0,0 +1,105 @@
+const { getGroupConfig, setGroupConfig, deleteGroupToggle } = require('../../Database/settingsStore');
+const isAdmin = require('../../davelib/isAdmin');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function antiimageCommand(sock, chatId, userMessage, senderId, isSenderAdmin, message) {
+    try {
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+
+        if (!isSenderAdmin && !message?.key?.fromMe && !db.isSudo(senderId)) {
+            await sock.sendMessage(chatId, { text: `*${botName}*\nAdmin only command!` }, { quoted: fake });
+            return;
+        }
+
+        const args = userMessage.slice(11).toLowerCase().trim().split(' ');
+        const action = args[0];
+
+        if (!action) {
+            const config = getGroupConfig(chatId, 'antiimage') || { enabled: false };
+            const currentMode = config.enabled ? (config.action || 'delete') : 'off';
+
+            const usage = `*${botName} ANTI-IMAGE*\n\nCurrent Mode: ${currentMode.toUpperCase()}\n\n*Commands:*\n.antiimage off - Disable\n.antiimage delete - Delete image\n.antiimage warn - Delete + warn\n.antiimage kick - Delete + kick`;
+
+            await sock.sendMessage(chatId, { text: usage }, { quoted: fake });
+            return;
+        }
+
+        const validModes = ["off", "delete", "warn", "kick"];
+
+        if (!validModes.includes(action)) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nInvalid mode! Use: off, delete, warn, kick` 
+            }, { quoted: fake });
+            return;
+        }
+
+        if (action === 'off') {
+            deleteGroupToggle(chatId, 'antiimage');
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nAnti-Image DISABLED` 
+            }, { quoted: fake });
+        } else {
+            setGroupConfig(chatId, 'antiimage', { enabled: true, action: action });
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nAnti-Image: ${action.toUpperCase()}` 
+            }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Error in antiimage command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+async function handleImageDetection(sock, chatId, message, senderId) {
+    try {
+        const isImage = message.type === 'imageMessage' || 
+                       (message.message && message.message.imageMessage);
+
+        if (!isImage) return;
+        if (!chatId.endsWith('@g.us')) return;
+
+        const config = getGroupConfig(chatId, 'antiimage');
+        if (!config || !config.enabled) return;
+
+        const { isSenderAdmin, isBotAdmin } = await isAdmin(sock, chatId, senderId);
+        if (!isBotAdmin || isSenderAdmin || db.isSudo(senderId)) return;
+
+        const botName = getBotName();
+        const userTag = `@${senderId.split("@")[0]}`;
+
+        try {
+            await sock.sendMessage(chatId, {
+                delete: {
+                    remoteJid: chatId,
+                    fromMe: false,
+                    id: message.key.id,
+                    participant: senderId
+                }
+            });
+        } catch (e) {
+            console.error("[ANTI-IMAGE] Delete failed:", e.message);
+            return;
+        }
+
+        if (config.action === 'kick') {
+            await sock.sendMessage(chatId, {
+                text: `*${botName}*\n\n${userTag} kicked for sending image.`,
+                mentions: [senderId]
+            });
+            await sock.groupParticipantsUpdate(chatId, [senderId], 'remove');
+        } else if (config.action === 'warn') {
+            await sock.sendMessage(chatId, {
+                text: `*${botName}*\n\n${userTag}, images are not allowed!`,
+                mentions: [senderId]
+            });
+        }
+    } catch (error) {
+        console.error('Error in handleImageDetection:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+module.exports = {
+    antiimageCommand,
+    handleImageDetection
+};

package/davexcore/anti/antikick.js

@@ -0,0 +1,125 @@
+const { getGroupConfig, setGroupConfig, parseToggleCommand } = require('../../Database/settingsStore');
+const db = require('../../Database/database');
+const isAdmin = require('../../davelib/isAdmin');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+function participantToString(p) {
+    if (typeof p === 'string') return p;
+    if (p && p.id) return p.id;
+    return String(p);
+}
+
+async function resolveToPhone(sock, jid) {
+    if (!jid) return 'unknown';
+    const raw = jid.split('@')[0].split(':')[0];
+    if (/^\d{7,15}$/.test(raw)) return raw;
+    try {
+        if (sock?.signalRepository?.lidMapping?.getPNForLID) {
+            const formats = [jid, `${raw}:0@lid`, `${raw}@lid`];
+            for (const fmt of formats) {
+                try {
+                    const pn = await sock.signalRepository.lidMapping.getPNForLID(fmt);
+                    if (pn) {
+                        const num = String(pn).split('@')[0].replace(/[^0-9]/g, '');
+                        if (num.length >= 7 && num.length <= 15 && num !== raw) return num;
+                    }
+                } catch {}
+            }
+        }
+        const groups = await sock.groupFetchAllParticipating();
+        for (const gid of Object.keys(groups)) {
+            for (const p of (groups[gid].participants || [])) {
+                const pid = (p.id || '').split('@')[0].split(':')[0];
+                const pLid = (p.lid || '').split('@')[0].split(':')[0];
+                if ((pLid === raw || pid === raw) && pid && /^\d{7,15}$/.test(pid) && pid !== raw) return pid;
+            }
+        }
+    } catch {}
+    return raw;
+}
+
+async function antikickCommand(sock, chatId, message, senderId, isSenderAdmin) {
+    try {
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+
+        if (!isSenderAdmin && !message.key.fromMe && !db.isSudo(senderId)) {
+            await sock.sendMessage(chatId, { text: `*${botName}*\nAdmin only command!` }, { quoted: fake });
+            return;
+        }
+
+        const text = message.message?.conversation || message.message?.extendedTextMessage?.text || '';
+        const args = text.trim().split(' ').slice(1);
+        const action = args[0]?.toLowerCase();
+
+        const config = getGroupConfig(chatId, 'antikick') || { enabled: false };
+
+        if (!action) {
+            const helpText = `*${botName} ANTIKICK*\n\n` +
+                `Status: ${config.enabled ? 'ON' : 'OFF'}\n\n` +
+                `*Commands:*\n` +
+                `.antikick on - Enable\n` +
+                `.antikick off - Disable\n` +
+                `.antikick status - Show status`;
+            await sock.sendMessage(chatId, { text: helpText }, { quoted: fake });
+            return;
+        }
+
+        let responseText = '';
+
+        if (action === 'status') {
+            responseText = `*${botName}*\nAntikick: ${config.enabled ? 'ACTIVE' : 'INACTIVE'}`;
+        } else {
+            const toggle = parseToggleCommand(action);
+            if (toggle === 'on') {
+                setGroupConfig(chatId, 'antikick', { enabled: true });
+                responseText = `*${botName}*\nAntikick ENABLED\nRemoved members will be re-added.`;
+            } else if (toggle === 'off') {
+                setGroupConfig(chatId, 'antikick', { enabled: false });
+                responseText = `*${botName}*\nAntikick DISABLED`;
+            } else {
+                responseText = `*${botName}*\nInvalid command! Use: on, off, status`;
+            }
+        }
+
+        await sock.sendMessage(chatId, { text: responseText }, { quoted: fake });
+    } catch (error) {
+        console.error('Error in antikick command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+async function handleAntikick(sock, chatId, participants) {
+    try {
+        const config = getGroupConfig(chatId, 'antikick');
+        if (!config?.enabled) return;
+
+        const botName = getBotName();
+        const fake = createFakeContact();
+        
+        for (const participant of participants) {
+            try {
+                const participantJid = participantToString(participant);
+                const participantNumber = await resolveToPhone(sock, participantJid);
+                await sock.groupParticipantsUpdate(chatId, [participantJid], 'add');
+                await sock.sendMessage(chatId, {
+                    text: `*${botName}*\n@${participantNumber} was re-added by antikick.`,
+                    mentions: [participantJid]
+                }, { quoted: fake });
+            } catch (addError) {
+                console.error('Antikick re-add failed:', addError.message);
+            }
+        }
+    } catch (error) {
+        console.error('Error in antikick handler:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+function getGroupConfigExport(chatId) {
+    return getGroupConfig(chatId, 'antikick') || { enabled: false };
+}
+
+module.exports = {
+    antikickCommand,
+    handleAntikick,
+    getGroupConfig: getGroupConfigExport
+};

package/davexcore/anti/antilink.js

@@ -0,0 +1,237 @@
+const { getGroupConfig, setGroupConfig, parseToggleCommand, parseActionCommand } = require('../../Database/settingsStore');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+function normalizeJid(jid) {
+    if (!jid) return '';
+    const num = jid.split('@')[0].split(':')[0];
+    return num + '@s.whatsapp.net';
+}
+
+async function handleAntiLinkDetection(sock, m) {
+    try {
+        if (!m?.message) return;
+        if (m.key.fromMe) return;
+        if (!m.key.remoteJid?.endsWith('@g.us')) return;
+
+        const chatId = m.key.remoteJid;
+        const sender = m.key.participant || m.key.remoteJid;
+
+        const config = getGroupConfig(chatId, 'antilink');
+        if (!config?.enabled) return;
+
+        let text = "";
+        const msg = m.message;
+        if (msg.conversation) {
+            text = msg.conversation;
+        } else if (msg.extendedTextMessage?.text) {
+            text = msg.extendedTextMessage.text;
+        } else if (msg.imageMessage?.caption) {
+            text = msg.imageMessage.caption;
+        } else if (msg.videoMessage?.caption) {
+            text = msg.videoMessage.caption;
+        } else if (msg.documentMessage?.caption) {
+            text = msg.documentMessage.caption;
+        } else if (msg.buttonsResponseMessage?.selectedDisplayText) {
+            text = msg.buttonsResponseMessage.selectedDisplayText;
+        } else if (msg.listResponseMessage?.title) {
+            text = msg.listResponseMessage.title;
+        } else if (msg.templateButtonReplyMessage?.selectedDisplayText) {
+            text = msg.templateButtonReplyMessage.selectedDisplayText;
+        }
+
+        const urlRegex = /(https?:\/\/[^\s]+|www\.[^\s]+|bit\.ly\/[^\s]+|t\.me\/[^\s]+|chat\.whatsapp\.com\/[^\s]+|whatsapp\.com\/[^\s]+|youtu\.be\/[^\s]+|youtube\.com\/[^\s]+)/gi;
+        if (!urlRegex.test(String(text).toLowerCase())) return;
+
+        console.log(`[ANTILINK] Link detected from ${sender} in ${chatId}: "${text.substring(0, 80)}"`);
+
+        let groupMetadata;
+        try {
+            groupMetadata = await sock.groupMetadata(chatId);
+        } catch (metaErr) {
+            console.error('[ANTILINK] Failed to fetch group metadata:', metaErr.message);
+            return;
+        }
+
+        const botId = normalizeJid(sock.user.id);
+        const normalizedSender = normalizeJid(sender);
+        const bot = groupMetadata.participants.find(p => normalizeJid(p.id) === botId || p.id === sock.user?.id);
+        if (bot && !bot.admin) {
+            console.log(`[ANTILINK] Bot is not admin, skipping`);
+            return;
+        }
+
+        const participant = groupMetadata.participants.find(p => normalizeJid(p.id) === normalizedSender || p.id === sender);
+        if (participant?.admin) {
+            console.log(`[ANTILINK] Sender is admin, skipping`);
+            return;
+        }
+        if (db.isSudo(sender) || db.isSudo(normalizedSender)) {
+            console.log(`[ANTILINK] Sender is sudo, skipping`);
+            return;
+        }
+
+        const botName = getBotName();
+        const fake = createFakeContact(sender);
+
+        await sock.sendMessage(chatId, {
+            delete: {
+                remoteJid: chatId,
+                fromMe: false,
+                id: m.key.id,
+                participant: sender,
+            },
+        });
+
+        const username = sender.split('@')[0];
+        const action = config.action || 'delete';
+        const maxWarnings = config.maxWarnings || 3;
+
+        switch (action) {
+            case 'delete':
+                await sock.sendMessage(chatId, {
+                    text: `*${botName}*\n@${username}, no links allowed!\nMessage deleted.`,
+                    mentions: [sender],
+                }, { quoted: fake });
+                break;
+
+            case 'warn':
+                const warningCount = db.incrementWarning(chatId, sender);
+                if (warningCount >= maxWarnings) {
+                    try {
+                        await sock.groupParticipantsUpdate(chatId, [sender], 'remove');
+                        db.resetWarning(chatId, sender);
+                        await sock.sendMessage(chatId, {
+                            text: `*${botName}*\n@${username} kicked after ${maxWarnings} warnings!\nLinks not allowed.`,
+                            mentions: [sender],
+                        }, { quoted: fake });
+                    } catch {}
+                } else {
+                    await sock.sendMessage(chatId, {
+                        text: `*${botName}*\n@${username}, no links allowed!\nWarning ${warningCount}/${maxWarnings}`,
+                        mentions: [sender],
+                    }, { quoted: fake });
+                }
+                break;
+
+            case 'kick':
+                try {
+                    await sock.groupParticipantsUpdate(chatId, [sender], 'remove');
+                    await sock.sendMessage(chatId, {
+                        text: `*${botName}*\n@${username} kicked for posting links.`,
+                        mentions: [sender],
+                    }, { quoted: fake });
+                } catch (err) {
+                    console.error('Failed to kick user:', err.message);
+                }
+                break;
+        }
+    } catch (err) {
+        console.error('Error in handleAntiLinkDetection:', err.message, 'Line:', err.stack?.split('\n')[1]);
+    }
+}
+
+async function handleAntilinkCommand(sock, chatId, userMessage, senderId, isSenderAdmin) {
+    try {
+        const text = typeof userMessage === 'string' ? userMessage : 
+                    (userMessage?.message?.conversation || 
+                     userMessage?.message?.extendedTextMessage?.text || '');
+
+        const parts = text.trim().split(/\s+/);
+        const subCmd = parts[1]?.toLowerCase();
+        const botName = getBotName();
+        const fake = createFakeContact(senderId);
+        const config = getGroupConfig(chatId, 'antilink') || { enabled: false, action: 'delete', maxWarnings: 3 };
+
+        if (!subCmd || subCmd === 'help' || subCmd === 'status') {
+            const helpText = `*${botName} ANTILINK*\n\n` +
+                            `Status: ${config.enabled ? 'ON' : 'OFF'}\n` +
+                            `Action: ${config.action || 'delete'}\n` +
+                            `Max Warnings: ${config.maxWarnings || 3}\n\n` +
+                            `*Commands:*\n` +
+                            `.antilink on - Enable\n` +
+                            `.antilink off - Disable\n` +
+                            `.antilink delete - Set action to delete only\n` +
+                            `.antilink warn - Set action to warn (max = kick)\n` +
+                            `.antilink kick - Set action to delete & kick\n` +
+                            `.antilink setwarn <num> - Set max warnings\n` +
+                            `.antilink status - Show status`;
+            await sock.sendMessage(chatId, { text: helpText }, { quoted: fake });
+            return;
+        }
+
+        if (subCmd === 'setwarn') {
+            const num = parseInt(parts[2]);
+            if (num > 0 && num <= 10) {
+                const newConfig = { ...config, maxWarnings: num };
+                setGroupConfig(chatId, 'antilink', newConfig);
+                await sock.sendMessage(chatId, {
+                    text: `*${botName}*\nMax warnings set to: ${num}`
+                }, { quoted: fake });
+            } else {
+                await sock.sendMessage(chatId, {
+                    text: `*${botName}*\nInvalid number! Use 1-10`
+                }, { quoted: fake });
+            }
+            return;
+        }
+
+        let newConfig = { ...config };
+        let responseText = '';
+
+        if (subCmd === 'on' || subCmd === 'enable') {
+            newConfig.enabled = true;
+            responseText = `*${botName}*\nAntiLink ENABLED\nAction: ${newConfig.action || 'delete'}`;
+        } else if (subCmd === 'off' || subCmd === 'disable') {
+            newConfig.enabled = false;
+            responseText = `*${botName}*\nAntiLink DISABLED`;
+        } else if (subCmd === 'delete' || subCmd === 'del') {
+            newConfig.action = 'delete';
+            newConfig.enabled = true;
+            responseText = `*${botName}*\nAntiLink action set to: DELETE\nLinks will be deleted.`;
+        } else if (subCmd === 'warn' || subCmd === 'warning') {
+            newConfig.action = 'warn';
+            newConfig.enabled = true;
+            responseText = `*${botName}*\nAntiLink action set to: WARN\n${newConfig.maxWarnings || 3} warnings = kick.`;
+        } else if (subCmd === 'kick' || subCmd === 'boot') {
+            newConfig.action = 'kick';
+            newConfig.enabled = true;
+            responseText = `*${botName}*\nAntiLink action set to: KICK\nLink senders will be removed immediately.`;
+        } else {
+            responseText = `*${botName}*\nInvalid option: "${subCmd}"\nUse: on, off, delete, warn, kick`;
+        }
+
+        if (responseText && !responseText.includes('Invalid')) {
+            setGroupConfig(chatId, 'antilink', newConfig);
+        }
+
+        await sock.sendMessage(chatId, { text: responseText }, { quoted: fake });
+
+    } catch (error) {
+        console.error('Error in handleAntilinkCommand:', error.message, 'Line:', error.stack?.split('\n')[1]);
+        const botName = getBotName();
+        await sock.sendMessage(chatId, {
+            text: `*${botName}*\nFailed to configure antilink!`
+        });
+    }
+}
+
+async function getAntilink(groupId) {
+    return getGroupConfig(groupId, 'antilink');
+}
+
+async function setAntilink(groupId, type, action) {
+    const config = {
+        enabled: type === 'on' || type === 'delete' || type === 'kick' || type === 'warn',
+        action: action || 'delete'
+    };
+    setGroupConfig(groupId, 'antilink', config);
+    return true;
+}
+
+module.exports = {
+    handleAntiLinkDetection,
+    handleAntilinkCommand,
+    getAntilink,
+    setAntilink
+};