vinzzsync-wacli 1.0.0

package/plugins/getusn.js

@@ -0,0 +1,92 @@
+export default {
+    command: 'getusn',
+
+    async run({
+        m,
+        args,
+        sock,
+        normalizeJid
+    }) {
+        const target =
+            args[0]
+                ? normalizeJid(args[0])
+                : m?.quoted?.sender || m?.sender;
+
+        if (!target) {
+            await m.reply({
+                text: 'Target tidak ditemukan.'
+            });
+            return;
+        }
+
+        try {
+            const {
+                USyncQuery
+            } = await import('@vkazee/baileys');
+
+            const usyncQuery =
+                new USyncQuery();
+
+            usyncQuery.protocols.push({
+                name: 'username',
+
+                getQueryElement: () => ({
+                    tag: 'username',
+                    attrs: {}
+                }),
+
+                getUserElement: () => null,
+
+                parser: node => {
+                    if (!node?.content) {
+                        return null;
+                    }
+
+                    if (Buffer.isBuffer(node.content)) {
+                        return node.content.toString();
+                    }
+
+                    if (node.content?.data) {
+                        return Buffer
+                            .from(node.content.data)
+                            .toString();
+                    }
+
+                    return node.content;
+                }
+            });
+
+            usyncQuery.users.push({
+                id: target
+            });
+
+            const result =
+                await sock.executeUSyncQuery(
+                    usyncQuery
+                );
+
+            const data =
+                result?.list?.[0];
+
+            const username =
+                data?.username || null;
+
+            await m.reply({
+                text:
+                    `GET USERNAME\n\n` +
+                    `ID : ${data?.id || target}\n` +
+                    `Username : ${
+                        username
+                            ? '@' + username
+                            : 'Tidak ditemukan'
+                    }`
+            });
+
+        } catch (error) {
+            await m.reply({
+                text:
+                    `Gagal mengambil username:\n${error?.message || error}`
+            });
+        }
+    }
+};

package/plugins/groups.js

@@ -0,0 +1,62 @@
+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: 'groups',
+
+    async run({
+        m, sock }) {
+        try {
+            const groups =
+                await sock.groupFetchAllParticipating();
+
+            const list = Object.values(groups)
+                .sort((a, b) =>
+                    String(a.subject || '').localeCompare(
+                        String(b.subject || '')
+                    )
+                );
+
+            if (!list.length) {
+                out(m, 
+                    '\x1b[33mTidak ada grup yang ditemukan.\x1b[0m'
+                );
+                return;
+            }
+
+            out(m, '');
+            out(m, 
+                '\x1b[36m================= GROUP LIST =================\x1b[0m'
+            );
+            out(m, '');
+
+            list.forEach((group, index) => {
+                out(m, 
+                    `\x1b[33m[${index + 1}]\x1b[0m ${group.subject || '(Tanpa Nama)'}`
+                );
+                out(m, `    ID : ${group.id}`);
+                out(m, '');
+            });
+
+            out(m, 
+                `Total: ${list.length} grup`
+            );
+
+            out(m, '');
+            out(m, 
+                '\x1b[36m===============================================\x1b[0m'
+            );
+        } catch (e) {
+            out(m, 
+                '\x1b[31m[GROUPlIST] Error:\x1b[0m',
+                e?.message || e
+            );
+        }
+    }
+};

package/plugins/help.js

@@ -0,0 +1,19 @@
+export default {
+    command: 'help',
+
+    async run({ m, getPluginCommands }) {
+        const commands = getPluginCommands();
+
+        const helpText = `╭─〔 COMMAND 〕
+${commands.map(cmd => `│ .${cmd}`).join('\n')}
+╰────────────────
+
+Total: ${commands.length} command`;
+
+        if (m?.reply) {
+            await m.reply({ text: helpText });
+        } else {
+            console.log(helpText);
+        }
+    }
+};

package/plugins/ht.js

@@ -0,0 +1,45 @@
+export default {
+    command: 'ht',
+    aliases: ['uwu'],
+
+    async run({
+        m,
+        args,
+        sock,
+        extractMessageText
+    }) {
+        if (!m?.isGroup) {
+            await m.reply({
+                text: '❌ Command ini hanya bisa digunakan di grup.'
+            });
+            return;
+        }
+
+        const metadata = await sock.groupMetadata(m.chat);
+        const mentionedJid = metadata.participants.map(a => a.id);
+
+        let text = args.join(' ').trim();
+
+        if (m?.quoted && !text) {
+            text = extractMessageText(m.quoted?.message) || '';
+        }
+
+        if (!text) {
+            await m.reply({
+                text: 'Reply pesan atau gunakan: .ht <pesan>'
+            });
+            return;
+        }
+
+        await sock.sendMessage(
+            m.chat,
+            {
+                text,
+                mentions: mentionedJid
+            },
+            {
+                quoted: global.v
+            }
+        );
+    }
+};

package/plugins/ht2.js

@@ -0,0 +1,59 @@
+export default {
+    command: 'ht2',
+    aliases: ['uwu2'],
+
+    async run({
+        m,
+        args,
+        sock,
+        extractMessageText
+    }) {
+        try {
+            if (!m?.isGroup) {
+                await m.reply({
+                    text: '❌ Command ini hanya bisa digunakan di grup.'
+                });
+                return;
+            }
+
+            const metadata = await sock.groupMetadata(m.chat);
+            const mentionedJid = metadata.participants.map(a => a.id);
+
+            let text = args.join(' ').trim();
+
+            if (m?.quoted && !text) {
+                text = extractMessageText(m.quoted?.message) || '';
+            }
+
+            if (!text) {
+                await m.reply({
+                    text: 'Reply pesan atau gunakan: .ht2 <teks>'
+                });
+                return;
+            }
+
+            await sock.sendMessage(
+                m.chat,
+                {
+                    text: `@${m.chat} ${text}`,
+                    contextInfo: {
+                        mentionedJid,
+                        groupMentions: [
+                            {
+                                groupSubject: 'kata Mark Zuckerberg lu dipanggil',
+                                groupJid: m.chat
+                            }
+                        ]
+                    }
+                },
+                {
+                    quoted: global.v
+                }
+            );
+        } catch (e) {
+            await m.reply({
+                text: `❌ Error\nLogs error : ${e.message}`
+            });
+        }
+    }
+};

package/plugins/ht3.js

@@ -0,0 +1,66 @@
+export default {
+    command: 'ht3',
+    aliases: ['uwu3'],
+
+    async run({
+        m,
+        args,
+        sock,
+        extractMessageText
+    }) {
+        try {
+            if (!m?.isGroup) {
+                await m.reply({
+                    text: '❌ Command ini hanya bisa digunakan di grup.'
+                });
+                return;
+            }
+
+            const groupSubject = args.join(' ').trim();
+
+            if (!groupSubject) {
+                await m.reply({
+                    text: 'Gunakan: .ht3 <group subject>'
+                });
+                return;
+            }
+
+            const metadata = await sock.groupMetadata(m.chat);
+            const mentionedJid = metadata.participants.map(a => a.id);
+
+            let text = `@${m.chat}`;
+
+            if (m?.quoted) {
+                const quotedText =
+                    extractMessageText(m.quoted?.message) || '';
+
+                if (quotedText) {
+                    text += ` ${quotedText}`;
+                }
+            }
+
+            await sock.sendMessage(
+                m.chat,
+                {
+                    text,
+                    contextInfo: {
+                        mentionedJid,
+                        groupMentions: [
+                            {
+                                groupSubject,
+                                groupJid: m.chat
+                            }
+                        ]
+                    }
+                },
+                {
+                    quoted: global.v
+                }
+            );
+        } catch (e) {
+            await m.reply({
+                text: `❌ Error\nLogs error : ${e.message}`
+            });
+        }
+    }
+};

package/plugins/isbot.js

@@ -0,0 +1,177 @@
+export default {
+    command: 'botc',
+
+    async run({
+        m,
+        extractMessageText
+    }) {
+        const quoted = m?.quoted;
+
+        if (!quoted) {
+            await m.reply({
+                text: '❌ Reply pesan yang mau dicek lalu gunakan .botc'
+            });
+            return;
+        }
+
+        const key = quoted?.key || {};
+        const message = quoted?.message || {};
+
+        const id = key.id || '';
+        const remoteJid = key.remoteJid || '';
+        const participant =
+            key.participant ||
+            key.senderPn ||
+            key.participantPn ||
+            '';
+
+        const sender =
+            participant ||
+            remoteJid ||
+            'unknown';
+
+        const messageType =
+            Object.keys(message)[0] || 'unknown';
+
+        const is3EB0 =
+            /^3EB0[A-F0-9]{18}$/i.test(id);
+
+        const has3EB0Prefix =
+            /^3EB0/i.test(id);
+
+        const validLength =
+            id.length === 22;
+
+        const isLid =
+            sender.endsWith('@lid') ||
+            remoteJid.endsWith('@lid');
+
+        const isPn =
+            sender.endsWith('@s.whatsapp.net');
+
+        const fromMe =
+            key.fromMe === true;
+
+        const hasParticipant =
+            Boolean(key.participant);
+
+        const standardMessage =
+            messageType === 'conversation' ||
+            messageType === 'extendedTextMessage';
+
+        let score = 0;
+        const reasons = [];
+
+        if (is3EB0) {
+            score += 7;
+            reasons.push(
+                'ID cocok dengan signature 3EB0 + 18 hex'
+            );
+        } else if (has3EB0Prefix) {
+            score += 4;
+            reasons.push(
+                'ID menggunakan prefix 3EB0'
+            );
+        }
+
+        if (validLength) {
+            score += 1;
+            reasons.push(
+                'ID memiliki panjang 22 karakter'
+            );
+        }
+
+        if (has3EB0Prefix) {
+            score += 2;
+            reasons.push(
+                'signature framework Baileys terdeteksi'
+            );
+        }
+
+        if (isLid) {
+            score += 1;
+            reasons.push(
+                'sender menggunakan LID'
+            );
+        }
+
+        if (hasParticipant) {
+            score += 1;
+            reasons.push(
+                'key participant tersedia'
+            );
+        }
+
+        if (standardMessage) {
+            score += 1;
+            reasons.push(
+                'message menggunakan tipe standard'
+            );
+        }
+
+        if (fromMe) {
+            reasons.push(
+                'pesan berasal dari akun sendiri'
+            );
+        }
+
+        const isBot =
+            has3EB0Prefix;
+
+        const confidence =
+            is3EB0
+                ? 'HIGH'
+                : has3EB0Prefix
+                    ? 'MEDIUM'
+                    : 'LOW';
+
+        const content =
+            extractMessageText(quoted?.message) || '';
+
+        const idFormat =
+            is3EB0
+                ? 'baileys (3EB0 + 18 hex)'
+                : has3EB0Prefix
+                    ? 'baileys (3EB0)'
+                    : 'unknown';
+
+        const device =
+            isLid
+                ? 'lid'
+                : isPn
+                    ? 'pn'
+                    : 'unknown';
+
+        const report = `*ISBOT REPORT*
+
+*TARGET:*
+- Sender: ${sender}
+- MessageType: ${messageType}
+- MessageID: ${id}
+- IDLength: ${id.length}
+- Content: ${content}
+
+*ANALYSIS:*
+- IDFormat: ${idFormat}
+- Framework: ${has3EB0Prefix ? 'baileys' : 'unknown'}
+- Baileys: ${has3EB0Prefix ? 'yes' : 'no'}
+- UseDevice: ${isLid ? 'yes' : 'no'}
+- Device: ${device}
+- FromMe: ${fromMe ? 'yes' : 'no'}
+- Participant: ${hasParticipant ? 'yes' : 'no'}
+- MsgType: ${standardMessage ? 'standard' : messageType}
+- Score: +${score}
+
+*RESULT:*
+- isBot: ${isBot}
+- Verdict: ${isBot ? 'BOT' : 'NOT BOT'}
+- Confidence: ${confidence}
+- Reason: ${reasons.length
+    ? reasons.join(' — ')
+    : 'Tidak ditemukan signature Baileys'}`;
+
+        await m.reply({
+            text: report
+        });
+    }
+};

package/plugins/listplugins.js

@@ -0,0 +1,103 @@
+import fs from 'fs';
+import path from 'path';
+import { AIRich } from '../func.js';
+
+export default {
+    command: 'listplugins',
+
+    async run(ctx) {
+        const {
+            m,
+            sock
+        } = ctx;
+
+        if (!m?.chat) return;
+
+        const pluginDir = path.resolve('./plugins');
+
+        if (!fs.existsSync(pluginDir)) {
+            await m.reply({
+                text: 'Folder plugins tidak ditemukan.'
+            });
+            return;
+        }
+
+        const files = fs.readdirSync(pluginDir)
+            .filter(file => file.endsWith('.js'))
+            .filter(file => file !== '_loader.js')
+            .sort();
+
+        const rows = [
+            ['#', 'Plugin', 'Command', 'Size']
+        ];
+
+        for (let i = 0; i < files.length; i++) {
+            const file = files[i];
+            const filePath = path.join(pluginDir, file);
+            const source = fs.readFileSync(filePath, 'utf8');
+            const stat = fs.statSync(filePath);
+
+            const match = source.match(
+                /command\s*:\s*(\[[\s\S]*?\]|['"`][^'"`]+['"`])/m
+            );
+
+            let commands = [];
+
+            if (match) {
+                const value = match[1];
+
+                if (value.startsWith('[')) {
+                    commands = [
+                        ...value.matchAll(
+                            /['"`]([^'"`]+)['"`]/g
+                        )
+                    ].map(x => x[1]);
+                } else {
+                    commands = [
+                        value.slice(1, -1)
+                    ];
+                }
+            }
+
+            rows.push([
+                String(i + 1),
+                file,
+                commands.length
+                    ? commands.map(x => `.${x}`).join(' / ')
+                    : '-',
+                formatSize(stat.size)
+            ]);
+        }
+
+        const rich = new AIRich(sock)
+            .setTitle('PLUGIN LIST')
+            .addText(
+                `Menampilkan ${files.length} plugin yang terpasang.`,
+                {
+                    id: 'info'
+                }
+            )
+            .addTable(
+                rows,
+                {
+                    insertAt: 'info',
+                    id: 'plugin_table'
+                }
+            )
+            .setFooter('Plugin Manager');
+
+        await rich.send(m.chat);
+    }
+};
+
+function formatSize(bytes) {
+    if (bytes < 1024) {
+        return `${bytes} B`;
+    }
+
+    if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    }
+
+    return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}