levix-bot 2.0.0

package/src/commands/group/tagadmins.cjs

@@ -0,0 +1,50 @@
+// file: /commands/tagadmins.js
+const logger = require("../../utils/logger.cjs");
+
+module.exports = {
+  name: "tagadmins",
+  description: "Mentions all admins in the group.",
+  usage: "tagadmins [رسالة]",
+  chat: "group",
+
+  async execute(sock, msg, args, body, groupMetadata) {
+    const groupId = msg.key.remoteJid;
+
+    try {
+      // Filter the participants to get only admins and superadmins
+      const admins = groupMetadata.participants.filter(
+        (p) => p.admin === "admin" || p.admin === "superadmin"
+      );
+
+      if (admins.length === 0) {
+        return await sock.sendMessage(groupId, {
+          text: "لا يوجد مشرفون في هذا الجروب.",
+        });
+      }
+
+      // Get the custom message provided by the user, or use a default one
+      const customMessage = args.join(" ") || "يرجى حضور المشرفين";
+
+      // Get an array of JIDs for the mentions property
+      const mentions = admins.map((a) => a.id);
+
+      let text = `*🚨 تنبيه للمشرفين 🚨*\n\n*الرسالة:* ${customMessage}\n\n`;
+
+      // Add a tag for each admin
+      for (const admin of admins) {
+        text += `» @${admin.id.split("@")[0]}\n`;
+      }
+
+      await sock.sendMessage(groupId, {
+        text: text,
+        mentions: mentions,
+      });
+    } catch (error) {
+      logger.error(
+        { err: error, command: "tagadmins" },
+        "Error in !tagadmins command"
+      );
+      await sock.sendMessage(groupId, { text: "حدث خطأ." });
+    }
+  },
+};

package/src/commands/group/warn.cjs

@@ -0,0 +1,105 @@
+// file: /commands/warn.js (Corrected Logic Flow)
+const { getGroupSettings } = require("../../utils/storage.cjs"); // <-- 1. Import getGroupSettings
+const {
+  getUserWarnings,
+  saveUserWarnings,
+  clearUserWarnings,
+} = require("../../utils/storage.cjs");
+const logger = require("../../utils/logger.cjs");
+
+module.exports = {
+  name: "warn",
+  description: "Warns a user and takes action if the limit is reached.",
+  usage: "warn @عضو [السبب]",
+  chat: "group",
+  userAdminRequired: true,
+
+  async execute(sock, msg, args) {
+    try {
+      const groupId = msg.key.remoteJid;
+      const senderId = msg.key.participant;
+      const mentionedJid =
+        msg.message?.extendedTextMessage?.contextInfo?.mentionedJid?.[0];
+      const reason = args.slice(1).join(" ");
+
+      // --- 1. Validate Inputs ---
+      if (!mentionedJid) {
+        return await sock.sendMessage(groupId, {
+          text: "يجب عمل منشن للعضو الذي تريد تحذيره.",
+        });
+      }
+      if (!reason) {
+        return await sock.sendMessage(groupId, {
+          text: "يجب كتابة سبب التحذير.",
+        });
+      }
+
+      // --- 2. Add the New Warning ---
+      const userWarnings = getUserWarnings(groupId, mentionedJid);
+      userWarnings.push({
+        reason: reason,
+        by: senderId,
+        date: new Date().toISOString(),
+      });
+      saveUserWarnings(groupId, mentionedJid, userWarnings);
+
+      const newWarnCount = userWarnings.length;
+
+      // --- 3. Send Confirmation & Check for Action ---
+      let replyText =
+        `✅ تم توجيه تحذير إلى @${mentionedJid.split("@")[0]}.\n` +
+        `*السبب:* ${reason}`;
+
+      await sock.sendMessage(groupId, {
+        text: replyText,
+        mentions: [mentionedJid],
+      });
+
+      const warnConfig = getGroupSettings(groupId)?.warn_system;
+
+      if (
+        warnConfig &&
+        warnConfig.action === "KICK" &&
+        newWarnCount >= warnConfig.max_warnings
+      ) {
+        await sock.sendMessage(groupId, {
+          text: `🚫 لقد وصل العضو @${
+            mentionedJid.split("@")[0]
+          } إلى الحد الأقصى للتحذيرات (${newWarnCount}/${
+            warnConfig.max_warnings
+          }). سيتم حذفه.`,
+          mentions: [mentionedJid],
+        });
+
+        try {
+          // Kick the user and then clear their warnings
+          await sock.groupParticipantsUpdate(groupId, [mentionedJid], "remove");
+          clearUserWarnings(groupId, mentionedJid);
+          logger.info(
+            `[Warn Kick] Kicked and cleared warnings for ${mentionedJid} from ${groupId}`
+          );
+        } catch (kickError) {
+          logger.error(
+            { err: kickError },
+            "Failed to kick user after max warnings"
+          );
+          await sock.sendMessage(groupId, {
+            text: "حاولت حذف العضو ولكني لا أملك صلاحية كافية لذلك.",
+          });
+        }
+      } else {
+        // If no action is taken, just inform about the new count
+        await sock.sendMessage(groupId, {
+          text: `*إجمالي التحذيرات الآن:* ${newWarnCount}${
+            warnConfig ? `/${warnConfig.max_warnings}` : ""
+          }`,
+        });
+      }
+    } catch (error) {
+      logger.error({ err: error }, "An error occurred in the !warn command.");
+      await sock.sendMessage(msg.key.remoteJid, {
+        text: "حدث خطأ عام في أمر التحذير.",
+      });
+    }
+  },
+};

package/src/commands/group/warns.cjs

@@ -0,0 +1,66 @@
+// file: /commands/warns.js
+const { getUserWarnings } = require("../../utils/storage.cjs");
+const logger = require("../../utils/logger.cjs");
+
+module.exports = {
+  name: "warns",
+  description: "Displays the warnings for a specific user.",
+  usage: "warns @عضو",
+  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: "يجب عمل منشن للعضو الذي تريد عرض تحذيراته.",
+        });
+      }
+
+      // Fetch warnings directly from the database
+      const userWarnings = getUserWarnings(groupId, mentionedJid);
+
+      if (userWarnings.length === 0) {
+        return await sock.sendMessage(groupId, {
+          text: `✅ لا توجد أي تحذيرات للعضو @${mentionedJid.split("@")[0]}.`,
+          mentions: [mentionedJid],
+        });
+      }
+
+      let reply = `*سجل تحذيرات @${
+        mentionedJid.split("@")[0]
+      }:*\n*إجمالي التحذيرات: ${userWarnings.length}*\n\n`;
+
+      const mentionedAdmins = [];
+      userWarnings.forEach((warning, index) => {
+        const adminJid = warning.by;
+        mentionedAdmins.push(adminJid);
+        const warningDate = new Date(warning.date).toLocaleString("ar-EG", {
+          timeZone: "Africa/Cairo",
+        });
+
+        reply +=
+          `*${index + 1}. التحذير:*\n` +
+          `*السبب:* ${warning.reason}\n` +
+          `*بواسطة المشرف:* @${adminJid.split("@")[0]}\n` +
+          `*التاريخ:* ${warningDate}\n\n`;
+      });
+
+      const mentions = [mentionedJid, ...mentionedAdmins];
+
+      await sock.sendMessage(groupId, {
+        text: reply,
+        mentions: mentions,
+      });
+    } catch (error) {
+      logger.error({ err: error }, "Error in !warns command");
+      await sock.sendMessage(msg.key.remoteJid, {
+        text: "حدث خطأ أثناء عرض التحذيرات.",
+      });
+    }
+  },
+};

package/src/commands/group/welcome.cjs

@@ -0,0 +1,109 @@
+// file: /commands/welcome.js
+const {
+  getGroupSettings,
+  saveGroupSettings,
+} = require("../../utils/storage.cjs");
+const logger = require("../../utils/logger.cjs");
+
+module.exports = {
+  name: "welcome",
+  description: "Manages the group's welcome message system.",
+  usage: "welcome [status]\nwelcome <on|off>\nwelcome add <نص الترحيب>\nwelcome list\nwelcome delete <رقم>",
+  chat: "group",
+  userAdminRequired: true,
+
+  async execute(sock, msg, args) {
+    const groupId = msg.key.remoteJid;
+    const subCommand = args[0] ? args[0].toLowerCase() : "status"; // Default to showing status
+
+    try {
+      const settings = getGroupSettings(groupId);
+
+      // Initialize the welcome system settings if they don't exist
+      if (!settings.welcome_system) {
+        settings.welcome_system = { enabled: false, messages: [] };
+      }
+      const welcomeConfig = settings.welcome_system;
+
+      switch (subCommand) {
+        case "on":
+          welcomeConfig.enabled = true;
+          await sock.sendMessage(groupId, {
+            text: "✅ تم تفعيل نظام الترحيب التلقائي.",
+          });
+          break;
+
+        case "off":
+          welcomeConfig.enabled = false;
+          await sock.sendMessage(groupId, {
+            text: "☑️ تم تعطيل نظام الترحيب التلقائي.",
+          });
+          break;
+
+        case "add":
+          const messageToAdd = args.slice(1).join(" ");
+          if (!messageToAdd || !messageToAdd.includes("${user}")) {
+            return await sock.sendMessage(groupId, {
+              text: "يرجى كتابة رسالة ترحيب تحتوي على المتغير ${user} لعمل منشن للعضو الجديد.",
+            });
+          }
+          welcomeConfig.messages.push(messageToAdd);
+          await sock.sendMessage(groupId, {
+            text: "✅ تم إضافة رسالة الترحيب بنجاح.",
+          });
+          break;
+
+        case "list":
+          if (welcomeConfig.messages.length === 0) {
+            return await sock.sendMessage(groupId, {
+              text: "لا توجد رسائل ترحيب محفوظة.",
+            });
+          }
+          let listReply = "*قائمة رسائل الترحيب المحفوظة:*\n\n";
+          welcomeConfig.messages.forEach((message, index) => {
+            listReply += `#${index + 1}: ${message}\n`;
+          });
+          await sock.sendMessage(groupId, { text: listReply });
+          break;
+
+        case "delete":
+          const indexToDelete = parseInt(args[1]?.replace("#", ""), 10) - 1;
+          if (
+            isNaN(indexToDelete) ||
+            indexToDelete < 0 ||
+            indexToDelete >= welcomeConfig.messages.length
+          ) {
+            return await sock.sendMessage(groupId, {
+              text: "رقم الرسالة غير صالح. استخدم `!welcome list` لمعرفة الأرقام.",
+            });
+          }
+          const deletedMessage = welcomeConfig.messages.splice(
+            indexToDelete,
+            1
+          );
+          await sock.sendMessage(groupId, {
+            text: `☑️ تم حذف الرسالة بنجاح:\n*${deletedMessage[0]}*`,
+          });
+          break;
+
+        case "status":
+        default:
+          const statusReply =
+            `*상태 نظام الترحيب:*\n\n` +
+            `الحالة: ${welcomeConfig.enabled ? "مفعل ✅" : "معطل ☑️"}\n` +
+            `عدد الرسائل المحفوظة: ${welcomeConfig.messages.length}`;
+          await sock.sendMessage(groupId, { text: statusReply });
+          break;
+      }
+
+      // Save the updated settings back to the database
+      saveGroupSettings(groupId, settings);
+    } catch (error) {
+      logger.error(
+        { err: error, command: "welcome" },
+        "Error in !welcome command"
+      );
+      await sock.sendMessage(groupId, { text: "حدث خطأ." });
+    }
+  },
+};

package/src/commands/group.cjs

@@ -0,0 +1,160 @@
+// file: /commands/group.js (Permission-aware sub-command router)
+//
+// Audit fix: this used to read owner status from `config.owners` (always
+// empty) and admin status with a raw `p.id === senderId`
+// comparison that breaks under v7's LID/PN split. Both checks now go
+// through the centralized permissions module.
+
+const fs = require("fs");
+const path = require("path");
+const logger = require("../utils/logger.cjs");
+const runtimeConfig = require("../config/runtime-config.cjs");
+const {
+  isOwnerJidSync,
+  isAdminInGroupSync,
+  isBotAdminInGroupSync,
+} = require("../utils/permissions.cjs");
+const normalizeJid = require("../utils/normalizeJid.cjs");
+
+// --- Sub-command Loader ---
+//
+// Same story as the top-level command loader: read the directory normally, and
+// take a generated manifest instead when there is no directory to read (a
+// packaged executable). See scripts/build-sea.mjs.
+const subCommands = new Map();
+
+function register(command, label) {
+  try {
+    if (!command?.name) return;
+    subCommands.set(command.name, command);
+    if (Array.isArray(command.aliases)) {
+      command.aliases.forEach((alias) => subCommands.set(alias, command));
+    }
+  } catch (error) {
+    logger.error({ err: error, file: label }, `Failed to load group sub-command from ${label}`);
+  }
+}
+
+let manifest = null;
+try {
+  const loaded = require("./group/_manifest.cjs");
+  if (Array.isArray(loaded)) manifest = loaded;
+} catch (error) {
+  if (error?.code !== "MODULE_NOT_FOUND") {
+    logger.error({ err: error }, "[group] manifest failed to load");
+  }
+}
+
+if (manifest) {
+  for (const entry of manifest) register(entry.module, entry.label);
+} else {
+  const subCommandsPath = path.join(__dirname, "group");
+  for (const file of fs.readdirSync(subCommandsPath)) {
+    if (!file.endsWith(".cjs") || file.startsWith("_")) continue;
+    try {
+      register(require(path.join(subCommandsPath, file)), file);
+    } catch (error) {
+      logger.error(
+        { err: error, file },
+        `Failed to load group sub-command from ${file}`
+      );
+    }
+  }
+}
+
+module.exports = {
+  name: "group",
+  description: "Main command for all group management actions.",
+  usage: "group <أمر فرعي> [المعاملات]",
+  chat: "group",
+
+  async execute(sock, msg, args, body, groupMetadata) {
+    const subCommandName = args.shift()?.toLowerCase();
+
+    if (!subCommandName) {
+      return await sock.sendMessage(msg.key.remoteJid, {
+        text: "يرجى تحديد أمر فرعي بعد `!group`.",
+      });
+    }
+
+    const subCommand = subCommands.get(subCommandName);
+    if (!subCommand) {
+      return await sock.sendMessage(msg.key.remoteJid, {
+        text: `الأمر الفرعي \`${subCommandName}\` غير معروف.`,
+      });
+    }
+
+    // Switched off from the dashboard: `!group kick` has to refuse it too, not
+    // just the direct `!kick`.
+    if (runtimeConfig.isDisabled(subCommand.name)) {
+      return await sock.sendMessage(msg.key.remoteJid, {
+        text: "⛔ الأمر ده متوقف حاليًا.",
+      });
+    }
+
+    const senderId = normalizeJid(msg.key.participant || msg.key.remoteJid);
+    // Centralized owner check — covers the bot itself, LID<->PN,
+    // and the user_metadata table.
+    const isOwner = msg.key.fromMe || isOwnerJidSync(senderId);
+    const isSenderAdmin = isAdminInGroupSync(groupMetadata, senderId);
+
+    // "group:kick" — the flat key runtime-config uses for sub-commands, so a
+    // level changed from the dashboard applies here too.
+    const permissionLevel = runtimeConfig.getPermission(
+      `group:${subCommand.name}`
+    );
+
+    let hasPermission = false;
+    switch (permissionLevel) {
+      case "MEMBERS":
+      case "ALL":
+        hasPermission = true;
+        break;
+      case "OWNER_ONLY":
+        hasPermission = isOwner;
+        break;
+      case "ADMINS_ONLY":
+        hasPermission = isSenderAdmin || isOwner;
+        break;
+      case "ADMINS_OWNER":
+        hasPermission = isOwner || isSenderAdmin;
+        break;
+      default:
+        logger.warn(
+          `[group] Unknown permission level "${permissionLevel}" for sub-command "${subCommand.name}"`
+        );
+    }
+
+    if (!hasPermission) {
+      return await sock.sendMessage(msg.key.remoteJid, {
+        text: "🚫 ليس لديك الصلاحية لاستخدام هذا الأمر.",
+      });
+    }
+
+    const isBotAdmin = isBotAdminInGroupSync(groupMetadata, sock);
+    if (subCommand.userAdminRequired && !isSenderAdmin && !isOwner) {
+      return await sock.sendMessage(msg.key.remoteJid, {
+        text: "⚠️ هذا الأمر يتطلب أن تكون مشرفًا.",
+      });
+    }
+    if (subCommand.botAdminRequired && !isBotAdmin) {
+      return await sock.sendMessage(msg.key.remoteJid, {
+        text: "⚠️ يجب أن أكون مشرفًا لتنفيذ هذا الأمر.",
+      });
+    }
+
+    try {
+      await subCommand.execute(sock, msg, args, body, groupMetadata);
+    } catch (error) {
+      logger.error(
+        { err: error, subCommand: subCommandName },
+        "Error executing a group sub-command"
+      );
+      await sock.sendMessage(msg.key.remoteJid, {
+        text: `❌ *فشل تنفيذ الأمر الفرعي* (\`${error.name || "Error"}\`): ${
+          error.message || "غير معروف"
+        }`,
+      });
+    }
+  },
+};