@fer2809fl/baileys 7.0.2 → 7.0.5

package/lib/Utils/enhanced-logger.js

@@ -0,0 +1,185 @@
+const LOG_LEVELS = {
+    fatal: 60,
+    error: 50,
+    warn: 40,
+    info: 30,
+    debug: 20,
+    trace: 10,
+    silent: Infinity
+};
+
+const COLORS = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    fatal: '\x1b[35m\x1b[1m',
+    error: '\x1b[31m',
+    warn: '\x1b[33m',
+    info: '\x1b[36m',
+    debug: '\x1b[34m',
+    trace: '\x1b[90m',
+    socket: '\x1b[32m',
+    message: '\x1b[33m',
+    media: '\x1b[35m',
+    group: '\x1b[36m',
+    auth: '\x1b[31m',
+    cache: '\x1b[34m'
+};
+
+const CATEGORY_ICONS = {
+    socket: '[SOCKET]',
+    message: '[MSG]',
+    media: '[MEDIA]',
+    group: '[GROUP]',
+    auth: '[AUTH]',
+    cache: '[CACHE]',
+    queue: '[QUEUE]',
+    error: '[ERROR]',
+    warn: '[WARN]',
+    info: '[INFO]',
+    debug: '[DEBUG]',
+    success: '[OK]'
+};
+
+function formatTime(date = new Date()) {
+    return date.toLocaleTimeString('es-ES', { hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false });
+}
+
+function formatConsoleMessage(level, category, message, data) {
+    const time = formatTime();
+    const levelColor = COLORS[level] || COLORS.info;
+    const categoryColor = COLORS[category] || COLORS.reset;
+    const icon = CATEGORY_ICONS[category] || CATEGORY_ICONS[level] || '';
+    let formatted = `${COLORS.dim}[${time}]${COLORS.reset} `;
+    formatted += `${levelColor}${level.toUpperCase().padEnd(5)}${COLORS.reset} `;
+    if (category) formatted += `${categoryColor}${icon} ${category}${COLORS.reset} `;
+    formatted += message;
+    if (data && Object.keys(data).length > 0) {
+        const dataStr = JSON.stringify(data, null, 0);
+        if (dataStr.length < 100) formatted += ` ${COLORS.dim}${dataStr}${COLORS.reset}`;
+    }
+    return formatted;
+}
+
+class RyzeLogger {
+    constructor(options = {}) {
+        this.options = {
+            level: options.level || 'info',
+            prettyPrint: options.prettyPrint !== false,
+            category: options.category || 'baileys',
+            colors: options.colors !== false,
+            timestamps: options.timestamps !== false,
+            ...options
+        };
+        this.category = this.options.category;
+        this.filters = new Set(options.filters || []);
+        this.history = [];
+        this.maxHistory = options.maxHistory || 1000;
+    }
+
+    _log(level, messageOrData, data = {}) {
+        let message = '';
+        let logData = data;
+        if (typeof messageOrData === 'string') {
+            message = messageOrData;
+        } else if (typeof messageOrData === 'object') {
+            logData = messageOrData;
+            message = messageOrData.msg || '';
+        }
+        if (this.filters.size > 0) {
+            const shouldFilter = [...this.filters].some(f => message.includes(f) || JSON.stringify(logData).includes(f));
+            if (shouldFilter) return;
+        }
+        this._addToHistory(level, message, logData);
+        if (this.options.prettyPrint) console.log(formatConsoleMessage(level, this.category, message, logData));
+    }
+
+    _addToHistory(level, message, data) {
+        this.history.push({ timestamp: new Date().toISOString(), level, category: this.category, message, data });
+        if (this.history.length > this.maxHistory) this.history.shift();
+    }
+
+    fatal(messageOrData, data) { this._log('fatal', messageOrData, data); }
+    error(messageOrData, data) { this._log('error', messageOrData, data); }
+    warn(messageOrData, data) { this._log('warn', messageOrData, data); }
+    info(messageOrData, data) { this._log('info', messageOrData, data); }
+    debug(messageOrData, data) { this._log('debug', messageOrData, data); }
+    trace(messageOrData, data) { this._log('trace', messageOrData, data); }
+
+    success(message, data = {}) {
+        const formatted = `${COLORS.reset}${CATEGORY_ICONS.success} ${message}${COLORS.reset}`;
+        this._log('info', formatted, data);
+    }
+
+    child(bindings) {
+        return new RyzeLogger({ ...this.options, category: bindings.class || bindings.category || this.category });
+    }
+
+    setLevel(level) {
+        this.options.level = level;
+    }
+
+    addFilter(pattern) { this.filters.add(pattern); }
+    removeFilter(pattern) { this.filters.delete(pattern); }
+
+    getHistory(options = {}) {
+        let history = [...this.history];
+        if (options.level) history = history.filter(h => h.level === options.level);
+        if (options.category) history = history.filter(h => h.category === options.category);
+        if (options.since) {
+            const sinceDate = new Date(options.since);
+            history = history.filter(h => new Date(h.timestamp) >= sinceDate);
+        }
+        if (options.limit) history = history.slice(-options.limit);
+        return history;
+    }
+
+    clearHistory() { this.history = []; }
+
+    exportLogs(format = 'json') {
+        if (format === 'json') return JSON.stringify(this.history, null, 2);
+        return this.history.map(h => `[${h.timestamp}] ${h.level.toUpperCase()} [${h.category}] ${h.message}`).join('\n');
+    }
+
+    time(label) {
+        const start = Date.now();
+        return { end: (message) => {
+            const duration = Date.now() - start;
+            this.debug(`${message || label}: ${duration}ms`, { duration, label });
+            return duration;
+        }};
+    }
+
+    if(condition, level, message, data) {
+        if (condition) this[level](message, data);
+    }
+
+    throttle(key, message, data, intervalMs = 5000) {
+        if (!this._throttleCache) this._throttleCache = new Map();
+        const now = Date.now();
+        const lastLog = this._throttleCache.get(key) || 0;
+        if (now - lastLog >= intervalMs) {
+            this._throttleCache.set(key, now);
+            this.info(message, data);
+        }
+    }
+}
+
+function createLogger(options = {}) {
+    return new RyzeLogger({
+        level: process.env.LOG_LEVEL || 'info',
+        prettyPrint: process.env.NODE_ENV !== 'production',
+        ...options
+    });
+}
+
+const defaultLogger = createLogger({ category: 'baileys' });
+
+export {
+    LOG_LEVELS,
+    COLORS,
+    CATEGORY_ICONS,
+    RyzeLogger,
+    createLogger,
+    defaultLogger as default
+};

package/lib/Utils/event-buffer.js

@@ -169,7 +169,27 @@ export const makeEventBuffer = (logger) => {
         },
         on: (...args) => ev.on(...args),
         off: (...args) => ev.off(...args),
-        removeAllListeners: (...args) => ev.removeAllListeners(...args)
+        removeAllListeners: (...args) => ev.removeAllListeners(...args),
+        destroy() {
+            // Clear buffer timeout
+            if (bufferTimeout) {
+                clearTimeout(bufferTimeout);
+                bufferTimeout = null;
+            }
+            if (flushPendingTimeout) {
+                clearTimeout(flushPendingTimeout);
+                flushPendingTimeout = null;
+            }
+            // Clear history cache
+            historyCache.clear();
+            // Reset buffer data
+            data = makeBufferData();
+            isBuffering = false;
+            bufferCount = 0;
+            // Remove all listeners
+            ev.removeAllListeners();
+            logger.debug('Event buffer destroyed');
+        }
     };
 };
 const makeBufferData = () => {
@@ -235,7 +255,33 @@ eventData, logger) {
             }
             data.historySets.empty = false;
             data.historySets.syncType = eventData.syncType;
+            if (eventData.pastParticipants?.length) {
+                const merged = new Map();
+                const sigOf = (p) => `${p.userJid || ''}:${p.leaveTs || ''}:${p.leaveReason || ''}`;
+                const ingest = (entry) => {
+                    const key = entry.groupJid ?? JSON.stringify(entry);
+                    const existing = merged.get(key);
+                    if (!existing) {
+                        merged.set(key, { ...entry, pastParticipants: [...(entry.pastParticipants || [])] });
+                        return;
+                    }
+                    const seen = new Set((existing.pastParticipants || []).map(sigOf));
+                    for (const p of entry.pastParticipants || []) {
+                        const sig = sigOf(p);
+                        if (!seen.has(sig)) {
+                            existing.pastParticipants.push(p);
+                            seen.add(sig);
+                        }
+                    }
+                };
+                for (const entry of data.historySets.pastParticipants || [])
+                    ingest(entry);
+                for (const entry of eventData.pastParticipants)
+                    ingest(entry);
+                data.historySets.pastParticipants = [...merged.values()];
+            }
             data.historySets.progress = eventData.progress;
+            data.historySets.chunkOrder = eventData.chunkOrder;
             data.historySets.peerDataRequestSessionId = eventData.peerDataRequestSessionId;
             data.historySets.isLatest = eventData.isLatest || data.historySets.isLatest;
             break;
@@ -500,9 +546,11 @@ function consolidateEvents(data) {
             chats: Object.values(data.historySets.chats),
             messages: Object.values(data.historySets.messages),
             contacts: Object.values(data.historySets.contacts),
+            pastParticipants: data.historySets.pastParticipants,
             syncType: data.historySets.syncType,
             progress: data.historySets.progress,
             isLatest: data.historySets.isLatest,
+            chunkOrder: data.historySets.chunkOrder,
             peerDataRequestSessionId: data.historySets.peerDataRequestSessionId
         };
     }

package/lib/Utils/index.d.ts

@@ -20,4 +20,18 @@ export * from "./identity-change-handler.js";
 export * from "./stanza-ack.js";
 export * from "./rich-messages.js";
 export * from "./sticker-pack.js";
+export * from "./companion-reg-client-utils.js";
+export * from "./reporting-utils.js";
+// -- Añadido en v7.0.5: portado desde el fork beta --
+export * from "./lid-utils.js";
+export * from "./scheduled-messages.js";
+export * from "./anti-ban.js";
+export * from "./smart-reconnect.js";
+export * from "./message-queue.js";
+export * from "./enhanced-cache.js";
+export * from "./enhanced-logger.js";
+export * from "./bot-utils.js";
+export * from "./banner.js";
+export * from "./rich-message-utils.js";
+export * from "./use-sqlite-auth-state.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/Utils/index.js

@@ -18,6 +18,20 @@ export * from './message-retry-manager.js';
 export * from './browser-utils.js';
 export * from './identity-change-handler.js';
 export * from './stanza-ack.js';
+export * from './companion-reg-client-utils.js';
 export * from './rich-messages.js';
 export * from './sticker-pack.js';
+export * from './reporting-utils.js';
+// -- Añadido en v7.0.5: portado desde el fork beta --
+export * from './lid-utils.js';
+export * from './scheduled-messages.js';
+export * from './anti-ban.js';
+export * from './smart-reconnect.js';
+export * from './message-queue.js';
+export * from './enhanced-cache.js';
+export * from './enhanced-logger.js';
+export * from './bot-utils.js';
+export * from './banner.js';
+export * from './rich-message-utils.js';
+export * from './use-sqlite-auth-state.js';
 //# sourceMappingURL=index.js.map

package/lib/Utils/lid-utils.d.ts

@@ -0,0 +1,139 @@
+import type { WASocket } from '../Socket/index.js';
+
+export interface LidParticipant {
+    id?: string;
+    jid?: string;
+    lid?: string;
+    phoneNumber?: string;
+    admin?: string | null;
+}
+
+export interface LidMessage {
+    key: {
+        participant?: string;
+        remoteJid?: string;
+    };
+    participantPn?: string;
+}
+
+/**
+ * Cek apakah JID adalah format LID
+ */
+export declare const isLid: (jid: string | undefined) => boolean;
+
+/**
+ * Cek apakah JID adalah hasil konversi LID yang salah
+ */
+export declare const isLidConverted: (jid: string | undefined) => boolean;
+
+/**
+ * Convert LID ke format JID standard @s.whatsapp.net
+ */
+export declare const lidToJid: (jid: string) => string;
+
+/**
+ * Versi lidToJid yang aman, mengembalikan null jika tidak bisa convert
+ */
+export declare const lidToJidSafe: (jid: string) => string | null;
+
+/**
+ * Extract nomor dari JID apapun (termasuk LID)
+ */
+export declare const extractNumber: (jid: string) => Promise<string>;
+
+/**
+ * Resolve LID atau LID-converted JID ke JID asli menggunakan group metadata
+ */
+export declare const resolveLidFromParticipants: (
+    jid: string,
+    participants?: LidParticipant[]
+) => string;
+
+/**
+ * Resolve JID yang mungkin LID-converted ke JID asli
+ * Menangani cache, group participants, dan deteksi LID yang salah
+ */
+export declare const resolveAnyLidToJid: (
+    jid: string,
+    participants?: LidParticipant[]
+) => string;
+
+/**
+ * Convert array of JIDs, replacing any LIDs or LID-converted JIDs
+ */
+export declare const convertLidArray: (
+    jids: string[],
+    participants?: LidParticipant[]
+) => string[];
+
+/**
+ * Decode JID dan kembalikan dalam format standard
+ */
+export declare const decodeAndNormalize: (jid: string) => string | null;
+
+/**
+ * Konversi participant JID dari message
+ */
+export declare const resolveParticipant: (
+    msg: LidMessage,
+    sock?: WASocket
+) => Promise<string | null>;
+
+/**
+ * Helper untuk mendapatkan JID asli dari participant
+ */
+export declare const getParticipantJid: (participant: LidParticipant) => string;
+
+/**
+ * Convert semua participant IDs ke format yang bisa di-mention
+ */
+export declare const getParticipantJids: (participants?: LidParticipant[]) => string[];
+
+/**
+ * Cari participant berdasarkan nomor telepon
+ */
+export declare const findParticipantByNumber: (
+    participants: LidParticipant[],
+    targetJid: string
+) => LidParticipant | null;
+
+/**
+ * Cache LID to JID mapping dari array participant
+ */
+export declare const cacheParticipantLids: (participants?: LidParticipant[]) => void;
+
+/**
+ * Get cached JID for a LID
+ */
+export declare const getCachedJid: (lid: string) => string | null;
+
+/**
+ * Normalize JID ke nomor telepon (tanpa suffix @s.whatsapp.net atau @lid)
+ */
+export declare const normalizeToPhoneNumber: (
+    jid: string,
+    participants?: LidParticipant[]
+) => string;
+
+/**
+ * Simpan mapping LID-JID ke cache
+ */
+export declare const cacheLidJid: (lid: string, jid: string) => void;
+
+/**
+ * Resolve JID menggunakan sock.signalRepository o sock.store
+ */
+export declare const resolveFromSock: (
+    jid: string,
+    sock?: WASocket
+) => Promise<string>;
+
+/**
+ * Get jumlah item di LID cache
+ */
+export declare const getLidCacheSize: () => number;
+
+/**
+ * Simpan cache ke disk secara manual
+ */
+export declare const savePersistentCache: () => void;