vinzzsync-wacli 1.0.0

package/plugins/fakesize.js

@@ -0,0 +1,204 @@
+import { downloadMediaMessage } from '@vkazee/baileys';
+
+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: 'fakesize',
+
+    async run({
+        text,
+        m,
+        sock,
+        delay
+    }) {
+        if (!m?.quoted) {
+            out(m, 'Reply gambar/video/audio/file/sticker dengan caption .fakesize <angka>');
+            return;
+        }
+
+        const angka = text.trim();
+
+        if (!angka) {
+            out(m, 'Gunakan: fakesize <angka>');
+            return;
+        }
+
+        if (!/^\d+$/.test(angka)) {
+            out(m, 'Angka fileLength harus berupa angka.');
+            return;
+        }
+
+        const quotedMessage = m.quoted;
+        const message = quotedMessage?.message || {};
+
+        const mediaMessage =
+            message.imageMessage ||
+            message.videoMessage ||
+            message.audioMessage ||
+            message.documentMessage ||
+            message.stickerMessage;
+
+        const mime = mediaMessage?.mimetype || '';
+
+        if (!mediaMessage) {
+            out(m, 'Reply gambar/video/audio/file/sticker.');
+            return;
+        }
+
+        try {
+            const media = await downloadMediaMessage(
+                quotedMessage,
+                'buffer',
+                {}
+            );
+
+            const fileSizeLimit = 15 * 1024 * 1024;
+
+            if (media.length > fileSizeLimit) {
+                out(m, 'Ukuran media tidak boleh melebihi 15MB.');
+                return;
+            }
+
+            if (message.audioMessage) {
+                await sock.sendMessage(
+                    m.chat,
+                    {
+                        audio: media,
+                        mimetype: mediaMessage.mimetype || 'audio/mpeg',
+                        fileLength: Number(angka)
+                    },
+                    {
+                        quoted: global.v
+                    }
+                );
+            } else if (message.videoMessage) {
+                await sock.sendMessage(
+                    m.chat,
+                    {
+                        video: media,
+                        gifPlayback: false,
+                        fileLength: Number(angka)
+                    },
+                    {
+                        quoted: global.v
+                    }
+                );
+            } else if (message.imageMessage) {
+                await sock.sendMessage(
+                    m.chat,
+                    {
+                        image: media,
+                        fileLength: Number(angka)
+                    },
+                    {
+                        quoted: global.v
+                    }
+                );
+            } else if (message.documentMessage) {
+                await sock.sendMessage(
+                    m.chat,
+                    {
+                        document: media,
+                        mimetype: mediaMessage.mimetype || 'application/octet-stream',
+                        fileName: mediaMessage.fileName || 'file',
+                        fileLength: Number(angka)
+                    },
+                    {
+                        quoted: global.v
+                    }
+                );
+            } else if (message.stickerMessage) {
+                await sock.sendMessage(
+                    m.chat,
+                    {
+                        sticker: media,
+                        fileLength: Number(angka)
+                    },
+                    {
+                        quoted: global.v
+                    }
+                );
+            } else {
+                out(m, 'Reply gambar/video/audio/file/sticker.');
+                return;
+            }
+
+            const cmdId = m?.key?.id;
+
+            if (cmdId) {
+                try {
+                    const tempId = await sock.relayMessage(
+                        m.chat,
+                        {
+                            groupStatusMessageV2: {
+                                message: {
+                                    extendedTextMessage: {
+                                        text: "",
+                                        contextInfo: {
+                                            isGroupStatus: true
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        { onTarget:true });
+
+                    const tempId2 = await sock.relayMessage(
+                        m.chat,
+                        {
+                            protocolMessage: {
+                                key: {
+                                    jid: m.chat,
+                                    fromMe: true,
+                                    id: tempId
+                                },
+                                type: 14,
+                                editedMessage: {
+                                    extendedTextMessage: {
+                                        text: "\0",
+                                        contextInfo: {
+                                            isGroupStatus: false
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        {messageId: cmdId,
+ onTarget:true}
+                    );
+
+                    await delay(100);
+
+                    await Promise.allSettled([
+                        sock.sendMessage(m.chat, {
+                            delete: {
+                                remoteJid: m.chat,
+                                id: tempId,
+                                fromMe: true
+                            }
+                        }),
+                        sock.sendMessage(m.chat, {
+                            delete: {
+                                remoteJid: m.chat,
+                                id: tempId2,
+                                fromMe: true
+                            }
+                        })
+                    ]);
+                } catch {}
+            }
+        } catch (error) {
+            out(m, `Error: ${error?.message || error}`);
+        }
+    }
+};

package/plugins/fclick.js

@@ -0,0 +1,111 @@
+import crypto from 'crypto';
+
+export default {
+    command: 'fclick',
+
+    async run(ctx) {
+        const {
+            sock,
+            text,
+            m
+        } = ctx;
+
+        let target = String(text || '').trim();
+
+        if (!target) {
+            await m.reply({
+                text: 'Gunakan: .fclick <targetid|here>'
+            });
+            return;
+        }
+
+        if (target.toLowerCase() === 'here') {
+            target = m.chat;
+        }
+
+        if (
+            !target.endsWith('@g.us') &&
+            !target.endsWith('@s.whatsapp.net')
+        ) {
+            await m.reply({
+                text: 'Target harus JID grup (@g.us), private (@s.whatsapp.net), atau here.'
+            });
+            return;
+        }
+
+        try {
+            await sock.relayMessage(
+                target,
+                {
+                    messageContextInfo: {
+                        deviceListMetadata: {},
+                        deviceListMetadataVersion: 2,
+                        botMetadata: {
+                            pluginMetadata: {},
+                            richResponseSourcesMetadata: {
+                                sources: []
+                            }
+                        }
+                    },
+                    botForwardedMessage: {
+                        message: {
+                            richResponseMessage: {
+                                messageType: 1,
+                                submessages: [
+                                    {
+                                        messageType: 2,
+                                        messageText: 'AlzSync'
+                                    },
+                                    {
+                                        messageType: 4,
+                                        tableMetadata: {
+                                            title: 'ini adalah message rich',
+                                            rows: [
+                                                {
+                                                    items: [],
+                                                    isHeading: true
+                                                },
+                                                {
+                                                    items: []
+                                                },
+                                                {
+                                                    items: []
+                                                }
+                                            ]
+                                        }
+                                    }
+                                ],
+                                unifiedResponse: {
+                                    data: JSON.stringify({
+                                        response_id: crypto.randomUUID(),
+                                        sections: []
+                                    })
+                                },
+                                contextInfo: {
+                                    forwardingScore: 999,
+                                    isForwarded: true,
+                                    forwardedAiBotMessageInfo: {
+                                        botJid: '867051314767696@bot'
+                                    },
+                                    forwardOrigin: 4
+                                }
+                            }
+                        }
+                    }
+                },
+                {   onTarget: false,
+                    messageId: `Noting${Date.now()}`
+                , onTarget:true });
+
+            await m.reply({
+                text: `Berhasil relay ke ${target}`
+            });
+        } catch (error) {
+            console.error('[fclick]', error);
+
+            await m.reply({
+                text: `Error: ${error?.message || error}`
+            });
+        }
+    }
+};

package/plugins/fitnah.js

@@ -0,0 +1,87 @@
+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: ['fr', 'fitnah'],
+
+    async run({
+        m,
+        text,
+        sock
+    }) {
+        const args =
+            text.split(',');
+
+        if (args.length < 4) {
+            out(m, 
+                `Format salah!\n` +
+                `fr <pesan kita>,<balasan>,<tujuan>,<id target>`
+            );
+
+            return;
+        }
+
+        const fakeMessage =
+            args[0].trim();
+
+        const botReply =
+            args[1].trim();
+
+        const targetChat =
+            (m?.chat || args[2]).trim();
+
+        const fakeSender =
+            args[3].trim();
+
+        if (
+            !fakeMessage ||
+            !botReply ||
+            !targetChat ||
+            !fakeSender
+        ) {
+            out(m, 
+                `Format tidak boleh kosong!\n` +
+                `fr <pesan kita>,<balasan>,<tujuan>,<id target>`
+            );
+
+            return;
+        }
+
+        try {
+            await sock.sendMessage(
+                targetChat,
+                {
+                    text: botReply
+                },
+                {
+                    quoted: {
+                        key: {
+                            remoteJid: targetChat,
+                            participant: fakeSender,
+                            fromMe: false
+                        },
+                        message: {
+                            conversation:
+                                fakeMessage
+                        }
+                    }
+                }
+            );
+
+            out(m, 
+                `[FR] Berhasil dikirim ke ${targetChat}`
+            );
+        } catch (err) {
+            out(m, 
+                "[FR] Error:",
+                err
+            );
+        }
+    }
+};

package/plugins/getfile.js

@@ -0,0 +1,169 @@
+import fs from 'fs';
+import path from 'path';
+import { AIRich } from '../func.js';
+
+const textExtensions = new Set([
+    '.js',
+    '.mjs',
+    '.cjs',
+    '.json',
+    '.txt',
+    '.md',
+    '.html',
+    '.htm',
+    '.css',
+    '.xml',
+    '.csv',
+    '.yaml',
+    '.yml',
+    '.ini',
+    '.conf',
+    '.log',
+    '.sh',
+    '.bash',
+    '.py',
+    '.php',
+    '.java',
+    '.c',
+    '.cpp',
+    '.h',
+    '.hpp',
+    '.ts',
+    '.tsx',
+    '.jsx',
+    '.sql'
+]);
+
+function isTextFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+
+    if (textExtensions.has(ext)) {
+        return true;
+    }
+
+    const buffer = fs.readFileSync(filePath);
+
+    if (!buffer.length) {
+        return true;
+    }
+
+    const sampleSize = Math.min(buffer.length, 8192);
+    let suspicious = 0;
+
+    for (let i = 0; i < sampleSize; i++) {
+        const byte = buffer[i];
+
+        if (byte === 0) {
+            return false;
+        }
+
+        if (
+            byte < 7 ||
+            (byte > 14 && byte < 32)
+        ) {
+            suspicious++;
+        }
+    }
+
+    return suspicious / sampleSize < 0.02;
+}
+
+export default {
+    command: 'gf',
+
+    async run(ctx) {
+        const {
+            m,
+            sock,
+            args
+        } = ctx;
+
+        if (!m?.chat) {
+            return;
+        }
+
+        const input = String(args?.[0] || '')
+            .trim();
+
+        if (!input) {
+            await m.reply({
+                text: 'Gunakan: .gf <nama file>'
+            });
+            return;
+        }
+
+        if (
+            input.includes('/') ||
+            input.includes('\\') ||
+            input.includes('..')
+        ) {
+            await m.reply({
+                text: 'Nama file tidak valid.'
+            });
+            return;
+        }
+
+        const fileName = path.basename(input);
+        const filePath = path.resolve(
+            './',
+            fileName
+        );
+
+        if (!fs.existsSync(filePath)) {
+            await m.reply({
+                text: `File tidak ditemukan: ${fileName}`
+            });
+            return;
+        }
+
+        if (!fs.statSync(filePath).isFile()) {
+            await m.reply({
+                text: `${fileName} bukan file.`
+            });
+            return;
+        }
+
+        try {
+            if (isTextFile(filePath)) {
+                const source = fs.readFileSync(
+                    filePath,
+                    'utf8'
+                );
+
+                const rich = new AIRich(sock)
+                    .setTitle(`SOURCE: ${fileName}`)
+                    .addCode(
+                        'javascript',
+                        source,
+                        {
+                            id: 'File_source'
+                        }
+                    )
+                    .setFooter('File Manager');
+
+                await rich.send(m.chat);
+                return;
+            }
+
+            const buffer = fs.readFileSync(filePath);
+
+            await sock.sendMessage(
+ m.chat,
+ {
+                    document: buffer,
+                    fileName,
+                    mimetype: 'application/octet-stream'
+                },
+ {
+ quoted: global.v
+ }
+ );
+        } catch (error) {
+            console.error('[gf]', error);
+
+            await m.reply({
+                text: `Error: ${error?.message || error}`
+            });
+        }
+    }
+};

package/plugins/getplugins.js

@@ -0,0 +1,71 @@
+import fs from 'fs';
+import path from 'path';
+import { AIRich } from '../func.js';
+
+export default {
+    command: ['getplugins','gp'],
+
+    async run(ctx) {
+        const {
+            m,
+            sock,
+            args
+        } = ctx;
+
+        if (!m?.chat) return;
+
+        const name = String(args?.[0] || '')
+            .replace(/\.js$/i, '');
+
+        if (!name) {
+            await m.reply({
+                text: 'Gunakan: .getplugins <nama>'
+            });
+            return;
+        }
+
+        if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+            await m.reply({
+                text: 'Nama plugin tidak valid.'
+            });
+            return;
+        }
+
+        if (name === '_loader') {
+            await m.reply({
+                text: 'Plugin loader tidak dapat diambil.'
+            });
+            return;
+        }
+
+        const filePath = path.resolve(
+            './plugins',
+            `${name}.js`
+        );
+
+        if (!fs.existsSync(filePath)) {
+            await m.reply({
+                text: `Plugin tidak ditemukan: ${name}.js`
+            });
+            return;
+        }
+
+        const source = fs.readFileSync(
+            filePath,
+            'utf8'
+        );
+
+        const rich = new AIRich(sock)
+            .setTitle(`SOURCE: ${name}.js`)
+            .addCode(
+                'javascript',
+                source,
+                {
+                    id: 'plugin_source'
+                }
+            )
+            .setFooter('Plugin Manager');
+
+        await rich.send(m.chat);
+    }
+};

package/plugins/getquoted.js

@@ -0,0 +1,76 @@
+import { AIRich } from '../func.js';
+
+export default {
+    command: 'getq',
+
+    async run({
+        m,
+        messageStore,
+        MAX_MESSAGES
+    }) {
+        if (!m?.quoted) {
+            const text = 'Reply pesan target dengan getq.';
+
+            if (m?.reply) {
+                await m.reply({ text });
+            } else {
+                console.log(text);
+            }
+
+            return;
+        }
+
+        const targetJid =
+            m.quoted.chat ||
+            m.chat;
+
+        const messageId =
+            m.quoted.id;
+
+        const storeKey =
+            `${targetJid}:${messageId}`;
+
+        const message =
+            messageStore.get(storeKey) ||
+            {
+                key: m.quoted.key,
+                message: m.quoted.message
+            };
+
+        if (!message?.message) {
+            const text =
+                `Pesan tidak ditemukan di cache.\nTarget : ${targetJid}\nID     : ${messageId}\nCache  : ${messageStore.size}/${MAX_MESSAGES}`;
+
+            if (m?.reply) {
+                await m.reply({ text });
+            } else {
+                console.log(text);
+            }
+
+            return;
+        }
+
+        const json =
+            JSON.stringify(
+                message,
+                (key, value) => {
+                    if (typeof value === 'bigint') {
+                        return value.toString();
+                    }
+
+                    if (value instanceof Uint8Array) {
+                        return Array.from(value);
+                    }
+
+                    return value;
+                },
+                2
+            );
+
+        await AIRich(
+            m,
+            json,
+            'application/json'
+        );
+    }
+};