vinzzsync-wacli 1.0.0

package/plugins/savefile.js

@@ -0,0 +1,334 @@
+import fs from 'fs';
+import path from 'path';
+
+function getMessageContent(message) {
+    if (!message) return null;
+
+    if (message.ephemeralMessage?.message) {
+        return getMessageContent(message.ephemeralMessage.message);
+    }
+
+    if (message.viewOnceMessage?.message) {
+        return getMessageContent(message.viewOnceMessage.message);
+    }
+
+    if (message.viewOnceMessageV2?.message) {
+        return getMessageContent(message.viewOnceMessageV2.message);
+    }
+
+    if (message.viewOnceMessageV2Extension?.message) {
+        return getMessageContent(
+            message.viewOnceMessageV2Extension.message
+        );
+    }
+
+    return message;
+}
+
+function getQuotedType(message) {
+    const content = getMessageContent(message);
+
+    if (!content) return null;
+
+    if (content.documentMessage) return 'document';
+    if (content.imageMessage) return 'image';
+    if (content.videoMessage) return 'video';
+    if (content.audioMessage) return 'audio';
+    if (content.conversation) return 'text';
+    if (content.extendedTextMessage) return 'text';
+
+    return null;
+}
+
+function getText(message) {
+    const content = getMessageContent(message);
+
+    if (!content) return '';
+
+    if (typeof content.conversation === 'string') {
+        return content.conversation;
+    }
+
+    if (typeof content.extendedTextMessage?.text === 'string') {
+        return content.extendedTextMessage.text;
+    }
+
+    return '';
+}
+
+function getExtension(type, message, fileName) {
+    if (fileName) {
+        const ext = path.extname(fileName);
+
+        if (ext) {
+            return ext;
+        }
+    }
+
+    const content = getMessageContent(message);
+
+    if (type === 'image') {
+        const mime = content?.imageMessage?.mimetype || '';
+
+        if (mime.includes('png')) return '.png';
+        if (mime.includes('webp')) return '.webp';
+
+        return '.jpg';
+    }
+
+    if (type === 'video') {
+        const mime = content?.videoMessage?.mimetype || '';
+
+        if (mime.includes('webm')) return '.webm';
+        if (mime.includes('3gp')) return '.3gp';
+
+        return '.mp4';
+    }
+
+    if (type === 'audio') {
+        const mime = content?.audioMessage?.mimetype || '';
+
+        if (mime.includes('ogg')) return '.ogg';
+        if (mime.includes('opus')) return '.opus';
+        if (mime.includes('mpeg')) return '.mp3';
+        if (mime.includes('mp4')) return '.m4a';
+
+        return '.ogg';
+    }
+
+    return '';
+}
+
+function sanitizeName(name) {
+    return String(name || '')
+        .trim()
+        .replace(/[<>:"/\\|?*\x00-\x1F]/g, '_');
+}
+
+export default {
+    command: 'sf',
+
+    async run(ctx) {
+        const {
+            m,
+            text,
+            args,
+            sock
+        } = ctx;
+
+        if (!m?.chat) {
+            return;
+        }
+
+        const input = String(text || '').trim();
+
+        if (!input) {
+            await m.reply({
+                text: 'Gunakan:\n.sf <code> <nama>\natau reply file/pesan dengan .sf <nama>'
+            });
+            return;
+        }
+
+        let fileName = '';
+        let sourceText = '';
+        let quotedType = null;
+
+        if (m.quoted?.message) {
+            fileName = sanitizeName(
+                args?.[0] || ''
+            );
+
+            if (!fileName) {
+                await m.reply({
+                    text: 'Masukkan nama file.\nContoh: .sf foto.jpg'
+                });
+                return;
+            }
+
+            quotedType = getQuotedType(
+                m.quoted.message
+            );
+
+            if (!quotedType) {
+                await m.reply({
+                    text: 'Tipe pesan tidak didukung.'
+                });
+                return;
+            }
+        } else {
+            if (!args || args.length < 2) {
+                await m.reply({
+                    text: 'Gunakan:\n.sf <code> <nama>'
+                });
+                return;
+            }
+
+            fileName = sanitizeName(
+                args[args.length - 1]
+            );
+
+            sourceText = input
+                .slice(
+                    0,
+                    input.length - fileName.length
+                )
+                .trim();
+
+            if (!sourceText) {
+                await m.reply({
+                    text: 'Code/teks tidak boleh kosong.'
+                });
+                return;
+            }
+        }
+
+        if (!fileName) {
+            await m.reply({
+                text: 'Nama file tidak valid.'
+            });
+            return;
+        }
+
+        if (
+            fileName === '.' ||
+            fileName === '..' ||
+            fileName.includes('\0')
+        ) {
+            await m.reply({
+                text: 'Nama file tidak valid.'
+            });
+            return;
+        }
+
+        const filePath = path.resolve(
+            './',
+            fileName
+        );
+
+        if (m.quoted?.message) {
+            try {
+                if (quotedType === 'text') {
+                    const content =
+                        getText(m.quoted.message);
+
+                    if (!content) {
+                        await m.reply({
+                            text: 'Teks pada pesan tidak ditemukan.'
+                        });
+                        return;
+                    }
+
+                    fs.writeFileSync(
+                        filePath,
+                        content,
+                        'utf8'
+                    );
+
+                    await m.reply({
+                        text: `File berhasil disimpan: ${fileName}`
+                    });
+
+                    return;
+                }
+
+                const extension =
+                    getExtension(
+                        quotedType,
+                        m.quoted.message,
+                        fileName
+                    );
+
+                if (
+                    !path.extname(fileName) &&
+                    extension
+                ) {
+                    fileName += extension;
+                }
+
+                const finalPath = path.resolve(
+                    './',
+                    fileName
+                );
+
+                if (
+                    !finalPath.startsWith(
+                        path.resolve('./') +
+                        path.sep
+                    )
+                ) {
+                    await m.reply({
+                        text: 'Path file tidak valid.'
+                    });
+                    return;
+                }
+
+                const buffer =
+                    await sock.downloadMediaMessage(
+                        m.quoted,
+                        'buffer',
+                        {}
+                    );
+
+                if (!buffer) {
+                    throw new Error(
+                        'Gagal mengambil media dari pesan.'
+                    );
+                }
+
+                fs.writeFileSync(
+                    finalPath,
+                    buffer
+                );
+
+                await m.reply({
+                    text: `File berhasil disimpan: ${fileName}`
+                });
+
+                return;
+            } catch (error) {
+                console.error('[sf]', error);
+
+                await m.reply({
+                    text: `Gagal menyimpan file: ${error?.message || error}`
+                });
+
+                return;
+            }
+        }
+
+        try {
+            const finalPath = path.resolve(
+                './',
+                fileName
+            );
+
+            if (
+                !finalPath.startsWith(
+                    path.resolve('./') +
+                    path.sep
+                )
+            ) {
+                await m.reply({
+                    text: 'Path file tidak valid.'
+                });
+                return;
+            }
+
+            fs.writeFileSync(
+                finalPath,
+                sourceText,
+                'utf8'
+            );
+
+            await m.reply({
+                text: `File berhasil disimpan: ${fileName}`
+            });
+        } catch (error) {
+            console.error('[sf]', error);
+
+            await m.reply({
+                text: `Gagal menyimpan file: ${error?.message || error}`
+            });
+        }
+    }
+};

package/plugins/send.js

@@ -0,0 +1,52 @@
+function out(m, ...args) {
+    if (m?.reply) {
+        const text = args.map(v => typeof v === "string" ? v : String(v)).join(" ");
+        void m.reply({ text });
+    } else {
+        console.log(...args);
+    }
+}
+
+export default {
+    command: 'send',
+
+    async run({
+        m,
+        args,
+        normalizeJid,
+        warn,
+        debug,
+        sock,
+        info
+    }) {
+        if (args.length < 2) {
+            out(m, 'Gunakan: send <nomor> <pesan>');
+            return;
+        }
+
+        const target = normalizeJid(args.shift());
+        const message = args.join(' ');
+
+        if (!target) {
+            out(m, 'Nomor/JID tidak valid.');
+            return;
+        }
+
+        debug('sendMessage', {
+            target,
+            message
+        });
+
+        await sock.sendMessage(
+            target,
+            {
+                text: message
+            },
+            {
+                quoted: global.v
+            }
+        );
+
+        out(m, `Pesan terkirim ke ${target}`);
+    }
+};

package/plugins/session.js

@@ -0,0 +1,18 @@
+function out(m, text) {
+    if (m?.reply) {
+        void m.reply({ text });
+    } else {
+        console.log(text);
+    }
+}
+
+export default {
+    command: 'session',
+
+    async run({ m, detectSession, debug }) {
+        const detected = detectSession();
+        debug('Session details', detected.details);
+        const text = `======= SESSION DETECT =======\nType       : ${detected.type}\nPath       : ${detected.path ?? '-'}\nRegistered : ${detected.registered}\n==============================`;
+        out(m, text);
+    }
+};

package/plugins/smsg.js

@@ -0,0 +1,204 @@
+function out(m, ...args) {
+    const text = args
+        .map(v => typeof v === "string" ? v : String(v))
+        .join(" ");
+
+    if (m?.reply) {
+        void m.reply({ text });
+    } else {
+        console.log(...args);
+    }
+}
+
+export default {
+    command: 'smsg',
+
+    async run({
+        text,
+        m,
+        messageStore,
+        getMessageType,
+        MAX_MESSAGES
+    }) {
+        const input = text.trim();
+
+        if (!input) {
+            out(m, 'Gunakan: smsg [text],[nomor],[jid],[messageId]');
+            return;
+        }
+
+        const parts = input.split(',');
+
+        const searchText =
+            String(parts[0] || '').trim().toLowerCase();
+
+        const searchNumber =
+            String(parts[1] || '').trim().replace(/\D/g, '');
+
+        const inputJid =
+            String(parts[2] || '').trim().toLowerCase();
+
+        const inputId =
+            String(parts[3] || '').trim();
+
+        const searchJid =
+            String(inputJid || m?.chat || '')
+                .trim()
+                .toLowerCase();
+
+        const searchMessageId = inputId;
+
+        const results = [];
+
+        function getMessageText(message) {
+            let msg = message?.message;
+
+            if (!msg) return '';
+
+            if (msg.ephemeralMessage?.message) {
+                msg = msg.ephemeralMessage.message;
+            }
+
+            if (msg.viewOnceMessage?.message) {
+                msg = msg.viewOnceMessage.message;
+            }
+
+            if (msg.viewOnceMessageV2?.message) {
+                msg = msg.viewOnceMessageV2.message;
+            }
+
+            if (msg.viewOnceMessageV2Extension?.message) {
+                msg = msg.viewOnceMessageV2Extension.message;
+            }
+
+            if (msg.documentWithCaptionMessage?.message) {
+                msg = msg.documentWithCaptionMessage.message;
+            }
+
+            return String(
+                msg.conversation ||
+                msg.extendedTextMessage?.text ||
+                msg.imageMessage?.caption ||
+                msg.videoMessage?.caption ||
+                msg.documentMessage?.caption ||
+                msg.documentWithCaptionMessage?.message?.documentMessage?.caption ||
+                ''
+            );
+        }
+
+        for (const [storeKey, message] of messageStore.entries()) {
+            const key = message?.key || {};
+
+            const remoteJid =
+                String(key.remoteJid || '')
+                    .trim()
+                    .toLowerCase();
+
+            const participantJid =
+                String(
+                    key.participant ||
+                    key.senderPn ||
+                    key.participantPn ||
+                    ''
+                )
+                    .trim()
+                    .toLowerCase();
+
+            const senderNumber =
+                participantJid
+                    .split('@')[0]
+                    .split(':')[0]
+                    .replace(/\D/g, '');
+
+            const messageId = String(key.id || '');
+
+            if (
+                searchMessageId &&
+                messageId !== searchMessageId
+            ) {
+                continue;
+            }
+
+            const messageText = getMessageText(message);
+            const lowerText = messageText.toLowerCase();
+            const type = getMessageType(message);
+
+            if (
+    searchText &&
+    !lowerText.startsWith(searchText)
+) {
+    continue;
+}
+
+            if (
+                searchNumber &&
+                !senderNumber.includes(searchNumber)
+            ) {
+                continue;
+            }
+
+            if (
+                searchJid &&
+                remoteJid !== searchJid
+            ) {
+                continue;
+            }
+
+            results.push({
+                storeKey,
+                messageId,
+                remoteJid,
+                participantJid,
+                senderNumber,
+                fromMe: !!key.fromMe,
+                timestamp:
+                    message?.messageTimestamp ??
+                    message?.timestamp ??
+                    '-',
+                type,
+                text:
+                    messageText ||
+                    '[non-text / tanpa caption]',
+                raw: message
+            });
+        }
+
+        let output = '';
+
+        if (!results.length) {
+            output += '\x1b[31mTidak ada pesan yang cocok.\x1b[0m\n\n';
+            output += `Text   : ${searchText || '(semua)'}\n`;
+            output += `Nomor  : ${searchNumber || '(semua)'}\n`;
+            output += `JID    : ${searchJid || '(semua)'}\n`;
+            output += `ID     : ${searchMessageId || '(semua)'}\n`;
+            output += `Cache  : ${messageStore.size}/${MAX_MESSAGES}`;
+
+            out(m, output);
+            return;
+        }
+
+        output += '\n';
+        output += '\x1b[36m==================== SMESSAGE SEARCH ====================\x1b[0m\n\n';
+        output += `Query  : ${searchText || '(semua)'}\n`;
+        output += `Nomor  : ${searchNumber || '(semua)'}\n`;
+        output += `JID    : ${searchJid || '(semua)'}\n`;
+        output += `Hasil  : ${results.length}\n\n`;
+
+        results.forEach((item, index) => {
+            output += `\x1b[33m[${index + 1}]\x1b[0m\n`;
+            output += `  Sender     : ${item.senderNumber || item.participantJid || '-'}\n`;
+            output += `  Sender JID : ${item.participantJid || '-'}\n`;
+            output += `  Target JID : ${item.remoteJid || '-'}\n`;
+            output += `  Message ID : ${item.messageId || '-'}\n`;
+            output += `  Type       : ${item.type}\n`;
+            output += `  From Me    : ${item.fromMe}\n`;
+            output += `  Timestamp  : ${item.timestamp}\n`;
+            output += `  Text       : ${item.text}\n`;
+            output += `  Store Key  : ${item.storeKey}\n\n`;
+        });
+
+        output += '\x1b[36m==========================================================\x1b[0m';
+
+        out(m, output);
+    }
+};

package/plugins/status.js

@@ -0,0 +1,18 @@
+function out(m, text) {
+    if (m?.reply) {
+        void m.reply({ text });
+    } else {
+        console.log(text);
+    }
+}
+
+export default {
+    command: 'status',
+
+    async run({ m, connectionState, sessionType, sessionPath, reconnectAttempts, messageCount, currentWaVersion, lastDisconnect, debug }) {
+        const memory = process.memoryUsage();
+        const text = `========== STATUS ==========\nNode        : ${process.version}\nPlatform    : ${process.platform}\nArchitecture: ${process.arch}\nPID         : ${process.pid}\nConnection  : ${connectionState}\nSession     : ${sessionType}\nSession path: ${sessionPath ?? '-'}\nReconnect   : ${reconnectAttempts}\nMessages    : ${messageCount}\nWA version  : ${currentWaVersion ? currentWaVersion.join('.') : '-'}\nRSS         : ${Math.round(memory.rss / 1024 / 1024)} MB\n=============================`;
+        debug('Last disconnect', lastDisconnect);
+        out(m, text);
+    }
+};

package/plugins/typing_troll.js

@@ -0,0 +1,91 @@
+let trollTypingLoops = {};
+
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export default {
+    command: ['type-troll', 'typet'],
+
+    async run({ m, args, sock }) {
+        if (!m.isGroup) {
+            await m.reply({
+                text: 'Fitur ini hanya untuk grup.'
+            });
+            return;
+        }
+
+        const act =
+            (args[0] || '').toLowerCase();
+
+        if (!['on', 'off'].includes(act)) {
+            await m.reply({
+                text:
+                    'Gunakan format:\n' +
+                    '.typet on\n' +
+                    '.typet off'
+            });
+            return;
+        }
+
+        if (act === 'on') {
+            if (trollTypingLoops[m.chat]) {
+                await m.reply({
+                    text:
+                        '❗Typing Troll sudah aktif.'
+                });
+                return;
+            }
+
+            trollTypingLoops[m.chat] =
+                setInterval(async () => {
+                    try {
+                        await sock.sendPresenceUpdate(
+                            'composing',
+                            m.chat
+                        );
+
+                        await delay(300);
+
+                        await sock.sendPresenceUpdate(
+                            'paused',
+                            m.chat
+                        );
+                    } catch (error) {
+                        console.error(
+                            'TrollTyping Error:',
+                            error
+                        );
+                    }
+                }, 200);
+
+            await m.reply({
+                text:
+                    '✅ Auto Typing Troll diaktifkan.'
+            });
+
+            return;
+        }
+
+        if (act === 'off') {
+            if (!trollTypingLoops[m.chat]) {
+                await m.reply({
+                    text:
+                        '❗ Typing Troll belum aktif.'
+                });
+                return;
+            }
+
+            clearInterval(
+                trollTypingLoops[m.chat]
+            );
+
+            delete trollTypingLoops[m.chat];
+
+            await m.reply({
+                text:
+                    '❌ Typing Troll dimatikan.'
+            });
+        }
+    }
+};