levix-bot 2.0.0

package/src/commands/group/add.cjs

@@ -0,0 +1,136 @@
+// file: /commands/add.js (Upgraded with Invite Fallback)
+const logger = require("../../utils/logger.cjs");
+const normalizeJid = require("../../utils/normalizeJid.esm.js").default;
+
+module.exports = {
+  name: "add",
+  description:
+    "Adds a member to the group or sends an invite if privacy settings block it.",
+  usage: "add [admin] <رقم الموبايل>",
+  chat: "group",
+  userAdminRequired: true,
+  botAdminRequired: true,
+
+  // The full, correct execute function for commands/add.js
+
+  async execute(sock, msg, args, body, groupMetadata, confirmationSessions) {
+    const groupId = msg.key.remoteJid;
+    const senderId = msg.key.participant; // The admin who is running the command
+    let targetJid;
+    let shouldPromote = false;
+
+    try {
+      // --- ✅ THIS IS THE MISSING LOGIC TO DEFINE targetJid ---
+      // 1. Identify the Target User
+      const mentionedJid =
+        msg.message?.extendedTextMessage?.contextInfo?.mentionedJid?.[0];
+      let contactJid;
+
+      // Check for contact card in a quoted message
+      const quotedVcard =
+        msg.message?.extendedTextMessage?.contextInfo?.quotedMessage
+          ?.contactMessage?.vcard;
+      if (quotedVcard) {
+        contactJid =
+          quotedVcard.match(/waid=([0-9]+)/)?.[1] + "@s.whatsapp.net";
+      }
+
+      // If not found, check for contact card in the main message
+      if (!contactJid || !contactJid.includes("@")) {
+        const mainVcard = msg.message?.contactMessage?.vcard;
+        if (mainVcard) {
+          contactJid =
+            mainVcard.match(/waid=([0-9]+)/)?.[1] + "@s.whatsapp.net";
+        }
+      }
+
+      let numberArg = args.join(" ");
+
+      if (mentionedJid) {
+        targetJid = normalizeJid(mentionedJid);
+      } else if (contactJid && contactJid.includes("@")) {
+        targetJid = normalizeJid(contactJid);
+      } else if (numberArg) {
+        if (args[0].toLowerCase() === "admin") {
+          shouldPromote = true;
+          numberArg = args.slice(1).join(" ");
+        }
+        const cleanNumber = numberArg.replace(/\D/g, "");
+        if (!cleanNumber)
+          return await sock.sendMessage(groupId, {
+            text: "يرجى تقديم رقم هاتف صالح، أو عمل منشن، أو إرسال جهة اتصال.",
+          });
+        targetJid = `${cleanNumber}@s.whatsapp.net`;
+      } else {
+        return await sock.sendMessage(groupId, {
+          text: "لإضافة عضو، قم بعمل منشن له، أو أرسل رقمه، أو أرسل جهة الاتصال الخاصة به.",
+        });
+      }
+      // --- End of Target Identification Logic ---
+
+      // Pre-check if the user is already in the group
+      const isAlreadyMember = groupMetadata.participants.some(
+        (p) => normalizeJid(p.id) === normalizeJid(targetJid)
+      );
+      if (isAlreadyMember) {
+        return await sock.sendMessage(groupId, {
+          text: `⚠️ العضو @${targetJid.split("@")[0]} موجود بالفعل في الجروب.`,
+          mentions: [targetJid],
+        });
+      }
+
+      await sock.sendMessage(groupId, {
+        text: `جاري محاولة إضافة @${targetJid.split("@")[0]}...`,
+        mentions: [targetJid],
+      });
+      const response = await sock.groupParticipantsUpdate(
+        groupId,
+        [targetJid],
+        "add"
+      );
+      const status = response[0].status;
+
+      if (status === "200") {
+        let successMsg = `✅ تم إضافة @${targetJid.split("@")[0]} بنجاح.`;
+        if (shouldPromote) {
+          await sock.groupParticipantsUpdate(groupId, [targetJid], "promote");
+          successMsg += `\n👑 وتمت ترقيته إلى مشرف.`;
+        }
+        await sock.sendMessage(groupId, {
+          text: successMsg,
+          mentions: [targetJid],
+        });
+      } else if (status === "403") {
+        await sock.sendMessage(groupId, {
+          text: `⚠️ لا يمكن إضافة @${
+            targetJid.split("@")[0]
+          } مباشرة بسبب إعدادات الخصوصية لديه.\n\nهل تود إرسال رابط دعوة له في الخاص؟\nأرسل \`yes\` للتأكيد.`,
+          mentions: [targetJid],
+        });
+
+        confirmationSessions.set(senderId, {
+          command: "send_invite",
+          groupId: groupId,
+          targetJid: targetJid,
+          adminJid: senderId,
+          timestamp: Date.now(),
+        });
+
+        setTimeout(() => {
+          if (confirmationSessions.has(senderId)) {
+            confirmationSessions.delete(senderId);
+          }
+        }, 30000);
+      } else {
+        await sock.sendMessage(groupId, {
+          text: `⚠️ لم أتمكن من إضافة الرقم. (كود الحالة: ${status})`,
+        });
+      }
+    } catch (error) {
+      logger.error({ err: error, command: "add" }, "Error in !add command");
+      await sock.sendMessage(groupId, {
+        text: "حدث خطأ. تأكد من أنني مشرف وأن الرقم صحيح.",
+      });
+    }
+  },
+};

package/src/commands/group/all.cjs

@@ -0,0 +1,43 @@
+// file: /commands/all.js
+const logger = require("../../utils/logger.cjs");
+
+module.exports = {
+  name: "all",
+  description: "Mentions all members of the group.",
+  usage: "all [رسالة التنبيه]",
+  chat: "group",
+
+  async execute(sock, msg, args) {
+    try {
+      // 1. Get the group's JID (JID = WhatsApp ID)
+      const groupId = msg.key.remoteJid;
+
+      // 2. Get the group's metadata (this includes the list of participants)
+      // We fetch it fresh to make sure we have the latest list of members.
+      const metadata = await sock.groupMetadata(groupId);
+
+      // 6. Get the list of all participant JIDs
+      const participants = metadata.participants.map((p) => p.id);
+
+      // 7. Prepare the message text and the mentions array
+      // You can customize the message text here
+      let text = "📢 | تنبيه للجميع";
+      if (args && args.length > 0) {
+        text = `*📢 | تنبيه للجميع:*\n${args.join(" ")}`;
+      }
+
+      // 8. Send the message with mentions
+      // The `mentions` property is an array of JIDs that should be mentioned.
+      await sock.sendMessage(groupId, {
+        text: text,
+        mentions: participants,
+      });
+    } catch (error) {
+      logger.error(error, "[Error] in !all command:");
+      // Send a reply in case of an error
+      await sock.sendMessage(msg.key.remoteJid, {
+        text: "حدث خطأ أثناء محاولة عمل منشن للجميع.",
+      });
+    }
+  },
+};

package/src/commands/group/antiSpam.cjs

@@ -0,0 +1,96 @@
+// commands/antiSpam.js
+const logger = require("../../utils/logger.cjs");
+const { isAdminInGroupSync } = require("../../utils/permissions.cjs");
+
+// إعدادات يمكن تعديلها
+const SPAM_MESSAGE_COUNT = 3; // عدد الرسائل المتطابقة لتعتبر سبام
+const SPAM_TIME_WINDOW_SECONDS = 8; // خلال كم ثانية
+const SPAM_WARN_LIMIT = 2; // عدد تحذيرات السبام قبل الطرد
+
+// ذاكرة مؤقتة لتخزين رسائل المستخدمين وتحذيراتهم
+const antiSpamCache = new Map();
+
+/**
+ * دالة لمعالجة الرسائل والتحقق من التكرار (السبام)
+ * @param {import('@whiskeysockets/baileys').WASocket} sock - The socket connection
+ * @param {import('@whiskeysockets/baileys').WAMessage} msg - The message object
+ */
+async function handleAntiSpam(sock, msg) {
+  const isGroup = msg.key.remoteJid.endsWith("@g.us");
+  if (!isGroup) return; // النظام يعمل فقط في المجموعات
+
+  const senderId = msg.key.participant || msg.key.remoteJid;
+  const groupId = msg.key.remoteJid;
+
+  try {
+    // لا نطبق النظام على المشرفين لتجنب طردهم بالخطأ.
+    // v7/LID: نستخدم الفاحص الموحّد الذي يطابق الـ LID والـ PN معًا بدل
+    // المقارنة الخام `p.id === senderId` التي كانت تفشل مع اختلاف الصيغة
+    // (وكانت ممكن تطرد مشرف بالغلط).
+    const groupMetadata = await sock.groupMetadata(groupId);
+    const senderAlt = msg.key.participantAlt || msg.key.participantPn;
+    if (
+      isAdminInGroupSync(groupMetadata, senderId) ||
+      (senderAlt && isAdminInGroupSync(groupMetadata, senderAlt))
+    ) {
+      return;
+    }
+
+    const messageContent = JSON.stringify(msg.message); // طريقة دقيقة لمقارنة محتوى الرسالة
+    const now = Math.floor(Date.now() / 1000);
+    const cacheKey = `${senderId}_${groupId}`;
+
+    if (!antiSpamCache.has(cacheKey)) {
+      antiSpamCache.set(cacheKey, { messages: [], warnCount: 0 });
+    }
+    const userData = antiSpamCache.get(cacheKey);
+
+    // 1. فلترة الرسائل القديمة
+    userData.messages = userData.messages.filter(
+      (m) => now - m.timestamp < SPAM_TIME_WINDOW_SECONDS
+    );
+
+    // 2. إضافة الرسالة الجديدة
+    userData.messages.push({ content: messageContent, timestamp: now });
+
+    // 3. التحقق من وجود تكرار
+    const repeatedMessages = userData.messages.filter(
+      (m) => m.content === messageContent
+    );
+
+    if (repeatedMessages.length >= SPAM_MESSAGE_COUNT) {
+      userData.warnCount += 1;
+      userData.messages = []; // مسح الرسائل بعد اكتشاف السبام لمنع التحذيرات المتتالية
+
+      if (userData.warnCount >= SPAM_WARN_LIMIT) {
+        logger.info(
+          `[AntiSpam] Kicking ${senderId} from ${groupId} for repeated spam.`
+        );
+        // إعادة تعيين العداد بعد الطرد
+        antiSpamCache.delete(cacheKey);
+
+        await sock.sendMessage(groupId, {
+          text: `🚫 تم طرد المستخدم @${
+            senderId.split("@")[0]
+          } تلقائيًا بسبب الإزعاج.`,
+          mentions: [senderId],
+        });
+        await sock.groupParticipantsUpdate(groupId, [senderId], "remove");
+      } else {
+        logger.info(
+          `[AntiSpam] Warning ${senderId} in ${groupId}. Warn count: ${userData.warnCount}`
+        );
+        await sock.sendMessage(groupId, {
+          text: `⚠️ تحذير للمستخدم @${
+            senderId.split("@")[0]
+          } بسبب تكرار الرسائل.\nالتحذير رقم: ${userData.warnCount}`,
+          mentions: [senderId],
+        });
+      }
+    }
+  } catch (error) {
+    logger.error({ err: error }, "Error in handleAntiSpam");
+  }
+}
+
+module.exports = { handleAntiSpam };

package/src/commands/group/antilink.cjs

@@ -0,0 +1,167 @@
+// file: /commands/group/antilink.js
+const { getGroupSettings, saveGroupSettings } = require("../../utils/storage.cjs");
+const logger = require("../../utils/logger.cjs");
+const {
+  isOwnerJidSync,
+  isAdminInGroupSync,
+} = require("../../utils/permissions.cjs");
+
+// --- The Main Command Logic ---
+const command = {
+  name: "antilink",
+  description: "Advanced control for the anti-link feature.",
+  usage: "antilink [status]\nantilink <on|off>\nantilink mode <ALL|WHITELIST|BLACKLIST>\nantilink <allow|disallow> <دومين>",
+  chat: "group",
+  userAdminRequired: true,
+
+  async execute(sock, msg, args) {
+    const groupId = msg.key.remoteJid;
+    const subCommand = args[0] ? args[0].toLowerCase() : "status";
+    const settings = getGroupSettings(groupId);
+
+    // Initialize settings for antilink if it doesn't exist
+    if (!settings.antilink) {
+      settings.antilink = {
+        enabled: false,
+        mode: "ALL",
+        allowed_domains: [],
+        blocked_domains: [],
+      };
+    }
+
+    const antilinkConfig = settings.antilink;
+
+    switch (subCommand) {
+      case "on":
+        antilinkConfig.enabled = true;
+        await sock.sendMessage(groupId, {
+          text: "✅ تم تفعيل نظام منع الروابط.",
+        });
+        break;
+      case "off":
+        antilinkConfig.enabled = false;
+        await sock.sendMessage(groupId, {
+          text: "☑️ تم تعطيل نظام منع الروابط.",
+        });
+        break;
+      case "mode":
+        const mode = args[1] ? args[1].toUpperCase() : "";
+        if (!["ALL", "WHITELIST", "BLACKLIST"].includes(mode)) {
+          return await sock.sendMessage(groupId, {
+            text: "الوضع غير صالح. الأوضاع المتاحة: `ALL`, `WHITELIST`, `BLACKLIST`",
+          });
+        }
+        antilinkConfig.mode = mode;
+        await sock.sendMessage(groupId, {
+          text: `✅ تم تغيير وضع منع الروابط إلى: ${mode}`,
+        });
+        break;
+      case "allow":
+        const domainToAllow = args[1] ? args[1].toLowerCase() : "";
+        if (!domainToAllow)
+          return await sock.sendMessage(groupId, {
+            text: "يرجى تحديد دومين للسماح به.",
+          });
+        if (!antilinkConfig.allowed_domains.includes(domainToAllow)) {
+          antilinkConfig.allowed_domains.push(domainToAllow);
+        }
+        await sock.sendMessage(groupId, {
+          text: `✅ تم إضافة '${domainToAllow}' إلى قائمة الدومينات المسموح بها.`,
+        });
+        break;
+      case "disallow":
+        const domainToDisallow = args[1] ? args[1].toLowerCase() : "";
+        if (!domainToDisallow)
+          return await sock.sendMessage(groupId, {
+            text: "يرجى تحديد دومين لإزالته.",
+          });
+        antilinkConfig.allowed_domains = antilinkConfig.allowed_domains.filter(
+          (d) => d !== domainToDisallow
+        );
+        await sock.sendMessage(groupId, {
+          text: `☑️ تم إزالة '${domainToDisallow}' من قائمة الدومينات المسموح بها.`,
+        });
+        break;
+      default:
+        // Display current status
+        let statusReply = `*حالة نظام منع الروابط:*\n\n`;
+        statusReply += `الحالة: ${
+          antilinkConfig.enabled ? "مفعل ✅" : "معطل ☑️"
+        }\n`;
+        statusReply += `الوضع: ${antilinkConfig.mode}\n`;
+        statusReply += `الدومينات المسموح بها: ${
+          antilinkConfig.allowed_domains.join(", ") || "لا يوجد"
+        }\n`;
+        await sock.sendMessage(groupId, { text: statusReply });
+    }
+
+    saveGroupSettings(groupId, settings);
+  },
+};
+
+// --- The Message Handler Logic ---
+const linkRegex = new RegExp(
+  /(https?:\/\/(?:www\.|(?!www))[a-zA-Z0-9][a-zA-Z0-9-]+[a-zA-Z0-9]\.[^\s]{2,}|www\.[a-zA-Z0-9][a-zA-Z0-9-]+[a-zA-Z0-9]\.[^\s]{2,}|https?:\/\/[a-zA-Z0-9]+\.[^\s]{2,}|[a-zA-Z0-9]+\.[^\s]{2,})/i
+);
+
+async function handleAntiLink(sock, msg, _legacyConfig, _normalizeJid) {
+  const isGroup = msg.key.remoteJid.endsWith("@g.us");
+  if (!isGroup) return;
+
+  const groupId = msg.key.remoteJid;
+  const settings = getGroupSettings(groupId);
+  const antilinkConfig = settings.antilink;
+
+  if (!antilinkConfig || !antilinkConfig.enabled) return;
+
+  const senderId = msg.key.participant || msg.key.remoteJid;
+
+  const groupMetadata = await sock.groupMetadata(groupId);
+  // Centralized checks — handle LID/PN cross-format and bootstrap roster.
+  const isOwner = isOwnerJidSync(senderId);
+  const isSenderAdmin = isAdminInGroupSync(groupMetadata, senderId);
+
+  if (isOwner || isSenderAdmin) return;
+
+  const body =
+    msg.message.conversation || msg.message.extendedTextMessage?.text || "";
+  if (!linkRegex.test(body)) return; // No link found
+
+  // --- Link Found, Apply Rules ---
+  const foundLinks = body.match(linkRegex);
+  const domain = new URL(
+    foundLinks[0].startsWith("http") ? foundLinks[0] : `http://${foundLinks[0]}`
+  ).hostname.replace("www.", "");
+
+  let shouldDelete = false;
+
+  switch (antilinkConfig.mode) {
+    case "ALL":
+      shouldDelete = true;
+      break;
+    case "WHITELIST":
+      if (!antilinkConfig.allowed_domains.includes(domain)) {
+        shouldDelete = true;
+      }
+      break;
+    case "BLACKLIST":
+      if (antilinkConfig.blocked_domains.includes(domain)) {
+        shouldDelete = true;
+      }
+      break;
+  }
+
+  if (shouldDelete) {
+    logger.info(
+      `[Anti-Link] Deleting link from ${senderId} in ${groupId}. Domain: ${domain}`
+    );
+    await sock.sendMessage(groupId, { delete: msg.key });
+    await sock.sendMessage(groupId, {
+      text: `ممنوع إرسال الروابط هنا يا @${senderId.split("@")[0]}!`,
+      mentions: [senderId],
+    });
+  }
+}
+
+// Export both the command and the handler
+module.exports = { ...command, handleAntiLink };

package/src/commands/group/approveall.cjs

@@ -0,0 +1,54 @@
+// file: /commands/group/approveall.js
+const {
+  getGroupSettings,
+  saveGroupSettings,
+} = require("../../utils/storage.cjs"); // Note the path is ../../
+const logger = require("../../utils/logger.cjs");
+
+module.exports = {
+  name: "approveall",
+  description: "Manages the auto-approve feature for join requests.",
+  usage: "approveall <on|off>",
+  chat: "group",
+  userAdminRequired: true,
+  botAdminRequired: true, // The bot must be an admin to approve requests
+
+  async execute(sock, msg, args) {
+    const groupId = msg.key.remoteJid;
+    const option = args[0]?.toLowerCase();
+
+    try {
+      const settings = getGroupSettings(groupId);
+      if (!settings.join_requests) {
+        settings.join_requests = { auto_approve_enabled: false };
+      }
+
+      if (option === "on") {
+        settings.join_requests.auto_approve_enabled = true;
+        saveGroupSettings(groupId, settings);
+        return await sock.sendMessage(groupId, {
+          text: "✅ تم تفعيل نظام الموافقة التلقائية على طلبات الانضمام.",
+        });
+      } else if (option === "off") {
+        settings.join_requests.auto_approve_enabled = false;
+        saveGroupSettings(groupId, settings);
+        return await sock.sendMessage(groupId, {
+          text: "☑️ تم تعطيل نظام الموافقة التلقائية.",
+        });
+      } else {
+        const status = settings.join_requests.auto_approve_enabled
+          ? "مفعل ✅"
+          : "معطل ☑️";
+        return await sock.sendMessage(groupId, {
+          text: `حالة الموافقة التلقائية: ${status}.\nاستخدم 'on' أو 'off' للتغيير.`,
+        });
+      }
+    } catch (error) {
+      logger.error(
+        { err: error, command: "approveall" },
+        "Error in !group approveall command"
+      );
+      await sock.sendMessage(groupId, { text: "حدث خطأ." });
+    }
+  },
+};

package/src/commands/group/clearwarns.cjs

@@ -0,0 +1,41 @@
+// file: /commands/clearwarns.js
+const { clearUserWarnings } = require("../../utils/storage.cjs");
+const logger = require("../../utils/logger.cjs");
+
+module.exports = {
+  name: "clearwarns",
+  description: "Clears all warnings for a specific user.",
+  usage: "clearwarns @عضو",
+  chat: "group",
+  userAdminRequired: true,
+
+  async execute(sock, msg) {
+    try {
+      const groupId = msg.key.remoteJid;
+      const mentionedJid =
+        msg.message?.extendedTextMessage?.contextInfo?.mentionedJid?.[0];
+
+      if (!mentionedJid) {
+        return await sock.sendMessage(groupId, {
+          text: "يجب عمل منشن للعضو الذي تريد مسح تحذيراته.",
+        });
+      }
+
+      // Call the new function from storage.js to delete the record from the database
+      clearUserWarnings(groupId, mentionedJid);
+
+      const replyText = `✅ تم مسح جميع تحذيرات العضو @${
+        mentionedJid.split("@")[0]
+      } بنجاح.`;
+      await sock.sendMessage(groupId, {
+        text: replyText,
+        mentions: [mentionedJid],
+      });
+    } catch (error) {
+      logger.error({ err: error }, "Error in !clearwarns command");
+      await sock.sendMessage(msg.key.remoteJid, {
+        text: "حدث خطأ أثناء مسح التحذيرات.",
+      });
+    }
+  },
+};

package/src/commands/group/deletenote.cjs

@@ -0,0 +1,33 @@
+// file: /commands/deletenote.js
+const { deleteNote } = require("../../utils/storage.cjs");
+
+module.exports = {
+  name: "deletenote",
+  description: "Deletes a saved note.",
+  usage: "deletenote #الكلمة-المفتاحية",
+  chat: "all",
+  userAdminRequired: true,
+
+  async execute(sock, msg, args) {
+    const groupId = msg.key.remoteJid;
+    const keywordArg = args[0];
+
+    if (!keywordArg || !keywordArg.startsWith("#")) {
+      return await sock.sendMessage(groupId, {
+        text: "صيغة غير صحيحة. استخدم: `!deletenote #keyword`",
+      });
+    }
+
+    const keyword = keywordArg.slice(1).toLowerCase();
+
+    if (deleteNote(groupId, keyword)) {
+      await sock.sendMessage(groupId, {
+        text: `☑️ تم حذف الملاحظة \`#${keyword}\` بنجاح.`,
+      });
+    } else {
+      await sock.sendMessage(groupId, {
+        text: `⚠️ لم يتم العثور على ملاحظة بالكلمة المفتاحية: \`${keywordArg}\``,
+      });
+    }
+  },
+};

package/src/commands/group/demote.cjs

@@ -0,0 +1,62 @@
+// file: /commands/demote.js
+const logger = require("../../utils/logger.cjs");
+
+module.exports = {
+  name: "demote",
+  description: "Demotes an admin to a regular member.",
+  usage: "demote @عضو",
+  chat: "group",
+  userAdminRequired: true,
+  botAdminRequired: true,
+
+  async execute(sock, msg, args, body, groupMetadata) {
+    const groupId = msg.key.remoteJid;
+
+    // Logic to identify the target user from mention or reply
+    const targetJid =
+      msg.message?.extendedTextMessage?.contextInfo?.mentionedJid?.[0] ||
+      msg.message?.extendedTextMessage?.contextInfo?.participant;
+
+    if (!targetJid) {
+      return await sock.sendMessage(groupId, {
+        text: "يجب عمل منشن للمشرف أو الرد على رسالته لعزله.",
+      });
+    }
+
+    // Safety check: Is the target user NOT an admin?
+    const targetUser = groupMetadata.participants.find(
+      (p) => p.id === targetJid
+    );
+    if (!targetUser || !targetUser.admin) {
+      return await sock.sendMessage(groupId, {
+        text: `⚠️ العضو @${targetJid.split("@")[0]} ليس مشرفًا أصلاً.`,
+        mentions: [targetJid],
+      });
+    }
+
+    // Safety check: Cannot demote the group creator
+    if (targetUser.admin === "superadmin") {
+      return await sock.sendMessage(groupId, {
+        text: "لا يمكن عزل منشئ الجروب.",
+      });
+    }
+
+    try {
+      await sock.groupParticipantsUpdate(
+        groupId,
+        [targetJid],
+        "demote" // The action is 'demote'
+      );
+      await sock.sendMessage(groupId, {
+        text: `👤 تم عزل @${targetJid.split("@")[0]} من الإشراف.`,
+        mentions: [targetJid],
+      });
+    } catch (error) {
+      logger.error(
+        { err: error, command: "demote" },
+        "Error in !demote command"
+      );
+      await sock.sendMessage(groupId, { text: "حدث خطأ أثناء محاولة العزل." });
+    }
+  },
+};