levix-bot 3.3.0-rc.2 → 4.0.0-beta

package/src/utils/memory.cjs

@@ -208,7 +208,9 @@ function listMemory({ scope = "chat", chatId } = {}) {
  */
 function addMemory({ scope = "chat", chatId, content, by, chatName } = {}) {
   const normalizedScope = normalizeScope(scope);
-  const text = String(content || "").trim().slice(0, MAX_ENTRY_CHARS);
+  const text = String(content || "")
+    .trim()
+    .slice(0, MAX_ENTRY_CHARS);
   if (!text) throw new Error("مفيش محتوى أحفظه");
 
   const filePath = memoryFilePath(normalizedScope, chatId);
@@ -236,10 +238,7 @@ function addMemory({ scope = "chat", chatId, content, by, chatName } = {}) {
   ].join("\n");
 
   writeRaw(filePath, `${raw}${body}\n`);
-  logger.info(
-    { scope: normalizedScope, chatId, id },
-    "[memory] saved a new entry"
-  );
+  logger.info({ scope: normalizedScope, chatId, id }, "[memory] saved a new entry");
   return { id, content: text, scope: normalizedScope, file: filePath };
 }
 
@@ -292,9 +291,44 @@ function clearMemory({ scope = "chat", chatId } = {}) {
   return entries.length;
 }
 
+/**
+ * Remove account-derived AI memory when the WhatsApp account is unlinked.
+ * A later pairing is a different security principal, so neither chat files nor
+ * global facts may silently cross that account boundary.
+ */
+function clearAllMemoryFiles() {
+  let removed = 0;
+  try {
+    if (fs.existsSync(GLOBAL_FILE)) {
+      fs.unlinkSync(GLOBAL_FILE);
+      removed += 1;
+    }
+  } catch (err) {
+    logger.warn({ err }, "[memory] failed to remove global memory during unlink");
+  }
+
+  try {
+    if (fs.existsSync(CHATS_DIR)) {
+      for (const name of fs.readdirSync(CHATS_DIR)) {
+        if (!name.endsWith(".md")) continue;
+        const filePath = path.join(CHATS_DIR, name);
+        const stat = fs.lstatSync(filePath);
+        if (!stat.isFile() || stat.isSymbolicLink()) continue;
+        fs.unlinkSync(filePath);
+        removed += 1;
+      }
+    }
+  } catch (err) {
+    logger.warn({ err }, "[memory] failed to remove chat memory during unlink");
+  }
+  return removed;
+}
+
 /** Case-insensitive substring search across one scope. */
 function searchMemory(query, { scope = "chat", chatId } = {}) {
-  const needle = String(query || "").trim().toLowerCase();
+  const needle = String(query || "")
+    .trim()
+    .toLowerCase();
   const entries = listMemory({ scope, chatId });
   if (!needle) return entries;
   return entries.filter((entry) => entry.content.toLowerCase().includes(needle));
@@ -326,16 +360,11 @@ function buildMemoryContext(chatId, { limitChars = maxContextChars() } = {}) {
   const blocks = [];
 
   if (globalEntries.length) {
-    blocks.push(
-      `### ذاكرة عامة (global.md)\n${renderEntries(globalEntries, perScope)}`
-    );
+    blocks.push(`### ذاكرة عامة (global.md)\n${renderEntries(globalEntries, perScope)}`);
   }
   if (chatEntries.length) {
     blocks.push(
-      `### ذاكرة المحادثة دي (${safeFileName(chatId)}.md)\n${renderEntries(
-        chatEntries,
-        perScope
-      )}`
+      `### ذاكرة المحادثة دي (${safeFileName(chatId)}.md)\n${renderEntries(chatEntries, perScope)}`,
     );
   }
 
@@ -378,6 +407,7 @@ module.exports = {
   addMemory,
   removeMemory,
   clearMemory,
+  clearAllMemoryFiles,
   searchMemory,
   buildMemoryContext,
   memoryStats,

package/src/utils/messageContent.cjs

@@ -0,0 +1,40 @@
+// Unwrap WhatsApp envelopes the same way command routing already does for
+// captions: view-once / ephemeral / document-caption / SKDM-first.
+
+function unwrapMessage(message) {
+  let inner = message || {};
+  for (let i = 0; i < 6; i++) {
+    if (inner.viewOnceMessage?.message) inner = inner.viewOnceMessage.message;
+    else if (inner.viewOnceMessageV2?.message) inner = inner.viewOnceMessageV2.message;
+    else if (inner.viewOnceMessageV2Extension?.message) inner = inner.viewOnceMessageV2Extension.message;
+    else if (inner.ephemeralMessage?.message) inner = inner.ephemeralMessage.message;
+    else if (inner.documentWithCaptionMessage?.message) inner = inner.documentWithCaptionMessage.message;
+    else if (inner.editedMessage?.message) inner = inner.editedMessage.message;
+    else break;
+  }
+  return inner;
+}
+
+function visibleText(message) {
+  const inner = unwrapMessage(message);
+  return (
+    inner.conversation ||
+    inner.extendedTextMessage?.text ||
+    inner.imageMessage?.caption ||
+    inner.videoMessage?.caption ||
+    inner.documentMessage?.caption ||
+    ""
+  );
+}
+
+const MEDIA_KEYS = ["imageMessage", "videoMessage", "stickerMessage", "audioMessage", "documentMessage"];
+
+function mediaType(message) {
+  const inner = unwrapMessage(message);
+  for (const key of MEDIA_KEYS) {
+    if (inner[key]) return key.replace("Message", "").toLowerCase();
+  }
+  return "";
+}
+
+module.exports = { unwrapMessage, visibleText, mediaType };

package/src/utils/normalizeJid.esm.js

@@ -3,17 +3,17 @@ export default function normalizeJid(jid) {
   if (!jid) return jid;
 
   // V7: Handle LID format (@lid)
-  if (jid.includes('@lid')) {
+  if (jid.includes("@lid")) {
     // LID format: keep as-is
-    if (jid.includes(':')) {
-      return jid.split(':')[0] + '@lid';
+    if (jid.includes(":")) {
+      return jid.split(":")[0] + "@lid";
     }
     return jid;
   }
 
   // Handle PN format (@s.whatsapp.net)
-  if (jid.includes(':')) {
-    return jid.split(':')[0] + '@' + jid.split('@')[1];
+  if (jid.includes(":")) {
+    return jid.split(":")[0] + "@" + jid.split("@")[1];
   }
 
   return jid;
@@ -22,13 +22,13 @@ export default function normalizeJid(jid) {
 // V7: Helper to check if JID is a Phone Number (PN)
 export function isPnJid(jid) {
   if (!jid) return false;
-  return jid.includes('@s.whatsapp.net');
+  return jid.includes("@s.whatsapp.net");
 }
 
 // V7: Helper to check if JID is a LID
 export function isLidJid(jid) {
   if (!jid) return false;
-  return jid.includes('@lid');
+  return jid.includes("@lid");
 }
 
 // V7: Helper to check if JID is a user (either PN or LID)

package/src/utils/numerals.cjs

@@ -0,0 +1,75 @@
+// Digit-script conversion: Western 0-9 <-> Eastern Arabic / Persian.
+
+const ARABIC_DIGITS = ["٠", "١", "٢", "٣", "٤", "٥", "٦", "٧", "٨", "٩"];
+const PERSIAN_DIGITS = ["۰", "۱", "۲", "۳", "۴", "۵", "۶", "۷", "۸", "۹"];
+const ENGLISH_DIGITS = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];
+
+function convertNumerals(text, targetLang) {
+  if (!text || typeof text !== "string") return text;
+
+  if (targetLang === "ar") {
+    return text.replace(/[0-9]/g, (d) => ARABIC_DIGITS[parseInt(d, 10)]);
+  }
+
+  if (targetLang === "en") {
+    let result = text;
+    for (let i = 0; i < 10; i++) {
+      result = result.split(ARABIC_DIGITS[i]).join(ENGLISH_DIGITS[i]);
+      result = result.split(PERSIAN_DIGITS[i]).join(ENGLISH_DIGITS[i]);
+    }
+    return result;
+  }
+
+  return text;
+}
+
+function classifyNumerals(text) {
+  const source = String(text || "");
+  const hasEn = /[0-9]/.test(source);
+  const hasAr = /[٠-٩۰-۹]/.test(source);
+  if (hasEn && hasAr) return "mixed";
+  if (hasEn) return "en";
+  if (hasAr) return "ar";
+  return "none";
+}
+
+function oppositeNumeralLang(kind) {
+  if (kind === "en") return "ar";
+  if (kind === "ar") return "en";
+  return null;
+}
+
+function getQuotedText(msg) {
+  const quoted = msg.message?.extendedTextMessage?.contextInfo?.quotedMessage;
+  if (!quoted) return null;
+  return (
+    quoted.conversation ||
+    quoted.extendedTextMessage?.text ||
+    quoted.imageMessage?.caption ||
+    quoted.videoMessage?.caption ||
+    null
+  );
+}
+
+function isExplicitAr(token) {
+  const t = String(token || "")
+    .toLowerCase()
+    .trim();
+  return t === "ar" || t === "عربي" || t === "ع";
+}
+
+function isExplicitEn(token) {
+  const t = String(token || "")
+    .toLowerCase()
+    .trim();
+  return t === "en" || t === "انجليزي" || t === "إنجليزي";
+}
+
+module.exports = {
+  convertNumerals,
+  classifyNumerals,
+  oppositeNumeralLang,
+  getQuotedText,
+  isExplicitAr,
+  isExplicitEn,
+};

package/src/utils/permissions.esm.js

@@ -32,18 +32,15 @@
 //   sameUser(a, b)
 //     True if two identifiers refer to the same person (LID/PN/phone equiv).
 
-import normalizeJid, {
-  isLidJid,
-  isPnJid,
-} from "./normalizeJid.esm.js";
+import normalizeJid, { isLidJid, isPnJid } from "./normalizeJid.esm.js";
 import {
-  getAllOwners,
-  getAllBotAdmins,
-  isUserOwner as dbIsOwner,
   isUserBotAdmin as dbIsBotAdmin,
-  setUserRole,
+  isUserOwner as dbIsOwner,
+  getAllBotAdmins,
+  getAllOwners,
   getLidForPn,
   getPnForLid,
+  setUserRole,
 } from "./storage.esm.js";
 
 // Two rosters, same mechanics:
@@ -96,7 +93,9 @@ export function getBootstrapOwners() {
 export function bootstrapAdmins(values) {
   bootstrapAdminSet.clear();
   if (!Array.isArray(values)) return;
-  values.forEach((value) => pushInto(bootstrapAdminSet, value));
+  values.forEach((value) => {
+    pushInto(bootstrapAdminSet, value);
+  });
 }
 
 export function addBootstrapAdmin(value) {
@@ -162,9 +161,7 @@ function hasRole(jid, { set, dbCheck, listAll }) {
     try {
       for (const entry of listAll()) {
         const entryPhone =
-          digitsOnly(entry.phone) ||
-          digitsOnly(entry.jid) ||
-          digitsOnly(entry.lid);
+          digitsOnly(entry.phone) || digitsOnly(entry.jid) || digitsOnly(entry.lid);
         if (entryPhone && entryPhone === phone) return true;
       }
     } catch {}
@@ -308,9 +305,7 @@ export function isAdminInGroup(groupMetadata, jid) {
   return groupMetadata.participants.some((p) => {
     if (!["admin", "superadmin"].includes(p.admin)) return false;
     const participantIds = [p.id, p.lid, p.phoneNumber, p.jid].filter(Boolean);
-    return participantIds.some(
-      (pid) => normalizeJid(pid) === target || sameUser(pid, jid)
-    );
+    return participantIds.some((pid) => normalizeJid(pid) === target || sameUser(pid, jid));
   });
 }
 

package/src/utils/providerUrl.cjs

@@ -0,0 +1,281 @@
+// Security boundary for operator-configured AI provider endpoints.
+//
+// Local loopback is an intentional product feature (Ollama / LM Studio and
+// local compatibility gateways). Other private, link-local, metadata,
+// multicast, and reserved destinations must never receive a vaulted API key.
+
+const dns = require("node:dns").promises;
+const net = require("node:net");
+const { Agent, fetch: undiciFetch, Response: UndiciResponse } = require("undici");
+
+function ipv4Bytes(host) {
+  const parts = String(host).split(".");
+  if (
+    parts.length !== 4 ||
+    !parts.every((part) => /^\d{1,3}$/.test(part) && Number(part) <= 255)
+  ) {
+    return null;
+  }
+  return parts.map(Number);
+}
+
+function ipv6Bytes(host) {
+  let value = String(host).toLowerCase().split("%")[0];
+  const dotted = value.match(/(?:^|:)(\d+\.\d+\.\d+\.\d+)$/)?.[1];
+  if (dotted) {
+    const bytes = ipv4Bytes(dotted);
+    if (!bytes) return null;
+    value = value.slice(0, -dotted.length) + `${(bytes[0] << 8) | bytes[1]}:${
+      (bytes[2] << 8) | bytes[3]
+    }`;
+  }
+
+  const halves = value.split("::");
+  if (halves.length > 2) return null;
+  const left = halves[0] ? halves[0].split(":") : [];
+  const right = halves[1] ? halves[1].split(":") : [];
+  const missing = 8 - left.length - right.length;
+  if (missing < 0 || (halves.length === 1 && missing !== 0)) return null;
+  const words = [...left, ...Array(missing).fill("0"), ...right];
+  if (words.length !== 8 || !words.every((word) => /^[0-9a-f]{1,4}$/.test(word))) return null;
+
+  const out = [];
+  for (const word of words) {
+    const number = Number.parseInt(word, 16);
+    out.push(number >> 8, number & 0xff);
+  }
+  return out;
+}
+
+function isIpv4Loopback(bytes) {
+  return bytes?.[0] === 127;
+}
+
+function isForbiddenIpv4(bytes, { allowLoopback = false } = {}) {
+  if (!bytes) return true;
+  const [a, b] = bytes;
+  if (isIpv4Loopback(bytes)) return !allowLoopback;
+  return (
+    a === 0 ||
+    a === 10 ||
+    (a === 100 && b >= 64 && b <= 127) ||
+    (a === 169 && b === 254) ||
+    (a === 172 && b >= 16 && b <= 31) ||
+    (a === 192 && b === 168) ||
+    (a === 198 && (b === 18 || b === 19)) ||
+    a >= 224
+  );
+}
+
+function embeddedIpv4(bytes) {
+  if (!bytes || bytes.length !== 16) return null;
+  const prefixIsZero = bytes.slice(0, 10).every((byte) => byte === 0);
+  if (prefixIsZero && bytes[10] === 0xff && bytes[11] === 0xff) return bytes.slice(12);
+  const translatedPrefix =
+    bytes.slice(0, 8).every((byte) => byte === 0) &&
+    bytes[8] === 0xff &&
+    bytes[9] === 0xff &&
+    bytes[10] === 0 &&
+    bytes[11] === 0;
+  if (translatedPrefix) return bytes.slice(12);
+
+  if (
+    bytes[0] === 0x00 &&
+    bytes[1] === 0x64 &&
+    bytes[2] === 0xff &&
+    bytes[3] === 0x9b &&
+    (bytes.slice(4, 12).every((byte) => byte === 0) ||
+      (bytes[4] === 0 && bytes[5] === 1 && bytes.slice(6, 12).every((byte) => byte === 0)))
+  ) {
+    return bytes.slice(12);
+  }
+  return null;
+}
+
+function isIpv6Loopback(bytes) {
+  return bytes?.slice(0, 15).every((byte) => byte === 0) && bytes[15] === 1;
+}
+
+function isForbiddenIpv6(bytes, { allowLoopback = false } = {}) {
+  if (!bytes) return true;
+  if (isIpv6Loopback(bytes)) return !allowLoopback;
+  if (bytes.every((byte) => byte === 0)) return true;
+
+  const embedded = embeddedIpv4(bytes);
+  if (embedded) return isForbiddenIpv4(embedded, { allowLoopback });
+
+  const first = bytes[0];
+  const second = bytes[1];
+  if ((first & 0xfe) === 0xfc) return true;
+  if (first === 0xfe && (second & 0xc0) === 0x80) return true;
+  if (first === 0xfe && (second & 0xc0) === 0xc0) return true;
+  if (first === 0xff) return true;
+  if (first === 0x20 && second === 0x02) return true;
+  return false;
+}
+
+function isForbiddenIp(host, options = {}) {
+  const family = net.isIP(host);
+  if (family === 4) return isForbiddenIpv4(ipv4Bytes(host), options);
+  if (family === 6) return isForbiddenIpv6(ipv6Bytes(host), options);
+  return false;
+}
+
+function parseProviderUrl(raw, { allowLoopback = true, allowQuery = false } = {}) {
+  const text = String(raw ?? "").trim();
+  if (!text) throw new Error("Base URL is required");
+
+  let url;
+  try {
+    url = new URL(text);
+  } catch {
+    throw new Error("Base URL must be a valid http(s) URL");
+  }
+  if (!/^https?:$/.test(url.protocol)) throw new Error("Base URL must be http or https");
+  if (!url.hostname) throw new Error("Base URL must include a host");
+  if (url.username || url.password) throw new Error("Base URL cannot contain credentials");
+  if ((!allowQuery && url.search) || url.hash) {
+    throw new Error("Base URL cannot contain a query or fragment");
+  }
+
+  const host = url.hostname.replace(/^\[|\]$/g, "").toLowerCase();
+  const isLoopback =
+    host === "localhost" ||
+    (net.isIP(host) === 4 && isIpv4Loopback(ipv4Bytes(host))) ||
+    (net.isIP(host) === 6 && isIpv6Loopback(ipv6Bytes(host)));
+
+  if (/^(metadata|metadata\.google\.internal|instance-data)$/i.test(host)) {
+    throw new Error("Base URL cannot point at cloud metadata");
+  }
+  if (net.isIP(host) && isForbiddenIp(host, { allowLoopback })) {
+    throw new Error("Base URL cannot point at a private, link-local, or reserved address");
+  }
+  if (isLoopback && !allowLoopback) throw new Error("Loopback provider URLs are not allowed");
+  if (url.protocol === "http:" && !isLoopback) {
+    throw new Error("Public provider URLs must use HTTPS");
+  }
+  return url;
+}
+
+function assertProviderBaseUrl(raw, options = {}) {
+  const url = parseProviderUrl(raw, options);
+  return url.toString().replace(/\/+$/, "");
+}
+
+async function resolveProviderRequestUrl(raw, options = {}) {
+  const url = parseProviderUrl(raw, { ...options, allowQuery: true });
+  const host = url.hostname.replace(/^\[|\]$/g, "").toLowerCase();
+  if (net.isIP(host)) {
+    return { url, host, addresses: [{ address: host, family: net.isIP(host) }] };
+  }
+
+  let answers;
+  try {
+    answers = await dns.lookup(host, { all: true, verbatim: true });
+  } catch {
+    throw new Error("Provider host could not be resolved");
+  }
+  const explicitLocalhost = host === "localhost";
+  if (
+    !answers.length ||
+    answers.some(({ address }) =>
+      isForbiddenIp(address, { allowLoopback: explicitLocalhost && options.allowLoopback !== false }),
+    )
+  ) {
+    throw new Error("Provider host resolves to a private, link-local, or reserved address");
+  }
+  return { url, host, addresses: answers };
+}
+
+async function assertProviderRequestUrl(raw, options = {}) {
+  const { url } = await resolveProviderRequestUrl(raw, options);
+  return url;
+}
+
+function pinnedLookup(expectedHost, addresses) {
+  return (hostname, lookupOptions, callback) => {
+    if (String(hostname).toLowerCase() !== expectedHost) {
+      const error = new Error("Provider connection attempted an unexpected host");
+      error.code = "EAI_FAIL";
+      return callback(error);
+    }
+    const requestedFamily =
+      typeof lookupOptions === "number" ? lookupOptions : lookupOptions?.family;
+    const candidates = requestedFamily
+      ? addresses.filter(({ family }) => family === requestedFamily)
+      : addresses;
+    if (!candidates.length) {
+      const error = new Error("Provider host has no address in the requested family");
+      error.code = "EAI_ADDRFAMILY";
+      return callback(error);
+    }
+    if (typeof lookupOptions === "object" && lookupOptions?.all) {
+      return callback(null, candidates.map(({ address, family }) => ({ address, family })));
+    }
+    return callback(null, candidates[0].address, candidates[0].family);
+  };
+}
+
+function responseWithDispatcherCleanup(response, dispatcher) {
+  let released = false;
+  const release = (destroy = false) => {
+    if (released) return;
+    released = true;
+    const done = destroy ? dispatcher.destroy() : dispatcher.close();
+    Promise.resolve(done).catch(() => dispatcher.destroy());
+  };
+
+  if (!response.body) {
+    release();
+    return response;
+  }
+
+  const reader = response.body.getReader();
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const chunk = await reader.read();
+        if (chunk.done) {
+          controller.close();
+          release();
+        } else {
+          controller.enqueue(chunk.value);
+        }
+      } catch (error) {
+        controller.error(error);
+        release(true);
+      }
+    },
+    async cancel(reason) {
+      try {
+        await reader.cancel(reason);
+      } finally {
+        release(true);
+      }
+    },
+  });
+  return new UndiciResponse(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers,
+  });
+}
+
+async function safeProviderFetch(raw, init = {}, options = {}) {
+  const { url, host, addresses } = await resolveProviderRequestUrl(raw, options);
+  const dispatcher = new Agent({ connect: { lookup: pinnedLookup(host, addresses) } });
+  try {
+    const response = await undiciFetch(url, { ...init, redirect: "manual", dispatcher });
+    return responseWithDispatcherCleanup(response, dispatcher);
+  } catch (error) {
+    Promise.resolve(dispatcher.destroy()).catch(() => {});
+    throw error;
+  }
+}
+
+module.exports = {
+  assertProviderBaseUrl,
+  assertProviderRequestUrl,
+  safeProviderFetch,
+  isForbiddenIp,
+};

package/src/utils/recurrence.cjs

@@ -44,15 +44,7 @@ const DAY_ALIASES = new Map([
   ["سبت", 6],
 ]);
 
-const WEEKDAYS = [
-  "Sunday",
-  "Monday",
-  "Tuesday",
-  "Wednesday",
-  "Thursday",
-  "Friday",
-  "Saturday",
-];
+const WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
 
 function normalizeDay(value) {
   return String(value ?? "")
@@ -84,7 +76,9 @@ function parseTime(value) {
 }
 
 function parseRecurringArgs(args) {
-  const type = String(args[0] ?? "").trim().toLowerCase();
+  const type = String(args[0] ?? "")
+    .trim()
+    .toLowerCase();
 
   if (type === "daily") {
     const time = parseTime(args[1]);
@@ -120,7 +114,9 @@ function parseRecurringArgs(args) {
 
 function describeScheduledJob(job, timezone) {
   if (job.type === "recurring") {
-    const parts = String(job.cronString ?? "").trim().split(/\s+/);
+    const parts = String(job.cronString ?? "")
+      .trim()
+      .split(/\s+/);
     if (parts.length === 5) {
       const [minuteText, hourText, dayOfMonth, month, dayText] = parts;
       const minute = Number(minuteText);

package/src/utils/sendBotMessage.esm.js

@@ -69,13 +69,7 @@ async function safePresence(sock, jid, presence) {
  * @returns {Promise<object>} Baileys send result
  */
 export async function sendBotMessage(sock, jid, content, options = {}) {
-  const {
-    replyTo = null,
-    quoted = null,
-    quote = true,
-    typing = true,
-    delayMs,
-  } = options;
+  const { replyTo = null, quoted = null, quote = true, typing = true, delayMs } = options;
 
   // Respect the per-chat cooldown so multiple replies don't pile up instantly.
   const now = Date.now();
@@ -109,7 +103,7 @@ export async function sendBotMessage(sock, jid, content, options = {}) {
   } catch (err) {
     logger.error(
       { err, jid, contentKeys: Object.keys(content || {}) },
-      "[sendBotMessage] sock.sendMessage failed"
+      "[sendBotMessage] sock.sendMessage failed",
     );
     throw err;
   }
@@ -127,12 +121,8 @@ export async function sendBotMessage(sock, jid, content, options = {}) {
  */
 export async function sendBotError(sock, jid, err, arabicLead = "حدث خطأ", options = {}) {
   const name = err?.name || (typeof err === "string" ? "Error" : "Error");
-  const message =
-    err?.message || (typeof err === "string" ? err : JSON.stringify(err));
-  const text = `❌ *${arabicLead}*\n\n*النوع:* \`${name}\`\n*التفاصيل:* ${message}`.slice(
-    0,
-    1500
-  );
+  const message = err?.message || (typeof err === "string" ? err : JSON.stringify(err));
+  const text = `❌ *${arabicLead}*\n\n*النوع:* \`${name}\`\n*التفاصيل:* ${message}`.slice(0, 1500);
   return sendBotMessage(sock, jid, { text }, options);
 }