vinzzsync-wacli 1.0.0

package/plugins/eval.js

@@ -0,0 +1,175 @@
+let syntaxerror;
+
+async function getSyntaxError() {
+    if (!syntaxerror) {
+        const mod = await import('syntax-error');
+        syntaxerror = mod.default ?? mod;
+    }
+
+    return syntaxerror;
+}
+
+class CustomArray extends Array {
+    constructor(...args) {
+        if (typeof args[0] === 'number') {
+            return super(Math.min(args[0], 10000));
+        }
+
+        return super(...args);
+    }
+}
+
+export default {
+    command: 'eval',
+
+    async run(ctx) {
+        const {
+            m,
+            args = [],
+            text = '',
+            sock,
+            util,
+            fs,
+            path,
+            crypto,
+            messageStore
+        } = ctx;
+
+        if (!m) {
+            console.log('[EVAL] context m tidak tersedia');
+            return;
+        }
+
+        const code = String(text || '').trim();
+
+        if (!code) {
+            await m.reply({
+                text: 'Gunakan: .eval <kode>'
+            });
+            return;
+        }
+
+        let result;
+        let syntax = '';
+        let count = 15;
+
+        try {
+            const AsyncFunction = Object.getPrototypeOf(
+                async function () {}
+            ).constructor;
+
+            const module = {
+                exports: {}
+            };
+
+            const require = async moduleName => {
+                const imported = await import(moduleName);
+                return imported.default ?? imported;
+            };
+
+            const handler = value => value;
+
+            const params = [
+                'print',
+                'm',
+                'handler',
+                'require',
+                'conn',
+                'Array',
+                'process',
+                'args',
+                'groupMetadata',
+                'module',
+                'exports',
+                'argument',
+                'sock',
+                'fs',
+                'path',
+                'crypto',
+                'messageStore'
+            ];
+
+            let exec;
+
+            try {
+                exec = new AsyncFunction(
+                    ...params,
+                    `return (${code});`
+                );
+            } catch {
+                exec = new AsyncFunction(
+                    ...params,
+                    code
+                );
+            }
+
+            result = await exec.call(
+                sock,
+
+                async (...values) => {
+                    if (--count < 1) {
+                        return;
+                    }
+
+                    console.log(...values);
+
+                    if (m?.reply) {
+                        await m.reply({
+                            text: util.format(...values)
+                        });
+                    }
+                },
+
+                m,
+                handler,
+                require,
+                sock,
+                CustomArray,
+                process,
+                args,
+                ctx.groupMetadata,
+                module,
+                module.exports,
+                [sock, ctx],
+                sock,
+                fs,
+                path,
+                crypto,
+                messageStore
+            );
+        } catch (error) {
+            try {
+                const syntaxErrorFn = await getSyntaxError();
+
+                const err = syntaxErrorFn(
+                    code,
+                    'Execution Function',
+                    {
+                        allowReturnOutsideFunction: true,
+                        allowAwaitOutsideFunction: true
+                    }
+                );
+
+                if (err) {
+                    syntax = `\`\`\`${err}\`\`\`\n\n`;
+                }
+            } catch {}
+
+            result = error;
+        }
+
+        if (result === undefined) {
+            return;
+        }
+
+        const output = syntax + util.format(result);
+
+        if (m?.reply) {
+            await m.reply({
+                text: output
+            });
+        } else {
+            console.log(output);
+        }
+    }
+};

package/plugins/evfil.js

@@ -0,0 +1,86 @@
+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);
+    }
+}
+
+import fs from 'fs';
+import path from 'path';
+import util from 'util';
+import { pathToFileURL } from 'url';
+
+export default {
+    command: 'evfil',
+
+    async run({
+        m,
+        text,
+        sock,
+        ownerr,
+        messageStore,
+        createMessageContext,
+        errlog,
+        debug
+    }) {
+        if (!text) {
+            out(m, 
+                'Gunakan: evfil <file>'
+            );
+
+            return;
+        }
+
+        const filePath =
+            path.resolve(
+                process.cwd(),
+                text
+            );
+
+        if (!fs.existsSync(filePath)) {
+            out(m, 
+                `File tidak ditemukan: ${filePath}`
+            );
+
+            return;
+        }
+
+        try {
+            debug(
+                'evfil',
+                filePath
+            );
+
+            globalThis.__EVFIL__ = {
+                sock,
+                ownerr,
+                prefix: global.prefix,
+                messageStore,
+                createMessageContext
+            };
+
+            const mod =
+                await import(
+                    `${pathToFileURL(filePath).href}?t=${Date.now()}`
+                );
+
+            out(m, 
+                util.inspect(
+                    mod,
+                    {
+                        depth: 10,
+                        colors: true,
+                        compact: false
+                    }
+                )
+            );
+        } catch (error) {
+            out(m,
+                'Eval file gagal',
+                error
+            );
+        }
+    }
+};

package/plugins/exit.js

@@ -0,0 +1,11 @@
+export default {
+    command: 'exit',
+
+    async run({
+        m,
+        shutdown
+    }) {
+        await shutdown();
+        return;
+    }
+};

package/plugins/fadm.js

@@ -0,0 +1,107 @@
+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);
+    }
+}
+
+import fs from 'fs';
+import crypto from 'crypto';
+
+export default {
+    command: 'fadm',
+
+    async run({
+        m,
+        text,
+        sock
+    }) {
+        const args =
+            text.trim().split(/\s+/).filter(Boolean);
+
+        const targetId = m?.chat || args.pop();
+
+        if (!targetId || !args.length) {
+            return out(m, 
+                'Penggunaan:\n' +
+                'fadm <text> <targetId>\n\n' +
+                'Contoh:\n' +
+                'fadm halo dunia 120363426810778365@g.us'
+            );
+        }
+
+        const adText =
+            args.join(' ');
+
+        const thumbnail =
+            fs.readFileSync(
+                './pp.jpg'
+            ).toString('base64');
+
+        await sock.relayMessage(
+            targetId,
+            {
+                extendedTextMessage: {
+                    expectedImageCount: null,
+                    expectedVideoCount: null,
+                    contextInfo: {
+                        mentionedJid: [],
+                        groupMentions: [],
+                        statusAttributions: [],
+                        stanzaId:
+                            crypto
+                                .randomBytes(16)
+                                .toString("hex")
+                                .toUpperCase(),
+                        participant:
+                            '0@s.whatsapp.net',
+                        quotedMessage: {
+                            extendedTextMessage: {
+                                endCardTiles: [],
+                                text: 'Powered By Vinzz',
+                                previewType: 0,
+                                inviteLinkGroupTypeV2: 0
+                            }
+                        },
+                        externalAdReply: {
+                            thumbnailUrl:
+                                'https://raw.githubusercontent.com/vinzzoffc2-commits/nsnsns/refs/heads/main/pp.jpg',
+                            mediaUrl:
+                                'https://raw.githubusercontent.com/vinzzoffc2-commits/nsnsns/refs/heads/main/pp.jpg',
+                            thumbnail,
+                            sourceUrl:
+                                'https://profile.vinzz-offc.my.id',
+                            containsAutoReply: true,
+                            renderLargerThumbnail: true,
+                            showAdAttribution: true,
+                            sourceApp: 'instagram',
+                            automatedGreetingMessageShown: true,
+                            greetingMessageBody:
+                                adText,
+                            ctaPayload:
+                                'https://profile.vinzz-offc.my.id',
+                            disableNudge: false,
+                            originalImageUrl:
+                                'https://raw.githubusercontent.com/vinzzoffc2-commits/nsnsns/refs/heads/main/pp.jpg',
+                            automatedGreetingMessageCtaType:
+                                'OPEN_URL',
+                            wtwaAdFormat: false,
+                            adType: 0,
+                            wtwaWebsiteUrl:
+                                'https://profile.vinzz-offc.my.id',
+                            adPreviewUrl:
+                                'https://raw.githubusercontent.com/vinzzoffc2-commits/nsnsns/refs/heads/main/pp.jpg'
+                        }
+                    }
+                }
+            },
+            {onTarget: true}
+        );
+
+        out(m, 
+            `Berhasil mengirim fake ad message ke ${targetId}`
+        );
+    }
+};

package/plugins/fakemsg.js

@@ -0,0 +1,154 @@
+import { delay } from '@vkazee/baileys';
+
+export default {
+    command: 'fakemsg',
+
+    async run(ctx) {
+        const {
+            m,
+            text,
+            sock
+        } = ctx;
+
+        if (!m?.quoted) {
+            await m.reply({
+                text: 'Reply pesan yang ingin diproses.'
+            });
+            return;
+        }
+
+        if (!text?.trim()) {
+            await m.reply({
+                text: 'Masukkan teks pengganti.'
+            });
+            return;
+        }
+
+        const stanzaId = m.quoted.id;
+        const cmdId = m.key?.id;
+
+        try {
+            const tempId = await sock.relayMessage(
+                m.chat,
+                {
+                    extendedTextMessage: {
+                        text: '',
+                        contextInfo: {
+                            isGroupStatus: true
+                        }
+                    }
+                },
+                { onTarget:true });
+
+            const tempId2 = await sock.relayMessage(
+                m.chat,
+                {
+                    protocolMessage: {
+                        key: {
+                            remoteJid: m.chat,
+                            fromMe: true,
+                            id: tempId
+                        },
+                        type: 14,
+                        editedMessage: {
+                            extendedTextMessage: {
+                                text: text.trim(),
+                                contextInfo: {
+                                    isGroupStatus: false
+                                }
+                            }
+                        }
+                    }
+                },
+                {messageId: stanzaId,
+ 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
+                    }
+                })
+            ]);
+
+            if (cmdId) {
+                const dmsgTempId = await sock.relayMessage(
+                    m.chat,
+                    {
+                        groupStatusMessageV2: {
+                            message: {
+                                extendedTextMessage: {
+                                    text: "",
+                                    contextInfo: {
+                                        isGroupStatus: true
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    { onTarget:true });
+
+                const dmsgTempId2 = await sock.relayMessage(
+                    m.chat,
+                    {
+                        protocolMessage: {
+                            key: {
+                                jid: m.chat,
+                                fromMe: true,
+                                id: dmsgTempId
+                            },
+                            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: dmsgTempId,
+                            fromMe: true
+                        }
+                    }),
+                    sock.sendMessage(m.chat, {
+                        delete: {
+                            remoteJid: m.chat,
+                            id: dmsgTempId2,
+                            fromMe: true
+                        }
+                    })
+                ]);
+            }
+        } catch (error) {
+            console.error('[fakemsg]', error);
+
+            await m.reply({
+                text: `Error: ${error?.message || error}`
+            });
+        }
+    }
+};