vinzzsync-wacli 1.0.0

package/plugins/cms.js

@@ -0,0 +1,474 @@
+import { AIRich, copyNForward } from '../func.js';
+
+function out(m, ...args) {
+    const text = args
+        .map(value =>
+            typeof value === 'string'
+                ? value
+                : String(value)
+        )
+        .join(' ');
+
+    if (m?.reply) {
+        void m.reply({ text });
+    } else {
+        console.log(text);
+    }
+}
+
+function serialize(value, depth = 0, seen = new WeakSet()) {
+    if (value === undefined) return 'undefined';
+    if (value === null) return 'null';
+
+    if (typeof value === 'string') {
+        return JSON.stringify(value);
+    }
+
+    if (typeof value === 'number') {
+        if (Number.isNaN(value)) return 'NaN';
+        if (value === Infinity) return 'Infinity';
+        if (value === -Infinity) return '-Infinity';
+        return String(value);
+    }
+
+    if (typeof value === 'bigint') {
+        return `${value}n`;
+    }
+
+    if (typeof value === 'boolean') {
+        return String(value);
+    }
+
+    if (typeof value === 'function') {
+        return value.toString();
+    }
+
+    if (
+        typeof Buffer !== 'undefined' &&
+        Buffer.isBuffer(value)
+    ) {
+        return `Buffer.from(${JSON.stringify([...value])})`;
+    }
+
+    if (value instanceof Uint8Array) {
+        return `Buffer.from(${JSON.stringify([...value])})`;
+    }
+
+    if (value instanceof ArrayBuffer) {
+        return `Buffer.from(new Uint8Array(${serialize(
+            value,
+            depth + 1,
+            seen
+        )}))`;
+    }
+
+    if (value instanceof Date) {
+        return `new Date(${JSON.stringify(
+            value.toISOString()
+        )})`;
+    }
+
+    if (typeof value !== 'object') {
+        return JSON.stringify(value);
+    }
+
+    if (seen.has(value)) {
+        return 'undefined';
+    }
+
+    seen.add(value);
+
+    if (depth > 100) {
+        seen.delete(value);
+        return '{}';
+    }
+
+    if (Array.isArray(value)) {
+        const items = value.map(item =>
+            serialize(item, depth + 1, seen)
+        );
+
+        seen.delete(value);
+
+        return `[
+${items
+    .map(item =>
+        `${'    '.repeat(depth + 1)}${item}`
+    )
+    .join(',\n')}
+${'    '.repeat(depth)}]`;
+    }
+
+    const entries = Object.entries(value);
+
+    const body = entries
+        .map(([key, item]) => {
+            const property =
+                /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)
+                    ? key
+                    : JSON.stringify(key);
+
+            return `${'    '.repeat(depth + 1)}${property}: ${serialize(
+                item,
+                depth + 1,
+                seen
+            )}`;
+        })
+        .join(',\n');
+
+    seen.delete(value);
+
+    return `{
+${body}
+${'    '.repeat(depth)}}`;
+}
+
+function getSourceKey(message) {
+    return {
+        remoteJid:
+            message?.key?.remoteJid ?? null,
+
+        id:
+            message?.key?.id ?? null,
+
+        participant:
+            message?.key?.participant ?? null,
+
+        senderPn:
+            message?.key?.senderPn ?? null,
+
+        participantPn:
+            message?.key?.participantPn ?? null,
+
+        fromMe:
+            message?.key?.fromMe ?? false
+    };
+}
+
+function getMessageType(message, getMessageTypeFn) {
+    if (typeof getMessageTypeFn === 'function') {
+        const type =
+            getMessageTypeFn(message);
+
+        if (type && type !== 'unknown') {
+            return type;
+        }
+    }
+
+    if (
+        message &&
+        typeof message === 'object'
+    ) {
+        return Object.keys(message)[0] || 'unknown';
+    }
+
+    return 'unknown';
+}
+
+function resolveTargetAndMessage({
+    m,
+    text,
+    messageStore
+}) {
+    const input =
+        String(text || '')
+            .trim()
+            .split(/\s+/)
+            .filter(Boolean);
+
+    let targetJid =
+        m?.chat || null;
+
+    let messageId =
+        m?.quoted?.id || null;
+
+    if (input.length >= 2) {
+        targetJid = input[0];
+        messageId = input[1];
+    } else if (input.length === 1) {
+        messageId = input[0];
+    }
+
+    if (!targetJid || !messageId) {
+        return {
+            targetJid,
+            messageId,
+            stored: null
+        };
+    }
+
+    const storeKey =
+        `${targetJid}:${messageId}`;
+
+    let stored =
+        messageStore?.get(storeKey) || null;
+
+    if (
+        !stored &&
+        m?.quoted?.message &&
+        m.quoted.id === messageId
+    ) {
+        stored = {
+            key: {
+                ...(m.quoted.key || {}),
+                id: messageId,
+                remoteJid:
+                    m.quoted.key?.remoteJid ||
+                    targetJid
+            },
+            message:
+                m.quoted.message
+        };
+    }
+
+    return {
+        targetJid,
+        messageId,
+        stored
+    };
+}
+
+function buildRelayCode(targetJid, message) {
+    const payload =
+        serialize(message);
+
+    return `const payload = ${payload};
+
+await sock.relayMessage(
+    ${JSON.stringify(targetJid)},
+    payload,
+    {onTarget: true,
+        messageId: Date.now() + "VINZZ",
+ onTarget:true}
+);`;
+}
+
+function buildForwardCode(targetJid, messageId) {
+    return `const source = messageStore.get(
+    ${JSON.stringify(`${targetJid}:${messageId}`)}
+);
+
+if (!source?.message) {
+    throw new Error("Source message tidak ditemukan");
+}
+
+await copyNForward(
+    sock,
+    ${JSON.stringify(targetJid)},
+    source,
+    true
+);`;
+}
+
+export default {
+    command: 'cms',
+
+    async run(ctx) {
+        const {
+            m,
+            text,
+            messageStore,
+            getMessageType,
+            sock
+        } = ctx;
+
+        const {
+            targetJid,
+            messageId,
+            stored
+        } = resolveTargetAndMessage({
+            m,
+            text,
+            messageStore
+        });
+
+        if (!targetJid || !messageId) {
+            const usage = `CREATE MESSAGE SEND (CMS)
+
+Cara pakai:
+.cms <reply pesan>
+.cms <messageId>
+.cms <jid> <messageId>`;
+
+            if (m?.reply) {
+                await m.reply({
+                    text: usage
+                });
+            } else {
+                out(m, usage);
+            }
+
+            return;
+        }
+
+        if (!stored?.message) {
+            const result = `CREATE MESSAGE SEND (CMS)
+
+• Status   : Message tidak ditemukan
+• Chat     : ${targetJid}
+• ID       : ${messageId}
+• Source   : messageStore`;
+
+            if (m?.reply) {
+                await m.reply({
+                    text: result
+                });
+            } else {
+                out(m, result);
+            }
+
+            return;
+        }
+
+        const rawMessage =
+            stored.message;
+
+        const messageType =
+            getMessageType(
+                rawMessage,
+                getMessageType
+            );
+
+        const sourceKey =
+            getSourceKey(stored);
+
+        const sender =
+            stored.key?.participant ||
+            stored.key?.senderPn ||
+            stored.key?.participantPn ||
+            stored.key?.remoteJid ||
+            'unknown';
+
+        const generated =
+            buildRelayCode(
+                targetJid,
+                rawMessage
+            );
+
+        const forwardGenerated =
+            buildForwardCode(
+                targetJid,
+                messageId
+            );
+
+        const info = `• Type     : ${messageType}
+• Source   : Raw WebMessageInfo
+• Chat     : ${targetJid}
+• ID       : ${stored.key?.id || messageId}
+• Sender   : ${sender}
+• From Me  : ${sourceKey.fromMe}
+• Payload  : Full message.message
+• Context  : Preserved
+• Quoted   : Preserved
+• Media    : Preserved
+• Forward  : copyNForward`;
+
+        if (m?.reply) {
+            const isLong =
+                generated.length > 1000;
+
+            const rich =
+                new AIRich(sock)
+                    .setTitle(
+                        'CREATE MESSAGE SEND (CMS)'
+                    )
+                    .addText(
+                        info,
+                        {
+                            id: 'cms_info'
+                        }
+                    );
+
+            if (!isLong) {
+                rich.addCode(
+                    'javascript',
+                    generated,
+                    {
+                        insertAt: 'cms_info',
+                        id: 'cms_code'
+                    }
+                );
+            }
+
+            rich.setFooter(
+                isLong
+                    ? 'Code dikirim sebagai file'
+                    : 'Generated by CMS'
+            );
+
+            const sent =
+                await rich.send(
+                    targetJid,
+                    {   onTarget: true,
+                        messageId:
+                            `VINZZCMS-${Date.now()}`
+                    }
+                );
+
+            messageStore.set(
+                `${targetJid}:${sent.key.id}`,
+                sent
+            );
+
+            if (isLong) {
+                const fileMessage =
+                    await sock.sendMessage(
+                        targetJid,
+                        {
+                            document:
+                                Buffer.from(
+                                    generated,
+                                    'utf8'
+                                ),
+                            mimetype:
+                                'text/javascript',
+                            fileName:
+                                `cms-${Date.now()}.js`
+                        },
+                        {
+                            quoted: global.v
+                        }
+                    );
+
+                if (fileMessage?.key?.id) {
+                    messageStore.set(
+                        `${targetJid}:${fileMessage.key.id}`,
+                        fileMessage
+                    );
+                }
+            }
+
+            return;
+        }
+
+        out(
+            m,
+            '\nCREATE MESSAGE SEND (CMS)\n'
+        );
+
+        out(
+            m,
+            info
+        );
+
+        out(
+            m,
+            '\nRELAY PAYLOAD\n'
+        );
+
+        out(
+            m,
+            generated
+        );
+
+        out(
+            m,
+            '\nFORWARD AS ORIGINAL\n'
+        );
+
+        out(
+            m,
+            forwardGenerated
+        );
+    }
+};

package/plugins/delplugins.js

@@ -0,0 +1,57 @@
+import fs from 'fs';
+import path from 'path';
+
+export default {
+    command: 'delplugins',
+
+    async run(ctx) {
+        const {
+            m,
+            args
+        } = ctx;
+
+        if (!m?.chat) return;
+
+        const name = String(args?.[0] || '')
+            .replace(/\.js$/i, '');
+
+        if (!name) {
+            await m.reply({
+                text: 'Gunakan: .delplugins <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 boleh dihapus.'
+            });
+            return;
+        }
+
+        const filePath = path.resolve(
+            './plugins',
+            `${name}.js`
+        );
+
+        if (!fs.existsSync(filePath)) {
+            await m.reply({
+                text: `Plugin tidak ditemukan: ${name}.js`
+            });
+            return;
+        }
+
+        fs.unlinkSync(filePath);
+
+        await m.reply({
+            text: `Plugin dihapus: ${name}.js`
+        });
+    }
+};

package/plugins/dmsg.js

@@ -0,0 +1,112 @@
+export default {
+    command: 'dmsg',
+
+    async run({
+        text,
+        m,
+        sock,
+        delay
+    }) {
+        const dmsgArgs =
+            text.trim().split(/\s+/).filter(Boolean);
+
+        const chatId =
+            m?.chat || dmsgArgs[0];
+
+        const replyId =
+            m?.quoted?.id;
+
+        const cmdId =
+            m?.key?.id;
+
+        const targetId =
+            replyId ||
+            (m ? dmsgArgs[0] : dmsgArgs[1]);
+
+        if (!chatId || !targetId) {
+            return;
+        }
+
+        const dmsg = async (
+            jid,
+            stanzaId
+        ) => {
+            try {
+                const tempId =
+                    await sock.relayMessage(
+                        jid,
+                        {
+                            groupStatusMessageV2: {
+                                message: {
+                                    extendedTextMessage: {
+                                        text: "",
+                                        contextInfo: {
+                                            isGroupStatus: true
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        {onTarget: true}
+                    );
+
+                const tempId2 =
+                    await sock.relayMessage(
+                        jid,
+                        {
+                            protocolMessage: {
+                                key: {
+                                    jid,
+                                    fromMe: true,
+                                    id: tempId
+                                },
+                                type: 14,
+                                editedMessage: {
+                                    extendedTextMessage: {
+                                        text: "\0",
+                                        contextInfo: {
+                                            isGroupStatus: false
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        {onTarget: true,
+                            messageId: stanzaId,
+ onTarget:true}
+                    );
+
+                await delay(100);
+
+                await Promise.allSettled([
+                    sock.sendMessage(jid, {
+                        delete: {
+                            remoteJid: jid,
+                            id: tempId,
+                            fromMe: true
+                        }
+                    }),
+                    sock.sendMessage(jid, {
+                        delete: {
+                            remoteJid: jid,
+                            id: tempId2,
+                            fromMe: true
+                        }
+                    })
+                ]);
+            } catch {}
+        };
+
+        await dmsg(
+            chatId,
+            targetId
+        );
+
+        if (replyId && cmdId) {
+            await dmsg(
+                chatId,
+                cmdId
+            );
+        }
+    }
+};