@prototypevip/baileys 0.0.7 → 0.0.9

package/lib/AntiBan/cli.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+/**
+ * baileys-antiban CLI
+ * Usage: npx baileys-antiban <command> [options]
+ */
+import * as fs from 'fs';
+import { StateManager } from './persist.js';
+import { resolveConfig } from './presets.js';
+import { applyPatch, unpatchFile } from './patch.js';
+const args = process.argv.slice(2);
+const command = args[0];
+function parseArgs(argv) {
+    const result = {};
+    for (let i = 1; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg.startsWith('--')) {
+            const key = arg.slice(2);
+            const next = argv[i + 1];
+            if (next && !next.startsWith('--')) {
+                result[key] = next;
+                i++;
+            }
+            else {
+                result[key] = true;
+            }
+        }
+    }
+    return result;
+}
+function cmdStatus(opts) {
+    const statePath = opts['state'];
+    let warmupInfo = 'No state file (in-memory mode)';
+    let savedAt = 'N/A';
+    if (statePath) {
+        const mgr = new StateManager(statePath);
+        const state = mgr.load();
+        if (state) {
+            const now = Date.now();
+            const dayMs = 86400000;
+            const currentDay = Math.floor((now - state.warmup.startedAt) / dayMs);
+            warmupInfo = state.warmup.graduated
+                ? 'Graduated (warmup complete)'
+                : `Day ${currentDay + 1}, sent today: ${state.warmup.dailyCounts[currentDay] || 0}`;
+            savedAt = new Date(state.savedAt).toISOString();
+        }
+        else {
+            warmupInfo = 'State file missing or corrupt';
+        }
+    }
+    const output = {
+        warmup: warmupInfo,
+        savedAt,
+        statePath: statePath || null,
+    };
+    if (opts['json']) {
+        console.log(JSON.stringify(output, null, 2));
+    }
+    else {
+        console.log('═══ baileys-antiban status ═══');
+        console.log(`Warmup:   ${output.warmup}`);
+        console.log(`Saved:    ${output.savedAt}`);
+        console.log(`State:    ${output.statePath || 'none'}`);
+    }
+}
+function cmdReset(opts) {
+    const statePath = opts['state'];
+    if (!statePath) {
+        console.error('Error: --state <path> required for reset');
+        process.exit(1);
+    }
+    if (!fs.existsSync(statePath)) {
+        console.log('State file does not exist — nothing to reset');
+        return;
+    }
+    fs.unlinkSync(statePath);
+    console.log(`✅ State file deleted: ${statePath}`);
+}
+function cmdWarmupSimulate(opts) {
+    const days = parseInt(opts['simulate'] || '7', 10);
+    const presetName = opts['preset'] || 'conservative';
+    const cfg = resolveConfig(presetName);
+    console.log(`\nWarmup simulation — preset: ${presetName}, days: ${days}`);
+    console.log('─'.repeat(50));
+    const startDate = new Date();
+    for (let day = 0; day < days; day++) {
+        const date = new Date(startDate);
+        date.setDate(date.getDate() + day);
+        const dayName = date.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric' });
+        const limit = Math.round(cfg.day1Limit * Math.pow(cfg.growthFactor, day));
+        const bar = '█'.repeat(Math.min(30, Math.round(limit / 10)));
+        console.log(`Day ${String(day + 1).padStart(2)} ${dayName.padEnd(15)} ${String(limit).padStart(5)} msgs/day  ${bar}`);
+    }
+    console.log('─'.repeat(50));
+    console.log(`Day ${days + 1}+: graduated (unlimited by warmup)\n`);
+}
+function cmdPatch(opts) {
+    const searchPaths = opts['path'] ? [opts['path']] : undefined;
+    const preset = opts['preset'] || 'conservative';
+    const minDelay = opts['min-delay'] ? parseInt(opts['min-delay']) : 1500;
+    const maxDelay = opts['max-delay'] ? parseInt(opts['max-delay']) : 4000;
+    const typingIndicator = opts['no-typing'] ? false : true;
+    const dryRun = !!opts['dry-run'];
+    const force = !!opts['force'];
+    const result = applyPatch({
+        baileysPaths: searchPaths,
+        preset,
+        minDelay,
+        maxDelay,
+        typingIndicator,
+        dryRun,
+    });
+    if (result.alreadyPatched && !force) {
+        console.log(result.message);
+        process.exit(0);
+    }
+    if (!result.success) {
+        console.error('✗ ' + result.message);
+        process.exit(1);
+    }
+    console.log(result.message);
+}
+function cmdUnpatch(opts) {
+    const targetFile = opts['file'];
+    if (!targetFile) {
+        console.error('Usage: npx baileys-antiban unpatch --file <path-to-patched-file>');
+        process.exit(1);
+    }
+    const result = unpatchFile(targetFile);
+    if (!result.success) {
+        console.error('✗ ' + result.message);
+        process.exit(1);
+    }
+    console.log(result.message);
+}
+// Main
+const opts = parseArgs(args);
+switch (command) {
+    case 'status':
+        cmdStatus(opts);
+        break;
+    case 'reset':
+        cmdReset(opts);
+        break;
+    case 'warmup':
+        if (opts['simulate']) {
+            cmdWarmupSimulate(opts);
+        }
+        else {
+            console.error('Usage: npx baileys-antiban warmup --simulate <days> [--preset conservative|moderate|aggressive]');
+            process.exit(1);
+        }
+        break;
+    case 'patch':
+        cmdPatch(opts);
+        break;
+    case 'unpatch':
+        cmdUnpatch(opts);
+        break;
+    default:
+        console.log('baileys-antiban v3.0');
+        console.log('');
+        console.log('Commands:');
+        console.log('  status [--state <path>] [--json]     Show warmup and health status');
+        console.log('  reset --state <path>                  Delete state file');
+        console.log('  warmup --simulate <days> [--preset]  Show warmup schedule');
+        console.log('  patch [--path <baileys-dir>] [--preset] [--min-delay] [--max-delay] [--no-typing] [--dry-run]');
+        console.log('  unpatch --file <patched-file>         Restore file from backup');
+        console.log('');
+        console.log('Examples:');
+        console.log('  npx baileys-antiban status --state ./antiban-state.json');
+        console.log('  npx baileys-antiban warmup --simulate 7 --preset moderate');
+        console.log('  npx baileys-antiban reset --state ./antiban-state.json');
+        console.log('  npx baileys-antiban patch');
+        console.log('  npx baileys-antiban patch --path ./node_modules/@openclaw/whatsapp/node_modules/baileys');
+        console.log('  npx baileys-antiban patch --preset moderate --min-delay 1000 --max-delay 3000');
+        console.log('  npx baileys-antiban unpatch --file ./node_modules/baileys/lib/socket/index.js');
+}

package/lib/Socket/groups.js

@@ -440,31 +440,36 @@ export const extractGroupMetadata = (result) => {
     memberAddMode: memberAddMode,
     participants: getBinaryNodeChildren(group, "participant").map(
       ({ attrs }) => {
-        const id = jidNormalizedUser(attrs.jid);
-        const phone = attrs.phone_number
-          ? jidNormalizedUser(attrs.phone_number)
-          : isPnUser(id)
-            ? id
-            : undefined;
-        const lid = attrs.lid
-          ? jidNormalizedUser(attrs.lid)
-          : isLidUser(id)
-            ? id
-            : undefined;
+        // مهم: الـ id هنا لازم يفضل زي ما السيرفر بعته (attrs.jid) بالظبط,
+        // من غير ما نلمسه أو نبدله بـ lid/phone بديل. السبب: القيمة دي هي
+        // اللي بتتبعت زي ما هي في participantsList لـ getUSyncDevices وفي
+        // الـ addressing_mode بتاع الرسالة الصادرة (messages-send.js) —
+        // فلو الجروب addressingMode="pn" لازم كل الـ ids تكون بصيغة PN,
+        // ولو "lid" لازم تكون كلها LID. أي تبديل هنا بيسبب mismatch بين
+        // هوية المشارك والـ addressing_mode المعلن، وده اللي كان بيطلع
+        // "بيشفر"/Waiting for this message لمشاركين الـ username بالذات —
+        // مش مشكلة سيشن عشان كده افتكاك السيشن وإعادة الدخول ما كانتش بتحل حاجة.
+        // عرض الرقم/اليوزرنيم للمستخدم (لو الرقم مخفي) اتحل بالفعل في مكان
+        // تاني (resolveDisplayIdentity) وده المكان الصح ليه، مش هنا.
+        const id = attrs.jid;
         return {
-          // لو مفيش رقم ظاهر (حساب يوزرنيم/خاصية إخفاء الرقم)، استخدم الـ
-          // LID بدل ما تسيبها undefined — undefined كانت بتوصل لقايمة
-          // المشاركين اللي بتتبعت لـ getUSyncDevices وتكسر استعلام
-          // الأجهزة للجروب كله، مع إن الاستعلام المباشر بالـ LID بيرجع
-          // فورًا لو استخدمناه صح
-          id: phone || lid,
-          lid: lid,
-          jid: phone || lid,
-          admin: attrs.type || false,
+          id,
+          // jid هنا نفس قيمة id بالظبط (مش قيمة تانية زي الكود القديم) —
+          // مُبقّاها بس عشان بعض أوامر البوت (كتم.js, مجتمع.js, muteSystem.js,
+          // context/group.js) بتقرا p.jid كـ fallback؛ ما بتأثرش على
+          // participantsList/addressing_mode لأنها زي id بالظبط دلوقتي
+          jid: id,
+          phoneNumber:
+            isLidUser(id) && isPnUser(attrs.phone_number)
+              ? attrs.phone_number
+              : undefined,
+          lid: isPnUser(id) && isLidUser(attrs.lid) ? attrs.lid : undefined,
+          username: attrs.participant_username || attrs.username || undefined,
+          admin: attrs.type || null,
         };
       },
     ),
     ephemeralDuration: eph ? +eph : undefined,
   };
   return metadata;
-};
+};

package/lib/Socket/index.js

@@ -1,79 +1,161 @@
 import { DEFAULT_CONNECTION_CONFIG } from "../Defaults/index.js";
 import { makeCommunitiesSocket } from "./communities.js";
-import { wrapSocket, wrapSocketWithFingerprint } from "../AntiBan/wrapper.js";
-import { resolveConfig, PRESETS } from "../AntiBan/presets.js";
 
 /**
- * Create a WhatsApp socket.
- *
- * Optional anti-ban protection (integrated from baileys-antiban) can be enabled via config.antiBan:
- *
- *   // Disabled (default) — normal Baileys behavior
- *   makeWASocket({ auth, ... })
- *
- *   // Enable with safe defaults (conservative preset)
- *   makeWASocket({ auth, antiBan: true })
- *
- *   // Enable with a named preset: 'conservative' | 'moderate' | 'aggressive' | 'high-volume'
- *   makeWASocket({ auth, antiBan: 'moderate' })
- *
- *   // Enable with full custom config (see baileys-antiban README)
- *   makeWASocket({
- *     auth,
- *     antiBan: {
- *       maxPerMinute: 8,
- *       maxPerHour: 200,
- *       warmUp: { enabled: true },
- *       // ... or nested style still accepted with deprecation warning
- *     }
- *   })
- *
- * When enabled, the returned socket has the same API plus:
- *   sock.antiban          — AntiBan instance
- *   sock.antiban.getStats() — current rate / health / risk stats
+ * Optional AntiBan — مقفول افتراضياً.
+ * لتفعيله مرّر في إعدادات makeWASocket:
+ *   makeWASocket({ antiBan: true })                    // moderate preset
+ *   makeWASocket({ antiBan: 'conservative' })          // preset name
+ *   makeWASocket({ antiBan: { maxPerMinute: 8, ... } }) // config مخصص
+ *   makeWASocket({ antiBan: false })                   // صراحة مقفول (الافتراضي)
  *
- * Extra advanced options (optional):
- *   antiBanWarmUpState   — restore previous warm-up state
- *   antiBanWrapOptions   — extra wrap options (groupOpGuard, legitimacySignals, etc.)
- *
- * You can also use the low-level helpers directly:
- *   import { wrapSocket, wrapSocketWithFingerprint, PRESETS } from '@prototypevip/baileys'
+ * الحالة الاختيارية:
+ *   antiBanWarmUpState  — حالة الـ warmup المحفوظة
+ *   antiBanWrapOptions  — خيارات إضافية لـ wrapSocket
+ */
+
+let _wrapSocket = null;
+let _wrapSocketWithFingerprint = null;
+let _PRESETS = {};
+let _antiBanLoadError = null;
+
+async function loadAntiBan() {
+  if (_wrapSocket) return true;
+  if (_antiBanLoadError) return false;
+  try {
+    const mod = await import("../AntiBan/index.js");
+    _wrapSocket = mod.wrapSocket;
+    _wrapSocketWithFingerprint = mod.wrapSocketWithFingerprint;
+    _PRESETS = mod.PRESETS || {};
+    return true;
+  } catch (e) {
+    // fallback: try wrapper export path
+    try {
+      const wrap = await import("../AntiBan/wrapper.js");
+      const presets = await import("../AntiBan/presets.js").catch(() => ({}));
+      _wrapSocket = wrap.wrapSocket;
+      _wrapSocketWithFingerprint = wrap.wrapSocketWithFingerprint;
+      _PRESETS = presets.PRESETS || {};
+      return true;
+    } catch (e2) {
+      _antiBanLoadError = e2;
+      console.warn(
+        "[@prototypevip/baileys] AntiBan module failed to load — continuing without it:",
+        e2?.message || e2
+      );
+      return false;
+    }
+  }
+}
+
+// Sync load attempt for ESM top-level (best-effort)
+try {
+  const wrap = await import("../AntiBan/wrapper.js");
+  _wrapSocket = wrap.wrapSocket;
+  _wrapSocketWithFingerprint = wrap.wrapSocketWithFingerprint;
+  try {
+    const presets = await import("../AntiBan/presets.js");
+    _PRESETS = presets.PRESETS || {};
+  } catch {}
+} catch (e) {
+  _antiBanLoadError = e;
+}
+
+/**
+ * Create a WhatsApp socket.
+ * AntiBan مقفول افتراضياً — فعّله عبر config.antiBan
  */
 const makeWASocket = (config = {}) => {
-  // Extract anti-ban related options so they don't leak into Baileys internal config
   const {
-    antiBan,
+    antiBan = false, // مقفول افتراضياً
     antiBanWarmUpState,
     antiBanWrapOptions,
     ...restConfig
-  } = config;
+  } = config || {};
 
   delete restConfig.userDevicesCache;
   const newConfig = { ...DEFAULT_CONNECTION_CONFIG, ...restConfig };
 
   let sock;
   const originalGetMessage = newConfig.getMessage;
-  newConfig.getMessage = async function (key) {
-    return originalGetMessage.call(sock || this, key);
-  };
+  if (typeof originalGetMessage === "function") {
+    newConfig.getMessage = async function (key) {
+      return originalGetMessage.call(sock || this, key);
+    };
+  }
 
   sock = makeCommunitiesSocket(newConfig);
 
-  // Optional anti-ban wrapping
-  if (antiBan) {
-    let antibanConfig;
-    if (antiBan === true) {
-      antibanConfig = resolveConfig(undefined); // conservative defaults
-    } else if (typeof antiBan === "string") {
-      antibanConfig = resolveConfig(antiBan);
-    } else {
-      antibanConfig = antiBan; // user object (supports both flat & nested)
+  // ── AntiBan (اختياري) ──
+  const enabled =
+    antiBan === true ||
+    (typeof antiBan === "string" && antiBan.length > 0) ||
+    (antiBan && typeof antiBan === "object");
+
+  if (enabled) {
+    if (typeof _wrapSocket !== "function") {
+      console.warn(
+        "[@prototypevip/baileys] antiBan requested but module not available — socket without protection"
+      );
+      return sock;
+    }
+
+    const antiBanConfig =
+      antiBan === true
+        ? "moderate"
+        : antiBan; // string preset or object config
+
+    try {
+      sock = _wrapSocket(
+        sock,
+        antiBanConfig,
+        antiBanWarmUpState,
+        antiBanWrapOptions || {}
+      );
+      if (newConfig.logger?.info) {
+        newConfig.logger.info(
+          { antiBan: typeof antiBanConfig === "string" ? antiBanConfig : "custom" },
+          "AntiBan protection enabled"
+        );
+      }
+    } catch (e) {
+      console.warn(
+        "[@prototypevip/baileys] AntiBan wrap failed — continuing without it:",
+        e?.message || e
+      );
     }
-    sock = wrapSocket(sock, antibanConfig, antiBanWarmUpState, antiBanWrapOptions);
   }
 
   return sock;
 };
 
+/** Pass-through stubs when antiban is not loaded; real functions when loaded */
+const wrapSocket = (sock, ...args) =>
+  typeof _wrapSocket === "function" ? _wrapSocket(sock, ...args) : sock;
+
+const wrapSocketWithFingerprint = (makeSock, opts, wrapOpts) => {
+  if (typeof _wrapSocketWithFingerprint === "function") {
+    return _wrapSocketWithFingerprint(makeSock, opts, wrapOpts);
+  }
+  return typeof makeSock === "function" ? makeSock(opts || {}) : makeSock;
+};
+
+const PRESETS = new Proxy(
+  {},
+  {
+    get(_, prop) {
+      return _PRESETS[prop];
+    },
+    ownKeys() {
+      return Reflect.ownKeys(_PRESETS);
+    },
+    getOwnPropertyDescriptor(_, prop) {
+      if (prop in _PRESETS) {
+        return { enumerable: true, configurable: true, value: _PRESETS[prop] };
+      }
+    },
+  }
+);
+
 export default makeWASocket;
-export { wrapSocket, wrapSocketWithFingerprint, PRESETS };
+export { makeWASocket, wrapSocket, wrapSocketWithFingerprint, PRESETS };

package/lib/Socket/messages-send.js

@@ -845,9 +845,31 @@ export const makeMessagesSocket = (config) => {
             return {};
           })(),
         ]);
-        const participantsList = groupData?.participants
-          ? groupData.participants.map((p) => p.id)
-          : [];
+        // نبني قائمة المشاركين + بدائل LID/PN عشان حسابات اليوزرنيم
+        // (اللي أحياناً USync بيرجع فاضي لو استعلمنا بصيغة واحدة بس)
+        const participantsList = [];
+        const seenParticipantUsers = new Set();
+        const addParticipantJid = (jid) => {
+          if (!jid || typeof jid !== "string") return;
+          const normalized = jidNormalizedUser(jid);
+          const user = jidDecode(normalized)?.user;
+          if (!user || seenParticipantUsers.has(user + ":" + (normalized.split("@")[1] || ""))) {
+            // نسمح بنفس الـ user بصيغتين مختلفتين (pn + lid) بس نمنع التكرار الحرفي
+          }
+          if (participantsList.includes(normalized) || participantsList.includes(jid)) return;
+          participantsList.push(normalized);
+          if (user) seenParticipantUsers.add(user);
+        };
+        if (groupData?.participants) {
+          for (const p of groupData.participants) {
+            addParticipantJid(p.id);
+            // بديل LID لو الـ id رقم (PN) — مهم لحسابات اليوزرنيم
+            if (p.lid) addParticipantJid(p.lid);
+            // بديل الرقم لو الـ id LID
+            if (p.phoneNumber) addParticipantJid(p.phoneNumber);
+            if (p.jid && p.jid !== p.id) addParticipantJid(p.jid);
+          }
+        }
         if (groupData?.ephemeralDuration && groupData.ephemeralDuration > 0) {
           additionalAttributes = {
             ...additionalAttributes,
@@ -855,13 +877,54 @@ export const makeMessagesSocket = (config) => {
           };
         }
         if (isStatus && statusJidList) {
-          participantsList.push(...statusJidList);
+          for (const s of statusJidList) addParticipantJid(s);
         }
-        const additionalDevices = await getUSyncDevices(
+        let additionalDevices = await getUSyncDevices(
           participantsList,
           !!useUserDevicesCache,
           false,
         );
+        // لو في مشاركين معرفين في الميتاداتا ومفيش أي device ليهم في النتيجة
+        // (شائع مع username/LID)، نعيد الاستعلام من غير كاش وبمهلة أطول
+        // على الـ JIDs الناقصة فقط — من غير ما نأثر على باقي الجروب
+        if (groupData?.participants?.length) {
+          const coveredUsers = new Set(
+            additionalDevices
+              .map((d) => d.user || jidDecode(d.jid)?.user)
+              .filter(Boolean),
+          );
+          const missingJids = [];
+          for (const p of groupData.participants) {
+            const candidates = [p.id, p.lid, p.phoneNumber, p.jid].filter(Boolean);
+            const userIds = candidates
+              .map((j) => jidDecode(jidNormalizedUser(j))?.user)
+              .filter(Boolean);
+            if (userIds.some((u) => coveredUsers.has(u))) continue;
+            // جرب LID أولاً لو موجود (أحسن لليوزرنيم)، وإلا id الأصلي
+            if (p.lid) missingJids.push(jidNormalizedUser(p.lid));
+            else if (p.id) missingJids.push(jidNormalizedUser(p.id));
+            else if (p.phoneNumber) missingJids.push(jidNormalizedUser(p.phoneNumber));
+          }
+          if (missingJids.length > 0) {
+            logger.debug(
+              { missing: missingJids.length, jids: missingJids.slice(0, 5) },
+              "retrying USync for participants with no devices (likely username/LID)",
+            );
+            try {
+              const retryDevices = await getUSyncDevices(
+                missingJids,
+                false, // no cache
+                false,
+                8000, // longer timeout
+              );
+              if (retryDevices?.length) {
+                additionalDevices = [...additionalDevices, ...retryDevices];
+              }
+            } catch (e) {
+              logger.warn({ e }, "USync retry for missing participants failed");
+            }
+          }
+        }
         devices.push(...additionalDevices);
         if (isGroup) {
           additionalAttributes = {

package/lib/Utils/ai-rich-formatter.js

@@ -0,0 +1,256 @@
+/**
+ * AI Rich Formatter helpers
+ * Extracted helpers for parsing AI responses and sending unified rich messages
+ * via AIRich (message-builder).
+ *
+ * Used by AI bot commands (Claude, Gemini, etc.)
+ */
+
+import { AIRich } from './message-builder.js';
+
+/**
+ * Parse a markdown table string into rows (string[][])
+ * First row is typically the header.
+ */
+export function parseMarkdownTable(tableString) {
+	const lines = tableString.trim().split('\n');
+	const rows = [];
+
+	for (let line of lines) {
+		line = line.trim();
+		if (line.replace(/[\s|:-]/g, '') === '') continue;
+
+		let items = line.split('|').map((c) => c.trim());
+		if (items[0] === '') items.shift();
+		if (items[items.length - 1] === '') items.pop();
+
+		if (items.length > 0) rows.push(items);
+	}
+	return rows;
+}
+
+/**
+ * Extract code blocks, tables, sources, and special action tags
+ * (exec / group / commands / db) from an AI response text.
+ */
+export function extractElements(text) {
+	const blocks = [];
+	const execBlocks = [];
+	const groupBlocks = [];
+	const commandsBlocks = [];
+	const dbBlocks = [];
+	const tables = [];
+	const sources = [];
+	let clean = text;
+
+	const codeRegex = /```(\w*)\n?([\s\S]*?)```/g;
+	let codeMatch;
+	while ((codeMatch = codeRegex.exec(text)) !== null) {
+		const lang = codeMatch[1].trim().toLowerCase() || 'javascript';
+		const code = codeMatch[2].trim();
+		if (code) {
+			if (lang === 'exec') execBlocks.push(code);
+			else if (lang === 'group') groupBlocks.push(code);
+			else if (lang === 'commands') commandsBlocks.push(code);
+			else if (lang === 'db') dbBlocks.push(code);
+			else blocks.push({ lang, code });
+		}
+		clean = clean.replace(codeMatch[0], '');
+	}
+
+	// Safety net: model wrote [group]/[db]/[commands]/[exec] without real code fences
+	const looseTagRegex =
+		/\[(group|db|commands|exec)(?:\s+\w+)?\]\s*\n?([\s\S]*?)(?=\n\[(?:group|db|commands|exec)(?:\s+\w+)?\]|$)/gi;
+	let looseMatch;
+	while ((looseMatch = looseTagRegex.exec(clean)) !== null) {
+		const tag = looseMatch[1].toLowerCase();
+		const payload = looseMatch[2].trim();
+		if (!payload) continue;
+		if (tag === 'exec') execBlocks.push(payload);
+		else if (tag === 'group') groupBlocks.push(payload);
+		else if (tag === 'commands') commandsBlocks.push(payload);
+		else if (tag === 'db') dbBlocks.push(payload);
+		clean = clean.replace(looseMatch[0], '');
+	}
+
+	const linkRegex = /\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/g;
+	let linkMatch;
+	const seenUrls = new Set();
+	while ((linkMatch = linkRegex.exec(clean)) !== null) {
+		const label = linkMatch[1].trim();
+		const url = linkMatch[2].trim();
+		if (!seenUrls.has(url)) {
+			seenUrls.add(url);
+			sources.push({ label, url });
+		}
+	}
+
+	linkRegex.lastIndex = 0;
+	clean = clean.replace(linkRegex, '$1');
+
+	const lines = clean.split('\n');
+	let currentTableLines = [];
+	let newCleanLines = [];
+	let inTable = false;
+
+	for (let line of lines) {
+		if (line.trim().startsWith('|') && line.trim().endsWith('|')) {
+			inTable = true;
+			currentTableLines.push(line);
+		} else {
+			if (inTable) {
+				const parsed = parseMarkdownTable(currentTableLines.join('\n'));
+				if (parsed.length > 0) tables.push(parsed);
+				currentTableLines = [];
+				inTable = false;
+			}
+			newCleanLines.push(line);
+		}
+	}
+	if (inTable && currentTableLines.length > 0) {
+		const parsed = parseMarkdownTable(currentTableLines.join('\n'));
+		if (parsed.length > 0) tables.push(parsed);
+	}
+
+	clean = newCleanLines.join('\n').trim();
+	const finalMergedCode = blocks
+		.map((b) => b.code)
+		.join('\n\n// ──────────────────────────────────────────\n\n');
+	const primaryLang = blocks.length > 0 ? blocks[0].lang : 'javascript';
+
+	return {
+		clean,
+		finalMergedCode,
+		primaryLang,
+		hasCode: blocks.length > 0,
+		tables,
+		sources,
+		execBlocks,
+		groupBlocks,
+		commandsBlocks,
+		dbBlocks,
+	};
+}
+
+/**
+ * Build and send a unified rich AI message (text + tables + code + sources + action results).
+ * Falls back to plain text if the rich send fails.
+ */
+export async function sendUnifiedMetaMessage(
+	prototype,
+	chatId,
+	m,
+	{
+		textOnly,
+		tables,
+		hasCode,
+		finalMergedCode,
+		primaryLang,
+		sources,
+		sig,
+		execResults,
+		groupResults,
+		commandsResults,
+		dbResults,
+	}
+) {
+	try {
+		const rich = new AIRich(prototype);
+
+		// 1. Text
+		rich.addText((textOnly || '🤖 تم إنشاء الرد بنجاح') + (sig || ''));
+
+		// 2. Tables
+		if (tables && tables.length > 0) {
+			for (const tableRows of tables) {
+				if (Array.isArray(tableRows) && tableRows.length > 0) {
+					rich.addTable(tableRows);
+				}
+			}
+		}
+
+		// 3. Colored code
+		if (hasCode && finalMergedCode) {
+			rich.addCode(primaryLang, finalMergedCode);
+		}
+
+		// 4. Exec results (file edit/create/delete)
+		if (Array.isArray(execResults) && execResults.length > 0) {
+			for (const r of execResults) {
+				rich.addText(`${r.ok ? '✅' : '❌'} تنفيذ: ${r.command}`);
+				rich.addCode('bash', r.output);
+			}
+		}
+
+		// 5. Group action results
+		if (Array.isArray(groupResults) && groupResults.length > 0) {
+			for (const r of groupResults) {
+				rich.addText(`${r.ok ? '✅' : '❌'} ${r.output}`);
+			}
+		}
+
+		// 6. Commands list/count results
+		if (Array.isArray(commandsResults) && commandsResults.length > 0) {
+			for (const r of commandsResults) {
+				rich.addText(`${r.ok ? '✅' : '❌'} ${r.output}`);
+			}
+		}
+
+		// 7. Database results
+		if (Array.isArray(dbResults) && dbResults.length > 0) {
+			for (const r of dbResults) {
+				rich.addText(`${r.ok ? '✅' : '❌'} نتيجة قاعدة البيانات:`);
+				rich.addCode('json', r.output);
+			}
+		}
+
+		// 8. Sources ("See details")
+		if (Array.isArray(sources) && sources.length > 0) {
+			const defaultIcon = 'https://files.catbox.moe/9qffq1.jpg';
+			rich.addSource(sources.slice(0, 10).map((s) => [defaultIcon, s.url, s.label]));
+		}
+
+		await rich.send(chatId, { quoted: m });
+	} catch (sendErr) {
+		console.warn('⚠️ فشل إرسال الرسالة الغنية، إرسال نسخة نصية بديلة:', sendErr.message);
+
+		let fallbackText = textOnly || '🤖 تم إنشاء الرد بنجاح';
+		if (hasCode && finalMergedCode) {
+			fallbackText += `\n\n\`\`\`${primaryLang}\n${finalMergedCode}\n\`\`\``;
+		}
+		if (Array.isArray(execResults) && execResults.length > 0) {
+			fallbackText +=
+				'\n\n' +
+				execResults
+					.map(
+						(r) =>
+							`${r.ok ? '✅' : '❌'} ${r.command}\n\`\`\`bash\n${r.output}\n\`\`\``
+					)
+					.join('\n\n');
+		}
+		if (Array.isArray(groupResults) && groupResults.length > 0) {
+			fallbackText +=
+				'\n\n' + groupResults.map((r) => `${r.ok ? '✅' : '❌'} ${r.output}`).join('\n');
+		}
+		if (Array.isArray(commandsResults) && commandsResults.length > 0) {
+			fallbackText +=
+				'\n\n' +
+				commandsResults.map((r) => `${r.ok ? '✅' : '❌'} ${r.output}`).join('\n');
+		}
+		if (Array.isArray(dbResults) && dbResults.length > 0) {
+			fallbackText +=
+				'\n\n' +
+				dbResults
+					.map((r) => `${r.ok ? '✅' : '❌'} \`\`\`json\n${r.output}\n\`\`\``)
+					.join('\n');
+		}
+		if (Array.isArray(sources) && sources.length > 0) {
+			fallbackText +=
+				`\n\n🔗 *مصادر:*\n` +
+				sources.slice(0, 10).map((s) => `• ${s.label}: ${s.url}`).join('\n');
+		}
+		fallbackText += sig || '';
+
+		await prototype.sendMessage(chatId, { text: fallbackText }, { quoted: m });
+	}
+}

package/lib/Utils/index.js

@@ -27,4 +27,5 @@ export * from "./use-prototype-auth-state.js";
 export * from "./sticker-utils.js";
 export * from "./rich-message-utils.js";
 export * from "./message-builder.js";
+export * from "./ai-rich-formatter.js";
 export * from "./constants.js";

package/lib/index.js

@@ -9,9 +9,7 @@ export * from "./WAM/index.js";
 export * from "./WAUSync/index.js";
 export * from "./Store/cache-factory.js";
 
-// Anti-ban toolkit (optional, integrated from baileys-antiban)
-export * from "./AntiBan/index.js";
-export { wrapSocket, wrapSocketWithFingerprint } from "./Socket/index.js";
+export { wrapSocket, wrapSocketWithFingerprint, PRESETS } from "./Socket/index.js";
 
 export { makeWASocket };
 export default makeWASocket;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prototypevip/baileys",
-  "version": "0.0.7",
-  "description": "Baileys fork with optional integrated anti-ban protection (rate limiting, warm-up, health monitoring, human-like messaging)",
+  "version": "0.0.9",
+  "description": "Baileys fork (@prototypevip/baileys) — clean, without anti-ban",
   "main": "lib/index.js",
   "type": "module",
   "scripts": {
@@ -34,11 +34,7 @@
     "whatsapp-bot",
     "whatsapp-chat",
     "whatsapp-group",
-    "whatsapp-web",
-    "anti-ban",
-    "rate-limit",
-    "warmup",
-    "baileys-antiban"
+    "whatsapp-web"
   ],
   "homepage": "https://github.com/GSK-F/baileys",
   "author": "The Prototype",