@celestial-community/baileys 0.0.1-security → 1.0.0

package/lib/Utils/anti-delete.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Anti-Delete / Message Store untuk Baileys-Joss
+ *
+ * Fitur untuk menyimpan dan recover deleted messages
+ *
+ * @module anti-delete
+ */
+import type { WAMessage, WAMessageKey } from '../Types';
+export interface StoredMessage {
+    /** Original message */
+    message: WAMessage;
+    /** Timestamp disimpan */
+    storedAt: number;
+    /** Sudah dihapus */
+    isDeleted: boolean;
+    /** Timestamp dihapus */
+    deletedAt?: number;
+    /** Siapa yang menghapus */
+    deletedBy?: string;
+}
+export interface DeletedMessageInfo {
+    /** Original message sebelum dihapus */
+    originalMessage: WAMessage;
+    /** Key dari message yang dihapus */
+    key: WAMessageKey;
+    /** Timestamp dihapus */
+    deletedAt: number;
+    /** Siapa yang menghapus (participant untuk group) */
+    deletedBy?: string;
+    /** Apakah dihapus oleh pengirim (delete for everyone) */
+    isRevokedBySender: boolean;
+}
+export interface MessageStoreOptions {
+    /** Max messages per chat */
+    maxMessagesPerChat?: number;
+    /** TTL dalam ms (default 24 jam) */
+    ttl?: number;
+    /** Auto cleanup interval dalam ms */
+    cleanupInterval?: number;
+}
+export declare class MessageStore {
+    private store;
+    private deletedMessages;
+    private options;
+    private cleanupTimer?;
+    constructor(options?: MessageStoreOptions);
+    private startCleanup;
+    /**
+     * Stop cleanup timer
+     */
+    stopCleanup(): void;
+    /**
+     * Cleanup old messages
+     */
+    cleanup(): void;
+    /**
+     * Get store key dari message key
+     */
+    private getKey;
+    /**
+     * Store message
+     */
+    storeMessage(message: WAMessage): void;
+    /**
+     * Store multiple messages
+     */
+    storeMessages(messages: WAMessage[]): void;
+    /**
+     * Get stored message
+     */
+    getMessage(key: WAMessageKey): StoredMessage | undefined;
+    /**
+     * Get original message (untuk anti-delete)
+     */
+    getOriginalMessage(key: WAMessageKey): WAMessage | undefined;
+    /**
+     * Mark message as deleted dan store info
+     */
+    markAsDeleted(key: WAMessageKey, deletedBy?: string): DeletedMessageInfo | null;
+    /**
+     * Get deleted message info
+     */
+    getDeletedMessage(key: WAMessageKey): DeletedMessageInfo | undefined;
+    /**
+     * Get all deleted messages
+     */
+    getAllDeletedMessages(): DeletedMessageInfo[];
+    /**
+     * Get deleted messages by chat
+     */
+    getDeletedMessagesByChat(chatId: string): DeletedMessageInfo[];
+    /**
+     * Get all messages in chat
+     */
+    getChatMessages(chatId: string): WAMessage[];
+    /**
+     * Get chat IDs
+     */
+    getChatIds(): string[];
+    /**
+     * Get stats
+     */
+    getStats(): {
+        totalChats: number;
+        totalMessages: number;
+        totalDeleted: number;
+    };
+    /**
+     * Clear all
+     */
+    clear(): void;
+    /**
+     * Clear chat
+     */
+    clearChat(chatId: string): void;
+    /**
+     * Get all messages in all chats (compatibility for bot saving)
+     */
+    getAllMessages(): {
+        [jid: string]: WAMessage[];
+    };
+}
+/**
+ * Check apakah message adalah delete/revoke message
+ */
+export declare const isDeleteMessage: (message: WAMessage) => boolean;
+/**
+ * Get deleted message key dari revoke message
+ */
+export declare const getDeletedMessageKey: (message: WAMessage) => WAMessageKey | null;
+/**
+ * Create anti-delete handler
+ * Bisa dipasang ke sock.ev.on('messages.update')
+ */
+export declare const createAntiDeleteHandler: (store: MessageStore) => (updates: {
+    key: WAMessageKey;
+    update: Partial<WAMessage>;
+}[]) => DeletedMessageInfo[];
+/**
+ * Create message store handler
+ * Bisa dipasang ke sock.ev.on('messages.upsert')
+ */
+export declare const createMessageStoreHandler: (store: MessageStore) => ({ messages }: {
+    messages: WAMessage[];
+}) => void;
+declare const _default: {
+    MessageStore: typeof MessageStore;
+    isDeleteMessage: (message: WAMessage) => boolean;
+    getDeletedMessageKey: (message: WAMessage) => WAMessageKey | null;
+    createAntiDeleteHandler: (store: MessageStore) => (updates: {
+        key: WAMessageKey;
+        update: Partial<WAMessage>;
+    }[]) => DeletedMessageInfo[];
+    createMessageStoreHandler: (store: MessageStore) => ({ messages }: {
+        messages: WAMessage[];
+    }) => void;
+};
+export default _default;

package/lib/Utils/anti-delete.js

@@ -0,0 +1,293 @@
+'use strict'
+/**
+ * Anti-Delete / Message Store untuk Baileys-Joss
+ *
+ * Fitur untuk menyimpan dan recover deleted messages
+ *
+ * @module anti-delete
+ */
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.createMessageStoreHandler =
+    exports.createAntiDeleteHandler =
+    exports.getDeletedMessageKey =
+    exports.isDeleteMessage =
+    exports.MessageStore =
+        void 0
+const index_js_1 = require('../../WAProto/index.js')
+
+// MESSAGE STORE CLASS
+class MessageStore {
+    constructor(options = {}) {
+        this.store = new Map()
+        this.deletedMessages = new Map()
+        this.options = {
+            maxMessagesPerChat: options.maxMessagesPerChat || 1000,
+            ttl: options.ttl || 24 * 60 * 60 * 1000, // 24 hours
+            cleanupInterval: options.cleanupInterval || 60 * 60 * 1000 // 1 hour
+        }
+        // Start cleanup timer
+        this.startCleanup()
+    }
+    startCleanup() {
+        this.cleanupTimer = setInterval(() => {
+            this.cleanup()
+        }, this.options.cleanupInterval)
+    }
+    /**
+     * Stop cleanup timer
+     */
+    stopCleanup() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer)
+        }
+    }
+    /**
+     * Cleanup old messages
+     */
+    cleanup() {
+        const now = Date.now()
+        const cutoff = now - this.options.ttl
+        for (const [chatId, messages] of this.store) {
+            for (const [msgId, stored] of messages) {
+                if (stored.storedAt < cutoff) {
+                    messages.delete(msgId)
+                }
+            }
+            if (messages.size === 0) {
+                this.store.delete(chatId)
+            }
+        }
+        // Cleanup deleted messages
+        for (const [key, info] of this.deletedMessages) {
+            if (info.deletedAt < cutoff) {
+                this.deletedMessages.delete(key)
+            }
+        }
+    }
+    /**
+     * Get store key dari message key
+     */
+    getKey(key) {
+        return `${key.remoteJid}:${key.id}`
+    }
+    /**
+     * Store message
+     */
+    storeMessage(message) {
+        const chatId = message.key.remoteJid
+        if (!chatId || !message.key.id) return
+        let chatMessages = this.store.get(chatId)
+        if (!chatMessages) {
+            chatMessages = new Map()
+            this.store.set(chatId, chatMessages)
+        }
+        // Enforce max messages per chat
+        if (chatMessages.size >= this.options.maxMessagesPerChat) {
+            // Remove oldest message
+            const oldestKey = chatMessages.keys().next().value
+            if (oldestKey) {
+                chatMessages.delete(oldestKey)
+            }
+        }
+        chatMessages.set(message.key.id, {
+            message,
+            storedAt: Date.now(),
+            isDeleted: false
+        })
+    }
+    /**
+     * Store multiple messages
+     */
+    storeMessages(messages) {
+        for (const msg of messages) {
+            this.storeMessage(msg)
+        }
+    }
+    /**
+     * Get stored message
+     */
+    getMessage(key) {
+        const chatMessages = this.store.get(key.remoteJid)
+        if (!chatMessages) return undefined
+        return chatMessages.get(key.id)
+    }
+    /**
+     * Get original message (untuk anti-delete)
+     */
+    getOriginalMessage(key) {
+        var _a
+        return (_a = this.getMessage(key)) === null || _a === void 0 ? void 0 : _a.message
+    }
+    /**
+     * Mark message as deleted dan store info
+     */
+    markAsDeleted(key, deletedBy) {
+        const stored = this.getMessage(key)
+        if (!stored) return null
+        const now = Date.now()
+        stored.isDeleted = true
+        stored.deletedAt = now
+        stored.deletedBy = deletedBy
+        const info = {
+            originalMessage: stored.message,
+            key,
+            deletedAt: now,
+            deletedBy,
+            isRevokedBySender: !deletedBy || deletedBy === stored.message.key.participant
+        }
+        this.deletedMessages.set(this.getKey(key), info)
+        return info
+    }
+    /**
+     * Get deleted message info
+     */
+    getDeletedMessage(key) {
+        return this.deletedMessages.get(this.getKey(key))
+    }
+    /**
+     * Get all deleted messages
+     */
+    getAllDeletedMessages() {
+        return Array.from(this.deletedMessages.values())
+    }
+    /**
+     * Get deleted messages by chat
+     */
+    getDeletedMessagesByChat(chatId) {
+        return Array.from(this.deletedMessages.values()).filter(
+            (info) => info.key.remoteJid === chatId
+        )
+    }
+    /**
+     * Get all messages in chat
+     */
+    getChatMessages(chatId) {
+        const chatMessages = this.store.get(chatId)
+        if (!chatMessages) return []
+        return Array.from(chatMessages.values()).map((s) => s.message)
+    }
+    /**
+     * Get chat IDs
+     */
+    getChatIds() {
+        return Array.from(this.store.keys())
+    }
+    /**
+     * Get stats
+     */
+    getStats() {
+        let totalMessages = 0
+        for (const messages of this.store.values()) {
+            totalMessages += messages.size
+        }
+        return {
+            totalChats: this.store.size,
+            totalMessages,
+            totalDeleted: this.deletedMessages.size
+        }
+    }
+    /**
+     * Clear all
+     */
+    clear() {
+        this.store.clear()
+        this.deletedMessages.clear()
+    }
+    /**
+     * Clear chat
+     */
+    clearChat(chatId) {
+        this.store.delete(chatId)
+    }
+    /**
+     * Get all messages in all chats (compatibility for bot saving)
+     */
+    getAllMessages() {
+        const all = {}
+        for (const [chatId, messages] of this.store) {
+            all[chatId] = Array.from(messages.values()).map((s) => s.message)
+        }
+        return all
+    }
+}
+exports.MessageStore = MessageStore
+
+// HELPER FUNCTIONS
+/**
+ * Check apakah message adalah delete/revoke message
+ */
+const isDeleteMessage = (message) => {
+    var _a
+    const content = message.message
+    if (!content) return false
+    return (
+        ((_a = content.protocolMessage) === null || _a === void 0 ? void 0 : _a.type) ===
+        index_js_1.proto.Message.ProtocolMessage.Type.REVOKE
+    )
+}
+exports.isDeleteMessage = isDeleteMessage
+/**
+ * Get deleted message key dari revoke message
+ */
+const getDeletedMessageKey = (message) => {
+    const content = message.message
+    if (!content) return null
+    const protoMsg = content.protocolMessage
+    if (
+        (protoMsg === null || protoMsg === void 0 ? void 0 : protoMsg.type) !==
+        index_js_1.proto.Message.ProtocolMessage.Type.REVOKE
+    )
+        return null
+    return protoMsg.key || null
+}
+exports.getDeletedMessageKey = getDeletedMessageKey
+/**
+ * Create anti-delete handler
+ * Bisa dipasang ke sock.ev.on('messages.update')
+ */
+const createAntiDeleteHandler = (store) => {
+    return (updates) => {
+        var _a
+        const deletedMessages = []
+        for (const { key, update } of updates) {
+            // Check if message was deleted
+            if (update.messageStubType === index_js_1.proto.WebMessageInfo.StubType.REVOKE) {
+                const deletedInfo = store.markAsDeleted(
+                    key,
+                    (_a = update.messageStubParameters) === null || _a === void 0 ? void 0 : _a[0]
+                )
+                if (deletedInfo) {
+                    deletedMessages.push(deletedInfo)
+                }
+            }
+        }
+        return deletedMessages
+    }
+}
+exports.createAntiDeleteHandler = createAntiDeleteHandler
+/**
+ * Create message store handler
+ * Bisa dipasang ke sock.ev.on('messages.upsert')
+ */
+const createMessageStoreHandler = (store) => {
+    return ({ messages }) => {
+        // Filter out protocol messages
+        const regularMessages = messages.filter((msg) => {
+            const content = msg.message
+            if (!content) return false
+            // Skip protocol messages (delete, read receipt, etc)
+            if (content.protocolMessage) return false
+            if (content.senderKeyDistributionMessage) return false
+            return true
+        })
+        store.storeMessages(regularMessages)
+    }
+}
+exports.createMessageStoreHandler = createMessageStoreHandler
+exports.default = {
+    MessageStore,
+    isDeleteMessage: exports.isDeleteMessage,
+    getDeletedMessageKey: exports.getDeletedMessageKey,
+    createAntiDeleteHandler: exports.createAntiDeleteHandler,
+    createMessageStoreHandler: exports.createMessageStoreHandler
+}

package/lib/Utils/antiban-presets.js

@@ -0,0 +1,91 @@
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })
+exports.resolve_antiban_config = exports.antiban_presets = void 0
+
+/**
+ * @file antiban-presets.js
+ * @description Predefined anti-ban configuration presets — conservative
+ *   (safest, slowest), moderate (balanced), aggressive (fastest, riskier).
+ *   `resolve_antiban_config` accepts a preset name, an object with a
+ *   `preset` key plus overrides, or nothing (defaults to conservative).
+ * @author Denzy ZeroDay
+ */
+
+const antiban_presets = {
+    conservative: {
+        maxPerMinute: 5,
+        maxPerHour: 100,
+        maxPerDay: 800,
+        minDelayMs: 2500,
+        maxDelayMs: 7000,
+        newChatDelayMs: 4000,
+        warmupDays: 10,
+        day1Limit: 15,
+        growthFactor: 1.8,
+        inactivityThresholdHours: 72,
+        autoPauseAt: 'medium',
+        groupMultiplier: 0.5,
+        groupProfiles: false,
+        logging: true
+    },
+    moderate: {
+        maxPerMinute: 10,
+        maxPerHour: 300,
+        maxPerDay: 1500,
+        minDelayMs: 1500,
+        maxDelayMs: 5000,
+        newChatDelayMs: 3000,
+        warmupDays: 7,
+        day1Limit: 20,
+        growthFactor: 1.8,
+        inactivityThresholdHours: 72,
+        autoPauseAt: 'high',
+        groupMultiplier: 0.7,
+        groupProfiles: false,
+        logging: true
+    },
+    aggressive: {
+        maxPerMinute: 20,
+        maxPerHour: 800,
+        maxPerDay: 4000,
+        minDelayMs: 800,
+        maxDelayMs: 3000,
+        newChatDelayMs: 2000,
+        warmupDays: 4,
+        day1Limit: 35,
+        growthFactor: 2,
+        inactivityThresholdHours: 48,
+        autoPauseAt: 'critical',
+        groupMultiplier: 0.9,
+        groupProfiles: false,
+        logging: true
+    }
+}
+exports.antiban_presets = antiban_presets
+
+/**
+ * Resolve an anti-ban config from a preset name, an object with overrides,
+ * or nothing (defaults to 'conservative').
+ *
+ * @param {string|object|undefined} input
+ * @returns {object} resolved config
+ */
+function resolve_antiban_config(input) {
+    if (input === undefined) {
+        return { ...antiban_presets.conservative }
+    }
+    if (typeof input === 'string') {
+        if (!(input in antiban_presets)) {
+            throw new Error(`Unknown preset "${input}". Valid: ${Object.keys(antiban_presets).join(', ')}`)
+        }
+        return { ...antiban_presets[input] }
+    }
+    const { preset = 'conservative', ...overrides } = input
+    if (!(preset in antiban_presets)) {
+        throw new Error(`Unknown preset "${preset}". Valid: ${Object.keys(antiban_presets).join(', ')}`)
+    }
+    return { ...antiban_presets[preset], ...overrides }
+}
+exports.resolve_antiban_config = resolve_antiban_config
+
+module.exports = { antiban_presets, resolve_antiban_config }

package/lib/Utils/antiban-profiles.js

@@ -0,0 +1,43 @@
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })
+exports.apply_group_multiplier = exports.should_use_group_profile = exports.is_broadcast = exports.is_newsletter = exports.is_group = void 0
+
+/**
+ * @file antiban-profiles.js
+ * @description Small JID-classification helpers and a rate-limit multiplier
+ *   applier used to give groups/newsletters looser (or tighter) limits than
+ *   1:1 chats.
+ * @author Denzy ZeroDay
+ */
+
+function is_group(jid) {
+    return jid.endsWith('@g.us')
+}
+exports.is_group = is_group
+
+function is_newsletter(jid) {
+    return jid.endsWith('@newsletter')
+}
+exports.is_newsletter = is_newsletter
+
+function is_broadcast(jid) {
+    return jid === 'status@broadcast' || jid.endsWith('@broadcast')
+}
+exports.is_broadcast = is_broadcast
+
+function should_use_group_profile(jid) {
+    return is_group(jid) || is_newsletter(jid)
+}
+exports.should_use_group_profile = should_use_group_profile
+
+/** Scale maxPerMinute/Hour/Day limits by a multiplier (min 1 each) */
+function apply_group_multiplier(limits, multiplier) {
+    return {
+        maxPerMinute: Math.max(1, Math.floor(limits.maxPerMinute * multiplier)),
+        maxPerHour: Math.max(1, Math.floor(limits.maxPerHour * multiplier)),
+        maxPerDay: Math.max(1, Math.floor(limits.maxPerDay * multiplier))
+    }
+}
+exports.apply_group_multiplier = apply_group_multiplier
+
+module.exports = { is_group, is_newsletter, is_broadcast, should_use_group_profile, apply_group_multiplier }