@fer2809fl/baileys 7.0.4 → 7.0.5

package/lib/Utils/bot-utils.js

@@ -0,0 +1,241 @@
+import { isJidGroup, jidDecode, jidNormalizedUser } from '../WABinary/index.js';
+import { randomBytes } from 'crypto';
+
+function parseCommand(text, prefix = '.') {
+    if (!text || typeof text !== 'string') return { isCommand: false };
+    const trimmed = text.trim();
+    if (!trimmed.startsWith(prefix)) return { isCommand: false };
+    const withoutPrefix = trimmed.slice(prefix.length);
+    const parts = withoutPrefix.split(/\s+/);
+    const command = parts[0].toLowerCase();
+    const args = parts.slice(1);
+    const fullArgs = withoutPrefix.slice(command.length).trim();
+    const flags = {};
+    const cleanArgs = [];
+    for (const arg of args) {
+        if (arg.startsWith('--')) {
+            const [key, value] = arg.slice(2).split('=');
+            flags[key] = value || true;
+        } else if (arg.startsWith('-') && arg.length === 2) {
+            flags[arg.slice(1)] = true;
+        } else {
+            cleanArgs.push(arg);
+        }
+    }
+    return { isCommand: true, command, args: cleanArgs, fullArgs, flags, raw: text, prefix };
+}
+
+function extractMentions(message) {
+    const mentions = [];
+    const extendedText = message.extendedTextMessage;
+    if (extendedText?.contextInfo?.mentionedJid) mentions.push(...extendedText.contextInfo.mentionedJid);
+    if (message.mentionedJid) mentions.push(...message.mentionedJid);
+    const text = extractText(message);
+    if (text) {
+        const phoneMatches = text.match(/@(\d+)/g);
+        if (phoneMatches) {
+            phoneMatches.forEach(match => {
+                const phone = match.slice(1);
+                const jid = `${phone}@s.whatsapp.net`;
+                if (!mentions.includes(jid)) mentions.push(jid);
+            });
+        }
+    }
+    return [...new Set(mentions)];
+}
+
+function extractText(message) {
+    if (!message) return '';
+    if (typeof message === 'string') return message;
+    const textSources = [
+        message.conversation,
+        message.extendedTextMessage?.text,
+        message.imageMessage?.caption,
+        message.videoMessage?.caption,
+        message.documentMessage?.caption,
+        message.buttonsResponseMessage?.selectedButtonId,
+        message.listResponseMessage?.singleSelectReply?.selectedRowId,
+        message.templateButtonReplyMessage?.selectedId
+    ];
+    return textSources.find(t => t) || '';
+}
+
+function extractQuotedMessage(message) {
+    const contextInfo =
+        message.extendedTextMessage?.contextInfo ||
+        message.imageMessage?.contextInfo ||
+        message.videoMessage?.contextInfo ||
+        message.documentMessage?.contextInfo ||
+        message.stickerMessage?.contextInfo;
+    if (!contextInfo?.quotedMessage) return null;
+    return {
+        message: contextInfo.quotedMessage,
+        stanzaId: contextInfo.stanzaId,
+        participant: contextInfo.participant,
+        remoteJid: contextInfo.remoteJid,
+        text: extractText(contextInfo.quotedMessage)
+    };
+}
+
+async function isGroupAdmin(sock, jid, participantJid) {
+    try {
+        if (!isJidGroup(jid)) return false;
+        const metadata = await sock.groupMetadata(jid);
+        const participant = metadata.participants.find(
+            p => jidNormalizedUser(p.id) === jidNormalizedUser(participantJid)
+        );
+        return participant?.admin === 'admin' || participant?.admin === 'superadmin';
+    } catch { return false; }
+}
+
+async function isBotAdmin(sock, jid) {
+    const botJid = sock.user?.id;
+    if (!botJid) return false;
+    return isGroupAdmin(sock, jid, botJid);
+}
+
+function getSenderJid(msg) {
+    const isGroup = isJidGroup(msg.key.remoteJid);
+    return isGroup ? msg.key.participant : msg.key.remoteJid;
+}
+
+function formatJid(jid) {
+    if (!jid) return 'Unknown';
+    const decoded = jidDecode(jid);
+    return decoded?.user || jid.split('@')[0] || jid;
+}
+
+function generateMessageId() {
+    const timestamp = Date.now().toString(36);
+    const random = randomBytes(8).toString('hex');
+    return `${timestamp}-${random}`.toUpperCase();
+}
+
+function truncateText(text, maxLength = 100, suffix = '...') {
+    if (!text || text.length <= maxLength) return text;
+    return text.slice(0, maxLength - suffix.length) + suffix;
+}
+
+function escapeMarkdown(text) {
+    if (!text) return '';
+    return text.replace(/([*_`\[\]()])/g, '\\$1');
+}
+
+function formatPhoneNumber(jid) {
+    const number = jid.replace(/[^0-9]/g, '');
+    if (number.length >= 10) {
+        const countryCode = number.slice(0, -10);
+        const areaCode = number.slice(-10, -7);
+        const first = number.slice(-7, -4);
+        const last = number.slice(-4);
+        return `+${countryCode} ${areaCode} ${first} ${last}`;
+    }
+    return number;
+}
+
+class CooldownManager {
+    constructor() { this.cooldowns = new Map(); }
+    isOnCooldown(key, cooldownMs) {
+        const expiry = this.cooldowns.get(key);
+        if (!expiry) return false;
+        if (Date.now() < expiry) return true;
+        this.cooldowns.delete(key);
+        return false;
+    }
+    setCooldown(key, cooldownMs) { this.cooldowns.set(key, Date.now() + cooldownMs); }
+    getRemainingTime(key) {
+        const expiry = this.cooldowns.get(key);
+        if (!expiry) return 0;
+        return Math.max(0, expiry - Date.now());
+    }
+    cleanup() {
+        const now = Date.now();
+        for (const [key, expiry] of this.cooldowns) {
+            if (now >= expiry) this.cooldowns.delete(key);
+        }
+    }
+}
+
+class PermissionManager {
+    constructor(config = {}) {
+        this.owners = new Set(config.owners || []);
+        this.admins = new Set(config.admins || []);
+        this.banned = new Set(config.banned || []);
+        this.premiums = new Set(config.premiums || []);
+    }
+    isOwner(jid) { return this.owners.has(jidNormalizedUser(jid)); }
+    isAdmin(jid) {
+        const normalized = jidNormalizedUser(jid);
+        return this.admins.has(normalized) || this.owners.has(normalized);
+    }
+    isBanned(jid) { return this.banned.has(jidNormalizedUser(jid)); }
+    isPremium(jid) { return this.premiums.has(jidNormalizedUser(jid)); }
+    addOwner(jid) { this.owners.add(jidNormalizedUser(jid)); }
+    removeOwner(jid) { this.owners.delete(jidNormalizedUser(jid)); }
+    addAdmin(jid) { this.admins.add(jidNormalizedUser(jid)); }
+    removeAdmin(jid) { this.admins.delete(jidNormalizedUser(jid)); }
+    ban(jid) { this.banned.add(jidNormalizedUser(jid)); }
+    unban(jid) { this.banned.delete(jidNormalizedUser(jid)); }
+    addPremium(jid) { this.premiums.add(jidNormalizedUser(jid)); }
+    removePremium(jid) { this.premiums.delete(jidNormalizedUser(jid)); }
+    toJSON() {
+        return { owners: [...this.owners], admins: [...this.admins], banned: [...this.banned], premiums: [...this.premiums] };
+    }
+}
+
+function createReply(options) {
+    const { text, mentions = [], quoted = null } = options;
+    const message = { text };
+    if (mentions.length > 0) message.mentions = mentions;
+    if (quoted) message.quoted = quoted;
+    return message;
+}
+
+function parseTime(timeStr) {
+    if (!timeStr || typeof timeStr !== 'string') return 0;
+    const units = { s: 1000, m: 60 * 1000, h: 60 * 60 * 1000, d: 24 * 60 * 60 * 1000, w: 7 * 24 * 60 * 60 * 1000 };
+    const match = timeStr.match(/^(\d+)([smhdw])$/i);
+    if (!match) return 0;
+    const value = parseInt(match[1]);
+    const unit = match[2].toLowerCase();
+    return value * (units[unit] || 0);
+}
+
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0) return `${days}d ${hours % 24}h`;
+    if (hours > 0) return `${hours}h ${minutes % 60}m`;
+    if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+    return `${seconds}s`;
+}
+
+async function sendFast(sock, jid, content, opts = {}) {
+    const { quoted = null, markRead = false } = opts;
+    const message = typeof content === 'string' ? { text: content } : content;
+    if (markRead && quoted?.key) sock.readMessages([quoted.key]).catch(() => {});
+    return sock.sendMessage(jid, message, quoted ? { quoted } : {});
+}
+
+export {
+    parseCommand,
+    extractMentions,
+    extractText,
+    extractQuotedMessage,
+    isGroupAdmin,
+    isBotAdmin,
+    getSenderJid,
+    formatJid,
+    generateMessageId,
+    truncateText,
+    escapeMarkdown,
+    formatPhoneNumber,
+    CooldownManager,
+    PermissionManager,
+    createReply,
+    parseTime,
+    formatDuration,
+    sendFast
+};

package/lib/Utils/enhanced-cache.d.ts

@@ -0,0 +1,40 @@
+export declare const CACHE_CONFIG: {
+    MEMORY: { MAX_SIZE: number; TTL: number; STALE_TTL: number };
+    SIGNAL: { MAX_SIZE: number; TTL: number };
+    GROUPS: { MAX_SIZE: number; TTL: number };
+    PROFILES: { MAX_SIZE: number; TTL: number };
+    PERSIST_INTERVAL: number;
+    PERSIST_ON_SIZE: number;
+};
+
+export declare class EnhancedCache<T = any> {
+    constructor(name: string, options?: { MAX_SIZE?: number; TTL?: number; STALE_TTL?: number; persistPath?: string });
+    get(key: string): T | undefined;
+    set(key: string, value: T, ttl?: number): void;
+    delete(key: string): void;
+    has(key: string): boolean;
+    getMany(keys: string[]): { found: Record<string, T>; missing: string[] };
+    setMany(entries: Record<string, T>): void;
+    load(): Promise<void>;
+    getStats(): {
+        hits: number;
+        misses: number;
+        sets: number;
+        deletes: number;
+        hitRate: string;
+        size: number;
+        hotCacheSize: number;
+        dirtyKeys: number;
+    };
+    clear(): void;
+    cleanup(): void;
+}
+
+export declare class CacheManager {
+    constructor(baseDir?: string, logger?: any);
+    loadAll(): Promise<void>;
+    getCache(name: 'signal' | 'groups' | 'profiles' | 'messages' | 'misc'): EnhancedCache;
+    getAllStats(): Record<string, ReturnType<EnhancedCache['getStats']>>;
+    clearAll(): void;
+    cleanup(): Promise<void>;
+}

package/lib/Utils/enhanced-cache.js

@@ -0,0 +1,242 @@
+import { LRUCache } from 'lru-cache';
+import { readFile, writeFile } from 'fs/promises';
+import { join } from 'path';
+
+const CACHE_CONFIG = {
+    MEMORY: {
+        MAX_SIZE: 10000,
+        TTL: 30 * 60 * 1000,
+        STALE_TTL: 5 * 60 * 1000
+    },
+    SIGNAL: {
+        MAX_SIZE: 5000,
+        TTL: 60 * 60 * 1000
+    },
+    GROUPS: {
+        MAX_SIZE: 500,
+        TTL: 15 * 60 * 1000
+    },
+    PROFILES: {
+        MAX_SIZE: 1000,
+        TTL: 60 * 60 * 1000
+    },
+    PERSIST_INTERVAL: 5 * 60 * 1000,
+    PERSIST_ON_SIZE: 100
+};
+
+class EnhancedCache {
+    constructor(name, options = {}) {
+        this.name = name;
+        this.options = { ...CACHE_CONFIG.MEMORY, ...options };
+        this.persistPath = options.persistPath;
+        this.dirty = new Set();
+        this.persistTimer = null;
+        this.stats = { hits: 0, misses: 0, sets: 0, deletes: 0 };
+        this.cache = new LRUCache({
+            max: this.options.MAX_SIZE,
+            ttl: this.options.TTL,
+            allowStale: true,
+            updateAgeOnGet: true,
+            updateAgeOnHas: true
+        });
+        this.hotCache = new Map();
+        this.hotCacheMaxSize = Math.floor(this.options.MAX_SIZE * 0.1);
+        this.accessCount = new Map();
+        if (this.persistPath) this._startPersistence();
+    }
+
+    get(key) {
+        if (this.hotCache.has(key)) {
+            this.stats.hits++;
+            this._trackAccess(key);
+            return this.hotCache.get(key);
+        }
+        const value = this.cache.get(key);
+        if (value !== undefined) {
+            this.stats.hits++;
+            this._trackAccess(key);
+            if (this._isHotKey(key)) this._addToHotCache(key, value);
+            return value;
+        }
+        this.stats.misses++;
+        return undefined;
+    }
+
+    set(key, value, ttl = undefined) {
+        this.cache.set(key, value, { ttl: ttl || this.options.TTL });
+        this.stats.sets++;
+        if (this.hotCache.has(key)) this.hotCache.set(key, value);
+        if (this.persistPath) {
+            this.dirty.add(key);
+            if (this.dirty.size >= CACHE_CONFIG.PERSIST_ON_SIZE) this._persist();
+        }
+    }
+
+    delete(key) {
+        this.cache.delete(key);
+        this.hotCache.delete(key);
+        this.accessCount.delete(key);
+        this.dirty.delete(key);
+        this.stats.deletes++;
+    }
+
+    has(key) {
+        return this.hotCache.has(key) || this.cache.has(key);
+    }
+
+    getMany(keys) {
+        const result = {};
+        const missing = [];
+        for (const key of keys) {
+            const value = this.get(key);
+            if (value !== undefined) result[key] = value;
+            else missing.push(key);
+        }
+        return { found: result, missing };
+    }
+
+    setMany(entries) {
+        for (const [key, value] of Object.entries(entries)) this.set(key, value);
+    }
+
+    _trackAccess(key) {
+        const count = (this.accessCount.get(key) || 0) + 1;
+        this.accessCount.set(key, count);
+        if (this.accessCount.size > this.options.MAX_SIZE) this._cleanupAccessCount();
+    }
+
+    _isHotKey(key) {
+        return (this.accessCount.get(key) || 0) >= 3;
+    }
+
+    _addToHotCache(key, value) {
+        if (this.hotCache.size >= this.hotCacheMaxSize) {
+            let minKey = null;
+            let minCount = Infinity;
+            for (const [k] of this.hotCache) {
+                const count = this.accessCount.get(k) || 0;
+                if (count < minCount) { minCount = count; minKey = k; }
+            }
+            if (minKey) this.hotCache.delete(minKey);
+        }
+        this.hotCache.set(key, value);
+    }
+
+    _cleanupAccessCount() {
+        const entries = [...this.accessCount.entries()];
+        entries.sort((a, b) => b[1] - a[1]);
+        this.accessCount.clear();
+        entries.slice(0, this.options.MAX_SIZE / 2).forEach(([k, v]) => {
+            this.accessCount.set(k, Math.floor(v / 2));
+        });
+    }
+
+    _startPersistence() {
+        this.persistTimer = setInterval(() => {
+            if (this.dirty.size > 0) this._persist();
+        }, CACHE_CONFIG.PERSIST_INTERVAL);
+    }
+
+    async _persist() {
+        if (!this.persistPath || this.dirty.size === 0) return;
+        try {
+            const data = {};
+            for (const key of this.dirty) {
+                const value = this.cache.get(key);
+                if (value !== undefined) data[key] = value;
+            }
+            const filePath = join(this.persistPath, `${this.name}-cache.json`);
+            let existing = {};
+            try {
+                const content = await readFile(filePath, 'utf8');
+                existing = JSON.parse(content);
+            } catch {}
+            const merged = { ...existing, ...data };
+            await writeFile(filePath, JSON.stringify(merged), 'utf8');
+            this.dirty.clear();
+        } catch (error) {
+            console.error('Cache persist error:', error);
+        }
+    }
+
+    async load() {
+        if (!this.persistPath) return;
+        try {
+            const filePath = join(this.persistPath, `${this.name}-cache.json`);
+            const content = await readFile(filePath, 'utf8');
+            const data = JSON.parse(content);
+            for (const [key, value] of Object.entries(data)) this.cache.set(key, value);
+        } catch {}
+    }
+
+    getStats() {
+        const hitRate = this.stats.hits / (this.stats.hits + this.stats.misses) || 0;
+        return {
+            ...this.stats,
+            hitRate: (hitRate * 100).toFixed(2) + '%',
+            size: this.cache.size,
+            hotCacheSize: this.hotCache.size,
+            dirtyKeys: this.dirty.size
+        };
+    }
+
+    clear() {
+        this.cache.clear();
+        this.hotCache.clear();
+        this.accessCount.clear();
+        this.dirty.clear();
+    }
+
+    cleanup() {
+        if (this.persistTimer) clearInterval(this.persistTimer);
+        this._persist();
+        this.clear();
+    }
+}
+
+class CacheManager {
+    constructor(baseDir, logger) {
+        this.baseDir = baseDir;
+        this.logger = logger;
+        this.caches = {
+            signal: new EnhancedCache('signal', { ...CACHE_CONFIG.SIGNAL, persistPath: baseDir }),
+            groups: new EnhancedCache('groups', { ...CACHE_CONFIG.GROUPS, persistPath: baseDir }),
+            profiles: new EnhancedCache('profiles', { ...CACHE_CONFIG.PROFILES, persistPath: baseDir }),
+            messages: new EnhancedCache('messages', CACHE_CONFIG.MEMORY),
+            misc: new EnhancedCache('misc', CACHE_CONFIG.MEMORY)
+        };
+    }
+
+    async loadAll() {
+        await Promise.all([
+            this.caches.signal.load(),
+            this.caches.groups.load(),
+            this.caches.profiles.load()
+        ]);
+        this.logger?.info('All caches loaded');
+    }
+
+    getCache(name) {
+        return this.caches[name];
+    }
+
+    getAllStats() {
+        const stats = {};
+        for (const [name, cache] of Object.entries(this.caches)) stats[name] = cache.getStats();
+        return stats;
+    }
+
+    clearAll() {
+        for (const cache of Object.values(this.caches)) cache.clear();
+    }
+
+    async cleanup() {
+        for (const cache of Object.values(this.caches)) cache.cleanup();
+    }
+}
+
+export {
+    CACHE_CONFIG,
+    EnhancedCache,
+    CacheManager
+};

package/lib/Utils/enhanced-logger.d.ts

@@ -0,0 +1,41 @@
+export declare const LOG_LEVELS: {
+    fatal: number; error: number; warn: number; info: number; debug: number; trace: number; silent: number;
+};
+export declare const COLORS: Record<string, string>;
+export declare const CATEGORY_ICONS: Record<string, string>;
+
+export type LogLevel = 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace';
+
+export declare class RyzeLogger {
+    constructor(options?: {
+        level?: LogLevel;
+        prettyPrint?: boolean;
+        category?: string;
+        colors?: boolean;
+        timestamps?: boolean;
+        filters?: string[];
+        maxHistory?: number;
+    });
+    fatal(messageOrData: string | object, data?: object): void;
+    error(messageOrData: string | object, data?: object): void;
+    warn(messageOrData: string | object, data?: object): void;
+    info(messageOrData: string | object, data?: object): void;
+    debug(messageOrData: string | object, data?: object): void;
+    trace(messageOrData: string | object, data?: object): void;
+    success(message: string, data?: object): void;
+    child(bindings: { class?: string; category?: string }): RyzeLogger;
+    setLevel(level: LogLevel): void;
+    addFilter(pattern: string): void;
+    removeFilter(pattern: string): void;
+    getHistory(options?: { level?: LogLevel; category?: string; since?: string | number | Date; limit?: number }): Array<{ timestamp: string; level: LogLevel; category: string; message: string; data: any }>;
+    clearHistory(): void;
+    exportLogs(format?: 'json' | 'text'): string;
+    time(label: string): { end: (message?: string) => number };
+    if(condition: boolean, level: LogLevel, message: string, data?: object): void;
+    throttle(key: string, message: string, data?: object, intervalMs?: number): void;
+}
+
+export declare function createLogger(options?: ConstructorParameters<typeof RyzeLogger>[0]): RyzeLogger;
+
+declare const defaultLogger: RyzeLogger;
+export default defaultLogger;