jsdecryptor 4.0.3

package/davelib/lightweight_store.js

@@ -0,0 +1,169 @@
+const fs = require('fs')
+const STORE_FILE = './baileys_store.json'
+
+// Hard limits for low-memory panels
+let MAX_MESSAGES   = 5    // messages kept per chat
+const MAX_CONTACTS = 250  // max contacts in memory
+const MAX_CHATS    = 60   // max chats in memory
+
+try {
+    const settings = require('../daveset.js')
+    if (settings.maxStoreMessages && typeof settings.maxStoreMessages === 'number') {
+        MAX_MESSAGES = Math.min(settings.maxStoreMessages, 8)
+    }
+} catch (e) {}
+
+let _isDirty = false  // only flush to disk when data actually changed
+
+const store = {
+    messages: {},
+    contacts: {},
+    chats: {},
+
+    readFromFile(filePath = STORE_FILE) {
+        try {
+            if (fs.existsSync(filePath)) {
+                const raw = fs.readFileSync(filePath, 'utf-8')
+                if (!raw || raw.length < 2) return
+                const data = JSON.parse(raw)
+                this.contacts = data.contacts || {}
+                this.chats    = data.chats    || {}
+                this.messages = data.messages || {}
+                this._enforceAllLimits()
+            }
+        } catch (e) {
+            console.warn('[STORE] Failed to read:', e.message)
+        }
+    },
+
+    writeToFile(filePath = STORE_FILE) {
+        if (!_isDirty) return
+        try {
+            fs.writeFileSync(filePath, JSON.stringify({
+                contacts: this.contacts,
+                chats:    this.chats,
+                messages: this.messages
+            }))
+            _isDirty = false
+        } catch (e) {
+            console.warn('[STORE] Failed to write:', e.message)
+        }
+    },
+
+    _enforceAllLimits() {
+        // Contacts
+        const cKeys = Object.keys(this.contacts)
+        if (cKeys.length > MAX_CONTACTS) {
+            for (const k of cKeys.slice(0, cKeys.length - MAX_CONTACTS)) {
+                delete this.contacts[k]
+            }
+        }
+        // Chats
+        const chatKeys = Object.keys(this.chats)
+        if (chatKeys.length > MAX_CHATS) {
+            for (const k of chatKeys.slice(0, chatKeys.length - MAX_CHATS)) {
+                delete this.chats[k]
+            }
+        }
+        // Messages — trim each chat and drop old-format objects
+        for (const jid of Object.keys(this.messages)) {
+            if (!Array.isArray(this.messages[jid])) {
+                const vals = Object.values(this.messages[jid])
+                this.messages[jid] = vals.slice(-MAX_MESSAGES)
+            } else if (this.messages[jid].length > MAX_MESSAGES) {
+                this.messages[jid] = this.messages[jid].slice(-MAX_MESSAGES)
+            }
+        }
+    },
+
+    bind(ev) {
+        ev.on('messages.upsert', ({ messages }) => {
+            for (const msg of messages) {
+                if (!msg.key?.remoteJid) continue
+                const jid = msg.key.remoteJid
+                if (!this.messages[jid]) this.messages[jid] = []
+                this.messages[jid].push(msg)
+                if (this.messages[jid].length > MAX_MESSAGES) {
+                    this.messages[jid] = this.messages[jid].slice(-MAX_MESSAGES)
+                }
+                _isDirty = true
+            }
+        })
+
+        ev.on('contacts.update', (contacts) => {
+            for (const contact of contacts) {
+                if (!contact.id) continue
+                this.contacts[contact.id] = {
+                    id:   contact.id,
+                    name: contact.notify || contact.name || ''
+                }
+                _isDirty = true
+            }
+            const cKeys = Object.keys(this.contacts)
+            if (cKeys.length > MAX_CONTACTS) {
+                for (const k of cKeys.slice(0, cKeys.length - MAX_CONTACTS)) {
+                    delete this.contacts[k]
+                }
+            }
+        })
+
+        ev.on('chats.set', (data) => {
+            const chatList = Array.isArray(data) ? data : (data?.chats || [])
+            if (!Array.isArray(chatList)) return
+            const recent = chatList.slice(-MAX_CHATS)
+            for (const chat of recent) {
+                if (chat?.id) {
+                    this.chats[chat.id] = { id: chat.id, subject: chat.subject || '' }
+                    _isDirty = true
+                }
+            }
+            const chatKeys = Object.keys(this.chats)
+            if (chatKeys.length > MAX_CHATS) {
+                for (const k of chatKeys.slice(0, chatKeys.length - MAX_CHATS)) {
+                    delete this.chats[k]
+                }
+            }
+        })
+    },
+
+    async loadMessage(jid, id) {
+        return this.messages[jid]?.find(m => m.key.id === id) || null
+    },
+
+    // Called by index.js when RAM hits critical level — aggressive purge
+    purge() {
+        const msgJids = Object.keys(this.messages)
+        if (msgJids.length > 15) {
+            for (const k of msgJids.slice(0, msgJids.length - 15)) {
+                delete this.messages[k]
+            }
+        }
+        for (const jid of Object.keys(this.messages)) {
+            this.messages[jid] = this.messages[jid].slice(-2)
+        }
+        const cKeys = Object.keys(this.contacts)
+        for (const k of cKeys.slice(0, Math.floor(cKeys.length * 0.6))) {
+            delete this.contacts[k]
+        }
+        const chatKeys = Object.keys(this.chats)
+        for (const k of chatKeys.slice(0, Math.floor(chatKeys.length * 0.6))) {
+            delete this.chats[k]
+        }
+        _isDirty = false
+    },
+
+    getStats() {
+        let totalMessages = 0
+        for (const msgs of Object.values(this.messages)) {
+            if (Array.isArray(msgs)) totalMessages += msgs.length
+        }
+        return {
+            messages:           totalMessages,
+            contacts:           Object.keys(this.contacts).length,
+            chats:              Object.keys(this.chats).length,
+            maxMessagesPerChat: MAX_MESSAGES
+        }
+    }
+}
+
+module.exports = store

package/davelib/messageConfig.js

@@ -0,0 +1,15 @@
+const channelInfo = {
+  contextInfo: {
+    forwardingScore: 999,
+    isForwarded: false,
+    forwardedNewsletterMessageInfo: {
+      newsletterJid: '@newsletter',
+      newsletterName: 'l',
+      serverMessageId: -1,
+    }
+  }
+};
+
+module.exports = {
+  channelInfo
+};;

package/davelib/messageHandler.js

@@ -0,0 +1,87 @@
+function getMessageText(message) {
+    if (!message?.message) return '';
+
+    const msg = message.message;
+
+    return msg.conversation?.trim() ||
+           msg.extendedTextMessage?.text?.trim() ||
+           msg.imageMessage?.caption?.trim() ||
+           msg.videoMessage?.caption?.trim() ||
+           msg.documentMessage?.caption?.trim() ||
+           msg.buttonsResponseMessage?.selectedButtonId?.trim() ||
+           msg.listResponseMessage?.singleSelectReply?.selectedRowId?.trim() ||
+           msg.templateButtonReplyMessage?.selectedId?.trim() ||
+           '';
+}
+
+function isEditedMessage(message) {
+    if (!message?.message) return false;
+    
+    const msg = message.message;
+    
+    // Baileys protocol message for edits (type 14)
+    if (msg.protocolMessage?.type === 14) return true;
+    if (msg.protocolMessage?.type === 'MESSAGE_EDIT') return true;
+    if (msg.editedMessage) return true;
+    
+    return false;
+}
+
+function getEditedMessageText(message) {
+    if (!message?.message) return '';
+
+    const msg = message.message;
+
+    if (msg.protocolMessage?.editedMessage?.message) {
+        const edited = msg.protocolMessage.editedMessage.message;
+        return edited.conversation?.trim() ||
+               edited.extendedTextMessage?.text?.trim() ||
+               '';
+    }
+
+    if (msg.editedMessage?.message) {
+        const edited = msg.editedMessage.message;
+        return edited.conversation?.trim() ||
+               edited.extendedTextMessage?.text?.trim() ||
+               '';
+    }
+
+    return '';
+}
+
+function extractCommand(text, prefix) {
+    if (!text || typeof text !== 'string') return { command: '', args: [], fullArgs: '' };
+    
+    const trimmed = text.trim();
+    
+    if (prefix && !trimmed.startsWith(prefix)) {
+        return { command: '', args: [], fullArgs: '' };
+    }
+
+    const withoutPrefix = prefix ? trimmed.slice(prefix.length).trimStart() : trimmed;
+    const parts = withoutPrefix.split(/\s+/).filter(p => p.length > 0);
+    const command = parts[0]?.toLowerCase() || '';
+    const args = parts.slice(1);
+    const fullArgs = args.join(' ');
+
+    return { command, args, fullArgs };
+}
+
+function shouldProcessEditedMessage(message, prefix) {
+    if (!isEditedMessage(message)) return false;
+    
+    const editedText = getEditedMessageText(message);
+    if (!editedText) return false;
+
+    if (prefix && !editedText.startsWith(prefix)) return false;
+
+    return true;
+}
+
+module.exports = {
+    getMessageText,
+    isEditedMessage,
+    getEditedMessageText,
+    extractCommand,
+    shouldProcessEditedMessage
+};

package/davelib/myfunc.js

@@ -0,0 +1,379 @@
+
+
+
+
+
+
+const {
+    proto,
+    delay,
+    getContentType
+} = require('@whiskeysockets/baileys')
+const chalk = require('chalk').default || require('chalk')
+const fs = require('fs')
+const Crypto = require('crypto')
+const axios = require('axios')
+const moment = require('moment-timezone')
+const {
+    sizeFormatter
+} = require('human-readable')
+const util = require('util')
+const Jimp = require('jimp')
+const {
+    defaultMaxListeners
+} = require('stream')
+const path = require('path')
+const { tmpdir } = require('os')
+
+const unixTimestampSeconds = (date = new Date()) => Math.floor(date.getTime() / 1000)
+
+exports.unixTimestampSeconds = unixTimestampSeconds
+
+exports.generateMessageTag = (epoch) => {
+    let tag = (0, exports.unixTimestampSeconds)().toString();
+    if (epoch)
+        tag += '.--' + epoch; // attach epoch if provided
+    return tag;
+}
+
+exports.processTime = (timestamp, now) => {
+    return moment.duration(now - moment(timestamp * 1000)).asSeconds()
+}
+
+exports.getRandom = (ext) => {
+    return `${Math.floor(Math.random() * 10000)}${ext}`
+}
+
+exports.getBuffer = async (url, options) => {
+    try {
+        options ? options : {}
+        const res = await axios({
+            method: "get",
+            url,
+            headers: {
+                'DNT': 1,
+                'Upgrade-Insecure-Request': 1
+            },
+            ...options,
+            responseType: 'arraybuffer'
+        })
+        return res.data
+    } catch (err) {
+        return err
+    }
+}
+
+exports.getImg = async (url, options) => {
+    try {
+        options ? options : {}
+        const res = await axios({
+            method: "get",
+            url,
+            headers: {
+                'DNT': 1,
+                'Upgrade-Insecure-Request': 1
+            },
+            ...options,
+            responseType: 'arraybuffer'
+        })
+        return res.data
+    } catch (err) {
+        return err
+    }
+}
+
+exports.fetchJson = async (url, options) => {
+    try {
+        options ? options : {}
+        const res = await axios({
+            method: 'GET',
+            url: url,
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.69 Safari/537.36'
+            },
+            ...options
+        })
+        return res.data
+    } catch (err) {
+        return err
+    }
+}
+
+exports.runtime = function(seconds) {
+    seconds = Number(seconds);
+    var d = Math.floor(seconds / (3600 * 24));
+    var h = Math.floor(seconds % (3600 * 24) / 3600);
+    var m = Math.floor(seconds % 3600 / 60);
+    var s = Math.floor(seconds % 60);
+    var dDisplay = d > 0 ? d + (d == 1 ? " day, " : " days, ") : "";
+    var hDisplay = h > 0 ? h + (h == 1 ? " hour, " : " hours, ") : "";
+    var mDisplay = m > 0 ? m + (m == 1 ? " minute, " : " minutes, ") : "";
+    var sDisplay = s > 0 ? s + (s == 1 ? " second" : " seconds") : "";
+    return dDisplay + hDisplay + mDisplay + sDisplay;
+}
+
+exports.clockString = (ms) => {
+    let h = isNaN(ms) ? '--' : Math.floor(ms / 3600000)
+    let m = isNaN(ms) ? '--' : Math.floor(ms / 60000) % 60
+    let s = isNaN(ms) ? '--' : Math.floor(ms / 1000) % 60
+    return [h, m, s].map(v => v.toString().padStart(2, 0)).join(':')
+}
+
+exports.sleep = async (ms) => {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+exports.isUrl = (url) => {
+    return url.match(new RegExp(/https?:\/\/(www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&/=]*)/, 'gi'))
+}
+
+exports.getTime = (format, date) => {
+    if (date) {
+        return moment(date).locale('id').format(format)
+    } else {
+        return moment.tz('Asia/Jakarta').locale('id').format(format)
+    }
+}
+
+exports.formatDate = (n, locale = 'id') => {
+    let d = new Date(n)
+    return d.toLocaleDateString(locale, {
+        weekday: 'long',
+        day: 'numeric',
+        month: 'long',
+        year: 'numeric',
+        hour: 'numeric',
+        minute: 'numeric',
+        second: 'numeric'
+    })
+}
+
+exports.tanggal = (numer) => {
+    const myMonths = ["Januari", "Februari", "Maret", "April", "Mei", "Juni", "Juli", "Agustus", "September", "Oktober", "November", "Desember"];
+    const myDays = ['Minggu', 'Senin', 'Selasa', 'Rabu', 'Kamis', "Jum'at", 'Sabtu'];
+    const tgl = new Date(numer);
+    const day = tgl.getDate();
+    const bulan = tgl.getMonth();
+    let thisDay = tgl.getDay();
+    thisDay = myDays[thisDay];
+    const yy = tgl.getYear();
+    const year = (yy < 1000) ? yy + 1900 : yy;
+    const time = moment.tz('Africa/Nsirobi').format('DD/MM HH:mm:ss');
+    const d = new Date();
+    const locale = 'id';
+    const gmt = new Date(0).getTime() - new Date('1 January 1970').getTime();
+    const weton = ['Pahing', 'Pon', 'Wage', 'Kliwon', 'Legi'][Math.floor(((d * 1) + gmt) / 84600000) % 5];
+
+    return `${thisDay}, ${day} - ${myMonths[bulan]} - ${year}`;
+}
+
+exports.jam = (numer, options = {}) => {
+    let format = options.format ? options.format : "HH:mm"
+    let jam = options?.timeZone ? moment(numer).tz(timeZone).format(format) : moment(numer).format(format)
+
+    return `${jam}`
+}
+
+exports.formatp = sizeFormatter({
+    std: 'JEDEC', //'SI' = default | 'IEC' | 'JEDEC'
+    decimalPlaces: 2,
+    keepTrailingZeroes: false,
+    render: (literal, symbol) => `${literal} ${symbol}B`,
+})
+
+exports.json = (string) => {
+    return JSON.stringify(string, null, 2)
+}
+
+function format(...args) {
+    return util.format(...args)
+}
+
+exports.logic = (check, inp, out) => {
+    if (inp.length !== out.length) throw new Error('Input and Output must have same length')
+    for (let i in inp)
+        if (util.isDeepStrictEqual(check, inp[i])) return out[i]
+    return null
+}
+
+exports.generateProfilePicture = async (buffer) => {
+    const jimp = await Jimp.read(buffer)
+    const min = jimp.getWidth()
+    const max = jimp.getHeight()
+    const cropped = jimp.crop(0, 0, min, max)
+    return {
+        img: await cropped.scaleToFit(720, 720).getBufferAsync(Jimp.MIME_JPEG),
+        preview: await cropped.scaleToFit(720, 720).getBufferAsync(Jimp.MIME_JPEG)
+    }
+}
+
+exports.bytesToSize = (bytes, decimals = 2) => {
+    if (bytes === 0) return '0 Bytes';
+
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
+}
+
+exports.getSizeMedia = (path) => {
+    return new Promise((resolve, reject) => {
+        if (/http/.test(path)) {
+            axios.get(path)
+                .then((res) => {
+                    let length = parseInt(res.headers['content-length'])
+                    let size = exports.bytesToSize(length, 3)
+                    if (!isNaN(length)) resolve(size)
+                })
+        } else if (Buffer.isBuffer(path)) {
+            let length = Buffer.byteLength(path)
+            let size = exports.bytesToSize(length, 3)
+            if (!isNaN(length)) resolve(size)
+        } else {
+            reject('error gatau apah')
+        }
+    })
+}
+
+exports.parseMention = (text = '') => {
+    return [...text.matchAll(/@([0-9]{5,16}|0)/g)].map(v => v[1] + '@s.whatsapp.net')
+}
+
+exports.getGroupAdmins = (participants) => {
+    let admins = []
+    for (let i of participants) {
+        i.admin === "superadmin" ? admins.push(i.id) : i.admin === "admin" ? admins.push(i.id) : ''
+    }
+    return admins || []
+}
+
+/**
+ * Serialize Message
+ * @param {WAConnection} conn 
+ * @param {Object} m 
+ * @param {store} store 
+ */
+exports.smsg = (XeonBotInc, m, store) => {
+    if (!m) return m
+    let M = proto.WebMessageInfo
+    if (m.key) {
+        m.id = m.key.id
+        m.isBaileys = m.id.startsWith('BAE5') && m.id.length === 16
+        m.chat = m.key.remoteJid
+        m.fromMe = m.key.fromMe
+        m.isGroup = m.chat.endsWith('@g.us')
+        m.sender = XeonBotInc.decodeJid(m.fromMe && XeonBotInc.user.id || m.participant || m.key.participant || m.chat || '')
+        if (m.isGroup) m.participant = XeonBotInc.decodeJid(m.key.participant) || ''
+    }
+    if (m.message) {
+        m.mtype = getContentType(m.message)
+        m.msg = (m.mtype == 'viewOnceMessage' ? m.message[m.mtype].message[getContentType(m.message[m.mtype].message)] : m.message[m.mtype])
+        m.body = m.message.conversation || m.msg.caption || m.msg.text || (m.mtype == 'listResponseMessage') && m.msg.singleSelectReply.selectedRowId || (m.mtype == 'buttonsResponseMessage') && m.msg.selectedButtonId || (m.mtype == 'viewOnceMessage') && m.msg.caption || m.text
+        let quoted = m.quoted = m.msg.contextInfo ? m.msg.contextInfo.quotedMessage : null
+        m.mentionedJid = m.msg.contextInfo ? m.msg.contextInfo.mentionedJid : []
+        if (m.quoted) {
+            let type = getContentType(quoted)
+            m.quoted = m.quoted[type]
+            if (['productMessage'].includes(type)) {
+                type = getContentType(m.quoted)
+                m.quoted = m.quoted[type]
+            }
+            if (typeof m.quoted === 'string') m.quoted = {
+                text: m.quoted
+            }
+            m.quoted.mtype = type
+            m.quoted.id = m.msg.contextInfo.stanzaId
+            m.quoted.chat = m.msg.contextInfo.remoteJid || m.chat
+            m.quoted.isBaileys = m.quoted.id ? m.quoted.id.startsWith('BAE5') && m.quoted.id.length === 16 : false
+            m.quoted.sender = XeonBotInc.decodeJid(m.msg.contextInfo.participant)
+            m.quoted.fromMe = m.quoted.sender === (XeonBotInc.user && XeonBotInc.user.id)
+            m.quoted.text = m.quoted.text || m.quoted.caption || m.quoted.conversation || m.quoted.contentText || m.quoted.selectedDisplayText || m.quoted.title || ''
+            m.quoted.mentionedJid = m.msg.contextInfo ? m.msg.contextInfo.mentionedJid : []
+            m.getQuotedObj = m.getQuotedMessage = async () => {
+                if (!m.quoted.id) return false
+                let q = await store.loadMessage(m.chat, m.quoted.id, XeonBotInc)
+                return exports.smsg(XeonBotInc, q, store)
+            }
+            let vM = m.quoted.fakeObj = M.fromObject({
+                key: {
+                    remoteJid: m.quoted.chat,
+                    fromMe: m.quoted.fromMe,
+                    id: m.quoted.id
+                },
+                message: quoted,
+                ...(m.isGroup ? {
+                    participant: m.quoted.sender
+                } : {})
+            })
+
+            /**
+             * 
+             * @returns 
+             */
+            m.quoted.delete = () => XeonBotInc.sendMessage(m.quoted.chat, {
+                delete: vM.key
+            })
+
+            /**
+             * 
+             * @param {*} jid 
+             * @param {*} forceForward 
+             * @param {*} options 
+             * @returns 
+             */
+            m.quoted.copyNForward = (jid, forceForward = false, options = {}) => XeonBotInc.copyNForward(jid, vM, forceForward, options)
+
+            /**
+             *
+             * @returns
+             */
+            m.quoted.download = () => XeonBotInc.downloadMediaMessage(m.quoted)
+        }
+    }
+    if (m.msg.url) m.download = () => XeonBotInc.downloadMediaMessage(m.msg)
+    m.text = m.msg.text || m.msg.caption || m.message.conversation || m.msg.contentText || m.msg.selectedDisplayText || m.msg.title || ''
+    /**
+     * Reply to this message
+     * @param {String|Object} text 
+     * @param {String|false} chatId 
+     * @param {Object} options 
+     */
+    m.reply = (text, chatId = m.chat, options = {}) => Buffer.isBuffer(text) ? XeonBotInc.sendMedia(chatId, text, 'file', '', m, {
+        ...options
+    }) : XeonBotInc.sendText(chatId, text, m, {
+        ...options
+    })
+    /**
+     * Copy this message
+     */
+    m.copy = () => exports.smsg(XeonBotInc, M.fromObject(M.toObject(m)))
+
+    /**
+     * 
+     * @param {*} jid 
+     * @param {*} forceForward 
+     * @param {*} options 
+     * @returns 
+     */
+    m.copyNForward = (jid = m.chat, forceForward = false, options = {}) => XeonBotInc.copyNForward(jid, m, forceForward, options)
+
+    return m
+}
+exports.reSize = (buffer, ukur1, ukur2) => {
+    return new Promise(async (resolve, reject) => {
+        var baper = await Jimp.read(buffer);
+        var ab = await baper.resize(ukur1, ukur2).getBufferAsync(Jimp.MIME_JPEG)
+        resolve(ab)
+    })
+}
+
+let file = require.resolve(__filename)
+fs.watchFile(file, () => {
+    fs.unwatchFile(file)
+    console.log(chalk.redBright(`Update ${__filename}`))
+    delete require.cache[file]
+    require(file)
+})