levix-bot 2.0.0

package/src/commands/mod.cjs

@@ -0,0 +1,155 @@
+// commands/mod.js
+
+const { getGroupSettings, saveGroupSettings } = require("../utils/storage.cjs");
+const {
+  isOwnerJidSync,
+  isAdminInGroupSync,
+} = require("../utils/permissions.cjs");
+
+// الهيكل الافتراضي لإعدادات المراقبة
+const defaultModSettings = {
+  antiLink: { enabled: false },
+  antiSpam: { enabled: true }, // نفعّله افتراضيًا لأنه مهم
+  forbiddenWords: {
+    enabled: false,
+    list: [],
+  },
+};
+
+module.exports = {
+  name: "mod",
+  aliases: ["moderation", "settings"],
+  description: "التحكم في إعدادات المراقبة للجروب.",
+  usage: "mod status\nmod <enable|disable> <antiLink|antiSpam|forbiddenWords>\nmod words <add|remove> <الكلمة>\nmod words list",
+  chat: "group", // يعمل في الجروبات فقط
+  botAdminRequired: false, // لا يتطلب أن يكون البوت مشرفًا لتغيير الإعدادات
+
+  async execute(sock, msg, args) {
+    const groupId = msg.key.remoteJid;
+    const senderId = msg.key.participant;
+
+    // التحقق من صلاحيات المشرف (LID-aware via central module). Owners can
+    // also drive moderation settings.
+    const groupMetadata = await sock.groupMetadata(groupId);
+    const senderIsAdmin = isAdminInGroupSync(groupMetadata, senderId);
+    const isOwner = msg.key.fromMe || isOwnerJidSync(senderId);
+    if (!senderIsAdmin && !isOwner) {
+      return sock.sendMessage(
+        groupId,
+        { text: "🚫 هذا الأمر للمشرفين فقط." },
+        { quoted: msg }
+      );
+    }
+
+    const command = args[0]?.toLowerCase();
+    const feature = args[1]?.toLowerCase();
+
+    // الحصول على الإعدادات الحالية للجروب أو إنشاء إعدادات افتراضية
+    let settings = getGroupSettings(groupId) || {};
+    if (!settings.moderation) {
+      settings.moderation = JSON.parse(JSON.stringify(defaultModSettings)); // نسخة عميقة
+    }
+
+    const modSettings = settings.moderation;
+
+    switch (command) {
+      case "enable":
+        if (!modSettings.hasOwnProperty(feature)) {
+          return sock.sendMessage(
+            groupId,
+            { text: `⚠️ الميزة "${feature}" غير موجودة.` },
+            { quoted: msg }
+          );
+        }
+        modSettings[feature].enabled = true;
+        saveGroupSettings(groupId, settings);
+        await sock.sendMessage(
+          groupId,
+          { text: `✅ تم تفعيل ميزة *${feature}*.` },
+          { quoted: msg }
+        );
+        break;
+
+      case "disable":
+        if (!modSettings.hasOwnProperty(feature)) {
+          return sock.sendMessage(
+            groupId,
+            { text: `⚠️ الميزة "${feature}" غير موجودة.` },
+            { quoted: msg }
+          );
+        }
+        modSettings[feature].enabled = false;
+        saveGroupSettings(groupId, settings);
+        await sock.sendMessage(
+          groupId,
+          { text: `❌ تم تعطيل ميزة *${feature}*.` },
+          { quoted: msg }
+        );
+        break;
+
+      case "status":
+        let statusText = "📊 *حالة إعدادات المراقبة* 📊\n\n";
+        for (const key in modSettings) {
+          const status = modSettings[key].enabled ? "✅ مفعل" : "❌ معطل";
+          statusText += `› *${key}*: ${status}\n`;
+        }
+        statusText += `\n- لعرض قائمة الكلمات الممنوعة، اكتب: \`!mod words list\``;
+        await sock.sendMessage(groupId, { text: statusText }, { quoted: msg });
+        break;
+
+      case "words":
+        const wordAction = args[1]?.toLowerCase();
+        const word = args.slice(2).join(" ").toLowerCase();
+
+        if (wordAction === "add") {
+          if (!word)
+            return sock.sendMessage(groupId, {
+              text: "الرجاء كتابة الكلمة التي تريد إضافتها.",
+            });
+          modSettings.forbiddenWords.list.push(word);
+          saveGroupSettings(groupId, settings);
+          await sock.sendMessage(groupId, {
+            text: `✅ تم إضافة "${word}" إلى قائمة الكلمات الممنوعة.`,
+          });
+        } else if (wordAction === "remove") {
+          if (!word)
+            return sock.sendMessage(groupId, {
+              text: "الرجاء كتابة الكلمة التي تريد إزالتها.",
+            });
+          modSettings.forbiddenWords.list =
+            modSettings.forbiddenWords.list.filter((w) => w !== word);
+          saveGroupSettings(groupId, settings);
+          await sock.sendMessage(groupId, {
+            text: `🗑️ تم إزالة "${word}" من القائمة.`,
+          });
+        } else if (wordAction === "list") {
+          let listText = "🚫 *قائمة الكلمات الممنوعة* 🚫\n\n";
+          if (modSettings.forbiddenWords.list.length === 0) {
+            listText += "القائمة فارغة حاليًا.";
+          } else {
+            modSettings.forbiddenWords.list.forEach((w, i) => {
+              listText += `${i + 1}. ${w}\n`;
+            });
+          }
+          await sock.sendMessage(groupId, { text: listText });
+        } else {
+          await sock.sendMessage(groupId, {
+            text: "استخدام خاطئ. الأوامر المتاحة: `add`, `remove`, `list`",
+          });
+        }
+        break;
+
+      default:
+        let helpText = "🤖 *أوامر التحكم في المراقبة*\n\n";
+        helpText +=
+          "• `!mod enable <feature>`\nلتفعيل ميزة (antilink, antispam, forbiddenwords)\n\n";
+        helpText += "• `!mod disable <feature>`\nلتعطيل ميزة.\n\n";
+        helpText += "• `!mod status`\nلعرض حالة الميزات الحالية.\n\n";
+        helpText += "• `!mod words add <word>`\nلإضافة كلمة ممنوعة.\n\n";
+        helpText += "• `!mod words remove <word>`\nلإزالة كلمة ممنوعة.\n\n";
+        helpText += "• `!mod words list`\nلعرض قائمة الكلمات الممنوعة.";
+        await sock.sendMessage(groupId, { text: helpText }, { quoted: msg });
+        break;
+    }
+  },
+};

package/src/commands/notes.cjs

@@ -0,0 +1,28 @@
+// file: /commands/notes.js
+const { getAllNotes } = require("../utils/storage.cjs");
+
+module.exports = {
+  name: "notes",
+  description: "Lists all saved note keywords for the group.",
+  usage: "notes",
+  chat: "all",
+
+  async execute(sock, msg) {
+    const groupId = msg.key.remoteJid;
+    const notes = getAllNotes(groupId);
+    const groupNotes = notes[groupId] || {};
+    const keywords = Object.keys(groupNotes);
+
+    if (keywords.length === 0) {
+      return await sock.sendMessage(groupId, {
+        text: "لا توجد ملاحظات محفوظة في هذا الجروب.",
+      });
+    }
+
+    let reply = "*🔑 الكلمات المفتاحية للملاحظات المحفوظة:*\n\n";
+    reply += keywords.map((kw) => `\`#${kw}\``).join("\n");
+    reply += "\n\nللحصول على ملاحظة، استخدم: `!note #keyword`";
+
+    await sock.sendMessage(groupId, { text: reply });
+  },
+};

package/src/commands/perm.cjs

@@ -0,0 +1,236 @@
+// Bot-level roles: owner and admin.
+//
+// Two ways to hand out privileges, as the operator asked:
+//   * manually — `!perm add admin @حد` (or a reply, or a bare number),
+//   * by asking the AI — the agent exposes grant_role/revoke_role and calls
+//     into the very same module (utils/permissions.esm.js).
+//
+// owner : everything, including OWNER_ONLY commands.
+// admin : counts as an admin in every chat (group admin OR this role satisfies
+//         ADMINS_ONLY / ADMINS_OWNER) — but never OWNER_ONLY.
+//
+// Roles live in `user_metadata` (is_owner / is_admin) and in the in-memory
+// roster, so a grant is effective on the very next message — no restart.
+
+const {
+  grantRole,
+  revokeRole,
+  listRoles,
+  isOwnerJidSync,
+} = require("../utils/permissions.cjs");
+const { sendBotMessage } = require("../utils/sendBotMessage.cjs");
+const normalizeJid = require("../utils/normalizeJid.cjs");
+const logger = require("../utils/logger.cjs");
+
+const ROLE_WORDS = {
+  owner: "owner",
+  owners: "owner",
+  مالك: "owner",
+  المالك: "owner",
+  admin: "admin",
+  admins: "admin",
+  مشرف: "admin",
+  ادمن: "admin",
+  أدمن: "admin",
+};
+
+const ADD_WORDS = new Set(["add", "grant", "set", "give", "اضف", "أضف", "ضيف"]);
+const DEL_WORDS = new Set([
+  "remove",
+  "revoke",
+  "del",
+  "delete",
+  "drop",
+  "شيل",
+  "احذف",
+  "امسح",
+]);
+const LIST_WORDS = new Set(["list", "ls", "show", "قائمة", "عرض", "الكل"]);
+
+function senderOf(msg) {
+  return msg.key.remoteJid?.endsWith("@g.us")
+    ? msg.key.participant || msg.key.participantAlt
+    : msg.key.remoteJid;
+}
+
+/**
+ * Work out who the command is about: a mention, a reply, a bare number, or
+ * "me". Returns a normalized JID/LID or null.
+ */
+function resolveTarget(msg, args) {
+  const contextInfo =
+    msg.message?.extendedTextMessage?.contextInfo ||
+    msg.message?.imageMessage?.contextInfo ||
+    msg.message?.videoMessage?.contextInfo ||
+    null;
+
+  const mentioned = contextInfo?.mentionedJid?.[0];
+  if (mentioned) return normalizeJid(mentioned);
+
+  const quotedParticipant =
+    contextInfo?.participant || contextInfo?.participantAlt;
+  if (quotedParticipant) return normalizeJid(quotedParticipant);
+
+  for (const arg of args) {
+    const value = String(arg);
+    if (/^(me|انا|أنا|نفسي)$/i.test(value)) return normalizeJid(senderOf(msg));
+    if (value.includes("@")) return normalizeJid(value);
+    const digits = (value.match(/\d{6,}/) || [])[0];
+    if (digits) return `${digits}@s.whatsapp.net`;
+  }
+  return null;
+}
+
+function labelFor(user) {
+  const name = user.displayName ? `${user.displayName} — ` : "";
+  return `${name}${user.phone || user.jid || user.lid}`;
+}
+
+// permissions.cjs bridges to an ESM module, so every non-`Sync` helper here
+// is async — awaiting them is not optional.
+async function rolesReport() {
+  const { owners, admins, bootstrapOwners, bootstrapAdmins } = await listRoles();
+  const lines = ["*🔑 صلاحيات البوت*", ""];
+
+  lines.push(`*👑 المالكين (${owners.length}):*`);
+  lines.push(
+    owners.length ? owners.map((o) => `• ${labelFor(o)}`).join("\n") : "• (مفيش)"
+  );
+
+  lines.push("", `*🛡️ الأدمنز (${admins.length}):*`);
+  lines.push(
+    admins.length ? admins.map((a) => `• ${labelFor(a)}`).join("\n") : "• (مفيش)"
+  );
+
+  const envOnly = [
+    ...bootstrapOwners.filter(
+      (jid) => !owners.some((o) => o.jid === jid || o.lid === jid)
+    ),
+    ...bootstrapAdmins.filter(
+      (jid) => !admins.some((a) => a.jid === jid || a.lid === jid)
+    ),
+  ];
+  if (envOnly.length) {
+    lines.push(
+      "",
+      `_من الإعدادات (env/config): ${[...new Set(envOnly)].length} إدخال._`
+    );
+  }
+
+  return lines.join("\n");
+}
+
+module.exports = {
+  name: "perm",
+  aliases: ["perms", "owner", "admin", "role", "roles", "صلاحيات"],
+  description:
+    "إدارة صلاحيات البوت: إضافة/إزالة مالك أو أدمن، وعرض القائمة الحالية.",
+  usage:
+    "perm list\nperm add admin @عضو\nperm add owner <رقم>\nperm remove admin @عضو",
+  chat: "all",
+
+  async execute(sock, msg, args) {
+    const jid = msg.key.remoteJid;
+    const action = String(args[0] || "").toLowerCase();
+
+    if (!action || LIST_WORDS.has(action)) {
+      return sendBotMessage(
+        sock,
+        jid,
+        { text: await rolesReport() },
+        { replyTo: msg }
+      );
+    }
+
+    const isAdd = ADD_WORDS.has(action);
+    const isRemove = DEL_WORDS.has(action);
+    if (!isAdd && !isRemove) {
+      return sendBotMessage(
+        sock,
+        jid,
+        {
+          text:
+            "استخدام غير صحيح.\n\n" +
+            "`!perm list` — القائمة الحالية\n" +
+            "`!perm add admin @عضو` — تعيين أدمن\n" +
+            "`!perm add owner <رقم>` — تعيين مالك\n" +
+            "`!perm remove admin @عضو` — سحب الصلاحية",
+        },
+        { replyTo: msg }
+      );
+    }
+
+    // Role word is optional and can sit anywhere; default to admin (the safer
+    // of the two) so `!perm add @حد` doesn't hand out ownership by accident.
+    let role = "admin";
+    for (const arg of args.slice(1)) {
+      const word = ROLE_WORDS[String(arg).toLowerCase()];
+      if (word) {
+        role = word;
+        break;
+      }
+    }
+
+    const target = resolveTarget(msg, args.slice(1));
+    if (!target) {
+      return sendBotMessage(
+        sock,
+        jid,
+        {
+          text:
+            "محتاج تحدد الشخص: منشن (@) أو رد على رسالته أو اكتب رقمه.\n" +
+            "مثال: `!perm add admin @عضو`",
+        },
+        { replyTo: msg }
+      );
+    }
+
+    // Only an owner may create another owner. (Reaching this command at all
+    // already requires OWNER_ONLY by default — this is the belt to that
+    // brace, and it also guards direct calls from elsewhere.)
+    const sender = senderOf(msg);
+    if (role === "owner" && !msg.key.fromMe && !isOwnerJidSync(sender)) {
+      return sendBotMessage(
+        sock,
+        jid,
+        { text: "🚫 تعيين مالك جديد للمالك فقط." },
+        { replyTo: msg }
+      );
+    }
+
+    try {
+      const record = isAdd
+        ? await grantRole(target, role)
+        : await revokeRole(target, role);
+      const who = record ? labelFor(record) : target;
+      const roleLabel = role === "owner" ? "مالك 👑" : "أدمن 🛡️";
+
+      logger.info(
+        { target, role, granted: isAdd, by: sender },
+        "[perm] role change"
+      );
+
+      return sendBotMessage(
+        sock,
+        jid,
+        {
+          text: isAdd
+            ? `✅ تم تعيين *${who}* كـ *${roleLabel}*.`
+            : `✅ تم سحب صلاحية *${roleLabel}* من *${who}*.`,
+          mentions: target.includes("@") ? [target] : undefined,
+        },
+        { replyTo: msg }
+      );
+    } catch (error) {
+      logger.error({ err: error }, "[perm] role change failed");
+      return sendBotMessage(
+        sock,
+        jid,
+        {
+          text: `❌ *مقدرتش أعدّل الصلاحية*\n\n*التفاصيل:* ${error.message}`,
+        },
+        { replyTo: msg }
+      );
+    }
+  },
+};

package/src/commands/ping.cjs

@@ -0,0 +1,17 @@
+// file: /commands/ping.js
+
+module.exports = {
+  name: "ping",
+  description: "A simple command to check if the bot is responsive.",
+  usage: "ping",
+  chat: "all", // <-- الخاصية الجديدة. يمكن أن تكون 'group' أو 'private'
+
+  async execute(sock, msg) {
+    // The bot will reply with "Pong!" and quote the original message
+    await sock.sendMessage(
+      msg.key.remoteJid,
+      { text: "Pong! 🏓" },
+      { quoted: msg }
+    );
+  },
+};

package/src/commands/poll.cjs

@@ -0,0 +1,80 @@
+// استفتاء — !poll
+//
+//   !poll نروح فين النهاردة؟ | السينما | البحر | نقعد في البيت
+//   !poll --multi اختر أكلك | كشري | فراخ | بيتزا     (يسمح بأكتر من اختيار)
+//
+// Sends a native WhatsApp poll (not a text list), so members vote with a tap
+// and WhatsApp counts the results.
+
+const { sendBotMessage } = require("../utils/sendBotMessage.cjs");
+
+const MIN_OPTIONS = 2;
+const MAX_OPTIONS = 12; // WhatsApp's own ceiling
+const MAX_QUESTION_CHARS = 255;
+const MAX_OPTION_CHARS = 100;
+
+const MULTI_FLAGS = new Set(["--multi", "-m", "متعدد"]);
+
+const HELP_TEXT =
+  "📊 *استفتاء*\n\n" +
+  "*الاستخدام:*\n" +
+  "`!poll <السؤال> | <خيار> | <خيار> ...`\n\n" +
+  "*خيارات:*\n" +
+  "`--multi` يسمح باختيار أكتر من إجابة\n\n" +
+  "*مثال:*\n" +
+  "`!poll نروح فين؟ | السينما | البحر | البيت`\n\n" +
+  `_من ${MIN_OPTIONS} لـ ${MAX_OPTIONS} خيارات._`;
+
+module.exports = {
+  name: "poll",
+  aliases: ["vote", "استفتاء", "تصويت"],
+  description: "ينشئ استفتاء (تصويت) داخل الشات.",
+  usage: "poll <السؤال> | <خيار1> | <خيار2> [| ...] [--multi]",
+  chat: "all",
+
+  async execute(sock, msg, args) {
+    const chatId = msg.key.remoteJid;
+    const reply = (text) => sendBotMessage(sock, chatId, { text }, { replyTo: msg });
+
+    let multi = false;
+    const rest = args.filter((arg) => {
+      if (MULTI_FLAGS.has(arg.toLowerCase())) {
+        multi = true;
+        return false;
+      }
+      return true;
+    });
+
+    const parts = rest
+      .join(" ")
+      .split(/\s*[|،]\s*/)
+      .map((part) => part.trim())
+      .filter(Boolean);
+
+    if (parts.length < MIN_OPTIONS + 1) return reply(HELP_TEXT);
+
+    const question = parts[0].slice(0, MAX_QUESTION_CHARS);
+    // WhatsApp rejects a poll with duplicate options.
+    const options = [...new Set(parts.slice(1).map((o) => o.slice(0, MAX_OPTION_CHARS)))];
+
+    if (options.length < MIN_OPTIONS) {
+      return reply("❌ محتاج خيارين مختلفين على الأقل.");
+    }
+    if (options.length > MAX_OPTIONS) {
+      return reply(`❌ الحد الأقصى ${MAX_OPTIONS} خيار (انت كاتب ${options.length}).`);
+    }
+
+    return sendBotMessage(
+      sock,
+      chatId,
+      {
+        poll: {
+          name: question,
+          values: options,
+          selectableCount: multi ? options.length : 1,
+        },
+      },
+      { replyTo: msg }
+    );
+  },
+};

package/src/commands/prayer.cjs

@@ -0,0 +1,64 @@
+// Simple time formatter (inline replacement for deleted formatTime module)
+function formatTime12Hour(time24) {
+  const [hours, minutes] = time24.split(":");
+  const hour = parseInt(hours);
+  const ampm = hour >= 12 ? "PM" : "AM";
+  const hour12 = hour % 12 || 12;
+  return `${hour12}:${minutes} ${ampm}`;
+}
+
+const axios = require("axios");
+const logger = require("../utils/logger.cjs");
+
+module.exports = {
+  name: "prayer",
+  description: "Gets prayer times for a specific city.",
+  usage: "prayer <المدينة بالإنجليزية>",
+  chat: "all", // This command can be used anywhere
+
+  async execute(sock, msg, args) {
+    // 2. Check if the user provided a city name
+    if (!args || args.length === 0) {
+      return await sock.sendMessage(msg.key.remoteJid, {
+        text: "يرجى تقديم اسم المدينة باللغة الانجليزية.\n\nمثال:* `!prayer cairo`",
+      });
+    }
+
+    // 3. Join the arguments to form the city name (in case it's multi-word like "New York")
+    const city = args.join(" ");
+
+    // 4. We will build the API URL here once you provide it
+    const API_URL = `https://api.aladhan.com/v1/timingsByCity/06-06-2025?city=${city}&country=EG&state=Egypt&method=5&shafaq=general&tune=5&timezonestring=Africa%2FCairo&calendarMethod=UAQ`;
+
+    try {
+      await sock.sendMessage(msg.key.remoteJid, {
+        text: "يتم جلب البيانات...",
+      });
+      // 5. We will make the API call using axios
+      const response = await axios.get(API_URL);
+      // 6. We will parse the prayer timings from the response data
+      const timings = response.data.data.timings;
+
+      // 7. We will format the reply message
+      const reply =
+        `*مواقيت الصلاة لمدينة ${city}:*\n\n` +
+        `الفجر: ${formatTime12Hour(timings.Fajr)}\n` +
+        `الشروق: ${formatTime12Hour(timings.Sunrise)}\n` +
+        `الظهر: ${formatTime12Hour(timings.Dhuhr)}\n` +
+        `العصر: ${formatTime12Hour(timings.Asr)}\n` +
+        `المغرب: ${formatTime12Hour(timings.Maghrib)}\n` +
+        `العشاء: ${formatTime12Hour(timings.Isha)}`;
+
+      // 8. Send the formatted message
+      await sock.sendMessage(msg.key.remoteJid, {
+        text: reply,
+      });
+    } catch (error) {
+      logger.error(error.message, "[Error] in Prayer API:");
+      // 9. Handle errors, like city not found or API failure
+      await sock.sendMessage(msg.key.remoteJid, {
+        text: `عذراً، لم أتمكن من العثور على وقت الصلاة في "${city}". يرجى التحقق من اسم المدينة ومحاولة مرة أخرى.`,
+      });
+    }
+  },
+};

package/src/commands/qr.cjs

@@ -0,0 +1,39 @@
+// file: /commands/qr.js
+const qrcode = require("qrcode");
+const logger = require("../utils/logger.cjs");
+
+module.exports = {
+  name: "qr",
+  description: "Generates a QR code from text.",
+  usage: "qr <نص|رابط>",
+  chat: "all",
+
+  async execute(sock, msg, args) {
+    const remoteJid = msg.key.remoteJid;
+    const textToEncode = args.join(" ");
+
+    if (!textToEncode) {
+      return await sock.sendMessage(remoteJid, {
+        text: "يرجى كتابة النص أو الرابط الذي تريد تحويله بعد الأمر.\n*مثال:*\n`!qr https://google.com`",
+      });
+    }
+
+    try {
+      // Generate the QR code and get it as a Buffer (raw image data)
+      const qrImageBuffer = await qrcode.toBuffer(textToEncode, {
+        errorCorrectionLevel: "H", // High error correction
+      });
+
+      // Send the image buffer as a photo
+      await sock.sendMessage(remoteJid, {
+        image: qrImageBuffer,
+        caption: `*QR Code for:*\n\`\`\`${textToEncode}\`\`\``,
+      });
+    } catch (error) {
+      logger.error({ err: error }, "Failed to generate QR code");
+      await sock.sendMessage(remoteJid, {
+        text: "حدث خطأ أثناء إنشاء QR code.",
+      });
+    }
+  },
+};