vinzzsync-wacli 1.0.0

package/index.js

@@ -0,0 +1,2416 @@
+// ============================================================
+// SMART WA CLI
+// - Auto detect MultiFile / SQLite session
+// - Auto reconnect
+// - Dynamic WA Web version when supported
+// - Incoming message callback/debug
+// - send / eval / cmd / exec / me / profile / status
+// ============================================================
+
+import fs from 'fs';
+import path from 'path';
+import util from 'util';
+import crypto from "crypto";
+import qrcode from 'qrcode-terminal'
+import readline from 'readline';
+import { exec } from 'child_process';
+import prompts from 'prompts';
+import Database from 'better-sqlite3';
+import { VERSION, Button, ButtonV2, Carousel, AIRich, Toolkit, copyNForward} from "./func.js";
+import { pathToFileURL } from 'url';
+import {
+    loadPlugins,
+    getPlugin,
+    getPluginCommands,
+    watchPlugins
+} from './plugins/_loader.js';
+// ------------------------------------------------------------
+// BAILEYS - dynamic import supaya export fork lebih fleksibel
+// ------------------------------------------------------------
+
+const baileys = await import('@vkazee/baileys');
+
+const makeWASocket =
+    baileys.default ??
+    baileys.makeWASocket;
+    
+const delay = baileys.delay;
+
+const useMultiFileAuthState =
+    baileys.useMultiFileAuthState;
+
+const makeCacheableSignalKeyStore =
+    baileys.makeCacheableSignalKeyStore;
+
+const fetchLatestWaWebVersion =
+    baileys.fetchLatestWaWebVersion;
+
+const Browsers =
+    baileys.Browsers;
+
+const {
+    BufferJSON,
+    initAuthCreds
+} = baileys;
+
+// ------------------------------------------------------------
+// CONFIG
+// ------------------------------------------------------------
+
+const SESSION_DIR = path.resolve('./session');
+
+const LOG_LEVEL =
+    process.env.LOG_LEVEL || 'info';
+
+const BASE_RECONNECT_DELAY = 3000;
+const MAX_RECONNECT_DELAY = 30000;
+
+const ENABLE_DYNAMIC_VERSION = true;
+
+// ------------------------------------------------------------
+// GLOBAL STATE
+// ------------------------------------------------------------
+global.owner = "6285185667890";
+global.ownerr = "6285185667890@s.whatsapp.net";
+global.v = {
+            key: {
+                participant: '13135550002@s.whatsapp.net',
+                remoteJid: '17608914335-1615035634@g.us',
+            },
+            message: {
+                conversation: `_Powered By Vinzz_`
+            }
+        };
+global.prefix = ".";
+let loginMethod = null;
+let sock = null;
+
+let sessionType = 'unknown';
+let sessionPath = null;
+
+let connectionState = 'closed';
+
+let reconnectTimer = null;
+let reconnectAttempts = 0;
+
+let shuttingDown = false;
+let terminalStarted = false;
+let lastDisconnectInfo = null;
+
+let currentWaVersion = null;
+let lastDisconnect = null;
+let lastConnectionUpdate = null;
+
+let messageCount = 0;
+
+// ============================================================
+// MESSAGE CACHE
+// ============================================================
+
+function getMessageType(message) {
+    if (!message) {
+        return 'unknown';
+    }
+
+    const keys =
+        Object.keys(
+            message
+        );
+
+    return (
+        keys[0] ||
+        'unknown'
+    );
+}
+
+
+const messageStore = new Map();
+const MAX_MESSAGES = 2000;
+
+function saveMessage(message) {
+
+    if (
+        !message?.key?.id ||
+        !message?.key?.remoteJid
+    ) {
+        return;
+    }
+
+    const key =
+        `${message.key.remoteJid}:${message.key.id}`;
+
+    messageStore.set(
+        key,
+        message
+    );
+
+    // Hapus pesan paling lama jika cache penuh
+    if (
+        messageStore.size >
+        MAX_MESSAGES
+    ) {
+        const oldestKey =
+            messageStore
+                .keys()
+                .next()
+                .value;
+
+        messageStore.delete(
+            oldestKey
+        );
+    }
+}
+
+function getDynamicHelpList() {
+    const source = handleCommand.toString();
+
+    const commands = [
+        ...source.matchAll(/\bcase\s+['"]([^'"]+)['"]\s*:/g)
+    ]
+        .map(match => match[1])
+        .filter(Boolean);
+
+    return [...new Set(commands)];
+}
+
+async function chooseLoginMethod() {
+    const response = await prompts({
+        type: 'select',
+        name: 'method',
+        message: 'Pilih method login:',
+        choices: [
+            {
+                title: 'Scan QR Code',
+                value: 'qr'
+            },
+            {
+                title: 'Pairing Code',
+                value: 'pairing'
+            }
+        ],
+        initial: 0
+    });
+
+    if (!response.method) {
+        console.log('\nOperasi dibatalkan.');
+        process.exit(0);
+    }
+
+    return response.method;
+}
+
+// ------------------------------------------------------------
+// READLINE
+// ------------------------------------------------------------
+
+let rl = null;
+
+function initReadline() {
+    if (process.stdin.isTTY && process.stdin.setRawMode) {
+        process.stdin.setRawMode(false);
+        process.stdin.resume();
+    }
+
+    if (rl) {
+        try { rl.close(); } catch {}
+    }
+
+    rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: true
+    });
+
+    rl.setPrompt('\x1b[32mroot@wa-cli\x1b[0m:\x1b[34m~\x1b[0m$ ');
+
+    rl.on('line', async input => {
+        if (shuttingDown || (loginMethod === 'pairing' && connectionState !== 'open')) {
+            return;
+        }
+
+        try {
+            await handleCommand(input);
+        } catch (err) {
+            console.error(err);
+        }
+
+        if (!shuttingDown && connectionState === 'open') {
+            rl.prompt();
+        } else {
+            terminalStarted = false;
+        }
+    });
+}
+
+
+// ------------------------------------------------------------
+// COLORS / LOGGING
+// ------------------------------------------------------------
+
+function now() {
+    return new Date().toISOString();
+}
+
+function debug(label, value = '') {
+    const prefix =
+        `\x1b[36m[${now()}] [DEBUG] ${label}\x1b[0m`;
+
+    if (
+        typeof value === 'object' &&
+        value !== null
+    ) {
+        console.log(
+            prefix,
+            util.inspect(value, {
+                depth: 10,
+                colors: true,
+                compact: false
+            })
+        );
+    } else {
+        console.log(prefix, value);
+    }
+}
+
+function info(message) {
+    console.log(
+        `\x1b[32m[+] ${message}\x1b[0m`
+    );
+}
+
+function warn(message) {
+    console.log(
+        `\x1b[33m[!] ${message}\x1b[0m`
+    );
+}
+
+function errlog(message, error = null) {
+    console.log(
+        `\x1b[31m[ERROR] ${message}\x1b[0m`
+    );
+
+    if (error) {
+        console.error(
+            util.inspect(error, {
+                depth: 10,
+                colors: true,
+                compact: false
+            })
+        );
+    }
+}
+
+// ------------------------------------------------------------
+// SESSION DETECTION
+// ------------------------------------------------------------
+
+function fileExists(file) {
+    try {
+        return fs.existsSync(file);
+    } catch {
+        return false;
+    }
+}
+
+function isDirectory(dir) {
+    try {
+        return fs.statSync(dir).isDirectory();
+    } catch {
+        return false;
+    }
+}
+
+function detectSQLiteAuth(dbPath) {
+    let db;
+
+    try {
+        db = new Database(
+            dbPath,
+            {
+                readonly: true,
+                fileMustExist: true
+            }
+        );
+
+        const rows =
+            db.prepare(`
+                SELECT name
+                FROM sqlite_master
+                WHERE type = 'table'
+            `).all();
+
+        const tables =
+            rows.map(x => x.name);
+
+        const hasBaileysState =
+            tables.includes('baileys_state');
+
+        let registered = false;
+
+        if (hasBaileysState) {
+            const row =
+                db.prepare(`
+                    SELECT value
+                    FROM baileys_state
+                    WHERE key = 'creds'
+                    LIMIT 1
+                `).get();
+
+            if (row?.value) {
+                try {
+                    const creds =
+                        JSON.parse(
+                            Buffer.from(
+                                row.value
+                            ).toString(),
+                            BufferJSON?.reviver
+                        );
+
+                    registered =
+                        creds?.registered === true;
+                } catch {
+                    registered = false;
+                }
+            }
+        }
+
+        return {
+            valid: hasBaileysState,
+            registered,
+            tables
+        };
+
+    } catch (error) {
+        debug(
+            `SQLite check gagal: ${dbPath}`,
+            error.message
+        );
+
+        return {
+            valid: false,
+            registered: false,
+            tables: []
+        };
+
+    } finally {
+        try {
+            db?.close();
+        } catch {}
+    }
+}
+
+function detectMultiFileAuth(dir) {
+    if (!isDirectory(dir)) {
+        return {
+            valid: false,
+            registered: false,
+            files: []
+        };
+    }
+
+    const files =
+        fs.readdirSync(dir);
+
+    const credsPath =
+        path.join(dir, 'creds.json');
+
+    if (!fileExists(credsPath)) {
+        return {
+            valid: false,
+            registered: false,
+            files
+        };
+    }
+
+    try {
+        const creds =
+            JSON.parse(
+                fs.readFileSync(
+                    credsPath,
+                    'utf8'
+                )
+            );
+
+        return {
+            valid: true,
+            registered:
+                creds?.registered === true,
+            files
+        };
+
+    } catch {
+        return {
+            valid: false,
+            registered: false,
+            files
+        };
+    }
+}
+
+// Ubah signature fungsi menjadi menerima parameter dir
+function detectSession(targetDir = SESSION_DIR) {
+    const result = {
+        type: 'none',
+        path: null,
+        registered: false,
+        details: {}
+    };
+
+    if (!isDirectory(targetDir)) {
+        return result;
+    }
+
+    const entries = fs.readdirSync(targetDir, { withFileTypes: true });
+
+    const sqliteCandidates = entries
+        .filter(entry => entry.isFile() && (entry.name.endsWith('.db') || entry.name.endsWith('.sqlite') || entry.name.endsWith('.sqlite3')))
+        .map(entry => path.join(targetDir, entry.name));
+
+    const sqliteResults = sqliteCandidates.map(dbPath => ({
+        dbPath,
+        ...detectSQLiteAuth(dbPath)
+    }));
+
+    const registeredSQLite = sqliteResults.find(x => x.valid && x.registered);
+    if (registeredSQLite) {
+        return { type: 'sqlite', path: registeredSQLite.dbPath, registered: true, details: registeredSQLite };
+    }
+
+    const validSQLite = sqliteResults.find(x => x.valid);
+    if (validSQLite) {
+        return { type: 'sqlite', path: validSQLite.dbPath, registered: validSQLite.registered, details: validSQLite };
+    }
+
+    const multi = detectMultiFileAuth(targetDir);
+    if (multi.valid) {
+        return { type: 'multifile', path: targetDir, registered: multi.registered, details: multi };
+    }
+
+    return result;
+}
+
+
+// ------------------------------------------------------------
+// SQLITE AUTH LOADER
+// Kompatibel dengan struktur:
+// baileys_state(key TEXT PRIMARY KEY, value BLOB)
+// ------------------------------------------------------------
+
+async function useSQLiteAuthState(dbPath) {
+    const db =
+        new Database(dbPath);
+
+    db.pragma('journal_mode = WAL');
+
+    db.prepare(`
+        CREATE TABLE IF NOT EXISTS baileys_state (
+            key TEXT PRIMARY KEY,
+            value BLOB
+        )
+    `).run();
+
+    function load(key) {
+        const row =
+            db.prepare(`
+                SELECT value
+                FROM baileys_state
+                WHERE key = ?
+                LIMIT 1
+            `).get(key);
+
+        if (!row) {
+            return null;
+        }
+
+        try {
+            return JSON.parse(
+                Buffer.from(
+                    row.value
+                ).toString(),
+                BufferJSON?.reviver
+            );
+        } catch {
+            return null;
+        }
+    }
+
+    function save(key, data) {
+        const json =
+            JSON.stringify(
+                data,
+                BufferJSON?.replacer
+            );
+
+        const buffer =
+            Buffer.from(
+                json,
+                'utf8'
+            );
+
+        db.prepare(`
+            INSERT OR REPLACE INTO baileys_state
+            (key, value)
+            VALUES (?, ?)
+        `).run(
+            key,
+            buffer
+        );
+    }
+
+    function remove(key) {
+        db.prepare(`
+            DELETE FROM baileys_state
+            WHERE key = ?
+        `).run(key);
+    }
+
+    const creds =
+        load('creds') ||
+        initAuthCreds();
+
+    const keys = {};
+
+    const categories = [
+        'pre-key',
+        'session',
+        'sender-key',
+        'app-state-sync-key',
+        'app-state-sync-version',
+        'lid-mapping',
+        'device-list'
+    ];
+
+    for (
+        const category of categories
+    ) {
+        keys[category] = {};
+
+        const rows =
+            db.prepare(`
+                SELECT key, value
+                FROM baileys_state
+                WHERE key LIKE ?
+            `).all(
+                `${category}:%`
+            );
+
+        for (
+            const row of rows
+        ) {
+            try {
+                const id =
+                    row.key.slice(
+                        category.length + 1
+                    );
+
+                keys[category][id] =
+                    JSON.parse(
+                        Buffer.from(
+                            row.value
+                        ).toString(),
+                        BufferJSON?.reviver
+                    );
+
+            } catch {
+                // skip corrupt row
+            }
+        }
+    }
+
+    const state = {
+        creds,
+
+        keys: {
+
+            get: async (
+                type,
+                ids
+            ) => {
+
+                const data = {};
+
+                for (
+                    const id of ids
+                ) {
+                    const value =
+                        load(
+                            `${type}:${id}`
+                        );
+
+                    if (
+                        value !== null &&
+                        value !== undefined
+                    ) {
+                        data[id] = value;
+                    }
+                }
+
+                return data;
+            },
+
+            set: async (
+                data
+            ) => {
+
+                for (
+                    const category
+                    in data
+                ) {
+
+                    for (
+                        const id
+                        in data[category]
+                    ) {
+
+                        const value =
+                            data[
+                                category
+                            ][id];
+
+                        save(
+                            `${category}:${id}`,
+                            value
+                        );
+                    }
+                }
+            }
+        }
+    };
+
+    async function saveCreds() {
+        save(
+            'creds',
+            creds
+        );
+    }
+
+    // Persist berkala
+    const interval =
+        setInterval(
+            () => {
+                try {
+                    save(
+                        'creds',
+                        creds
+                    );
+                } catch {}
+            },
+            30000
+        );
+
+    interval.unref?.();
+
+    return {
+        state,
+        saveCreds,
+        close: () => {
+            try {
+                clearInterval(
+                    interval
+                );
+            } catch {}
+
+            try {
+                db.close();
+            } catch {}
+        },
+
+        // util internal
+        _db: db,
+        _remove: remove
+    };
+}
+
+// ------------------------------------------------------------
+// WEB VERSION
+// ------------------------------------------------------------
+
+async function getLatestVersion() {
+    if (
+        !ENABLE_DYNAMIC_VERSION ||
+        typeof fetchLatestWaWebVersion !==
+            'function'
+    ) {
+        debug(
+            'fetchLatestWaWebVersion tidak tersedia'
+        );
+
+        return null;
+    }
+
+    try {
+        const result =
+            await fetchLatestWaWebVersion();
+
+        debug(
+            'WA Web version result',
+            result
+        );
+
+        if (
+            result?.version &&
+            Array.isArray(
+                result.version
+            )
+        ) {
+
+            currentWaVersion =
+                result.version;
+
+            info(
+                `WA Web version: ${
+                    result.version.join('.')
+                }`
+            );
+
+            return result.version;
+        }
+
+    } catch (error) {
+        warn(
+            `Gagal mengambil WA Web version: ${
+                error.message
+            }`
+        );
+    }
+
+    return null;
+}
+
+// ------------------------------------------------------------
+// QR OPTIONAL RENDER
+// Tidak wajib install qrcode-terminal.
+// ------------------------------------------------------------
+
+async function renderQR(qr) {
+    try {
+        const mod =
+            await import(
+                'qrcode-terminal'
+            );
+
+        const qrTerminal =
+            mod.default ??
+            mod;
+
+        if (
+            typeof qrTerminal.generate ===
+            'function'
+        ) {
+            qrTerminal.generate(
+                qr,
+                {
+                    small: true
+                }
+            );
+
+            return true;
+        }
+
+    } catch {
+        // package tidak terpasang
+    }
+
+    console.log('');
+    console.log(
+        '[QR] qrcode-terminal tidak terpasang.'
+    );
+    console.log(
+        '[QR] QR tersedia pada event connection.update.'
+    );
+    console.log('');
+
+    return false;
+}
+
+// ------------------------------------------------------------
+// MESSAGE TEXT EXTRACTION
+// ------------------------------------------------------------
+
+function extractMessageText(message) {
+    if (!message) {
+        return '';
+    }
+
+    return (
+        message.conversation ||
+
+        message.extendedTextMessage
+            ?.text ||
+
+        message.imageMessage
+            ?.caption ||
+
+        message.videoMessage
+            ?.caption ||
+
+        message.documentMessage
+            ?.caption ||
+
+        message.buttonsResponseMessage
+            ?.selectedDisplayText ||
+
+        message.listResponseMessage
+            ?.title ||
+
+        message.templateButtonReplyMessage
+            ?.selectedDisplayText ||
+
+        message.interactiveResponseMessage
+            ?.body
+            ?.text ||
+
+        ''
+    );
+}
+
+function setupCLIInput() {
+    if (process.stdin.isTTY && process.stdin.setRawMode) {
+        process.stdin.setRawMode(false);
+    }
+
+    if (rl) rl.close();
+
+    rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: true
+    });
+
+    // SET PROMPT CUSTOM DENGAN WARNA HIJAU ANSI (\x1b[32m)
+    const greenPrompt = '\x1b[32mroot@bot-wa:~$\x1b[0m ';
+    rl.setPrompt(greenPrompt);
+
+    rl.on('line', async (line) => {
+        const input = line.trim();
+        if (input) {
+            await handleCommand(input);
+        }
+        // Munculkan lagi prompt hijau setelah command selesai dieksekusi
+        rl.prompt();
+    });
+
+    // Tampilkan prompt untuk pertama kali
+    rl.prompt();
+}
+
+
+// ------------------------------------------------------------
+// JID HELPER
+// ------------------------------------------------------------
+
+function normalizeJid(input) {
+    if (!input) {
+        return null;
+    }
+
+    if (
+        input.includes('@')
+    ) {
+        return input;
+    }
+
+    const clean =
+        input
+            .replace(
+                /[^\d]/g,
+                ''
+            );
+
+    if (!clean) {
+        return null;
+    }
+
+    return (
+        `${clean}@s.whatsapp.net`
+    );
+}
+
+// ------------------------------------------------------------
+// DISCONNECT
+// ------------------------------------------------------------
+
+function parseDisconnect(
+    lastDisconnect
+) {
+
+    const error =
+        lastDisconnect?.error;
+
+    return {
+        message:
+            error?.message ||
+            'Unknown error',
+
+        statusCode:
+            error?.output?.statusCode ??
+            error?.statusCode ??
+            error?.data?.statusCode ??
+            null,
+
+        reason:
+            error?.data?.reason ??
+            null,
+
+        location:
+            error?.data?.location ??
+            null,
+
+        name:
+            error?.name ??
+            null,
+
+        stack:
+            error?.stack ??
+            null
+    };
+}
+
+// ------------------------------------------------------------
+// RECONNECT
+// ------------------------------------------------------------
+
+function reconnectDelay() {
+    const delay =
+        BASE_RECONNECT_DELAY *
+        Math.pow(
+            2,
+            Math.min(
+                reconnectAttempts,
+                4
+            )
+        );
+
+    return Math.min(
+        delay,
+        MAX_RECONNECT_DELAY
+    );
+}
+
+function scheduleReconnect() {
+    if (
+        shuttingDown
+    ) {
+        return;
+    }
+
+    if (
+        reconnectTimer
+    ) {
+        return;
+    }
+
+    reconnectAttempts++;
+
+    const delay =
+        reconnectDelay();
+
+    warn(
+        `Reconnect #${reconnectAttempts} dalam ${delay} ms`
+    );
+
+    reconnectTimer =
+        setTimeout(
+            async () => {
+
+                reconnectTimer =
+                    null;
+
+                try {
+                    await connectWhatsApp(ACTIVE_SESSION_DIR);
+                } catch (error) {
+                    errlog(
+                        'Reconnect error',
+                        error
+                    );
+
+                    scheduleReconnect();
+                }
+            },
+            delay
+        );
+}
+
+// ------------------------------------------------------------
+// TERMINAL PROMPT
+// ------------------------------------------------------------
+
+function prompt() {
+    if (terminalStarted || shuttingDown) {
+        return;
+    }
+
+    if (connectionState !== 'open') {
+        return;
+    }
+
+    terminalStarted = true;
+
+    console.log('');
+    console.log('Ketik "help" untuk daftar command.');
+    console.log('');
+
+    ask();
+}
+
+function ask() {
+    if (shuttingDown || connectionState !== 'open' || !rl) {
+        terminalStarted = false;
+        return;
+    }
+
+    rl.prompt();
+}
+
+
+/* rl.on('line', async input => {
+    if (
+        shuttingDown ||
+        loginMethod === 'pairing' &&
+        connectionState !== 'open'
+    ) {
+        return;
+    }
+
+    try {
+        await handleCommand(input);
+    } catch (err) {
+        console.error(err);
+    }
+
+    if (
+        !shuttingDown &&
+        connectionState === 'open'
+    ) {
+        rl.prompt();
+    } else {
+        terminalStarted = false;
+    }
+}); */
+
+
+// ------------------------------------------------------------
+// MESSAGE CONTEXT / BOT STYLE HANDLER
+// ------------------------------------------------------------
+
+function jidNumber(jid) {
+    return String(jid || '')
+        .split('@')[0]
+        .split(':')[0]
+        .replace(/\D/g, '');
+}
+
+function isSameJid(a, b) {
+    const aa = jidNumber(a);
+    const bb = jidNumber(b);
+    return !!aa && !!bb && aa === bb;
+}
+
+function unwrapMessage(message) {
+    let msg = message || {};
+
+    for (let i = 0; i < 8; i++) {
+        const next =
+            msg?.ephemeralMessage?.message ||
+            msg?.viewOnceMessage?.message ||
+            msg?.viewOnceMessageV2?.message ||
+            msg?.viewOnceMessageV2Extension?.message ||
+            msg?.documentWithCaptionMessage?.message ||
+            msg;
+
+        if (next === msg) break;
+        msg = next;
+    }
+
+    return msg;
+}
+
+function getContextInfo(message) {
+    const msg = unwrapMessage(message);
+    for (const value of Object.values(msg || {})) {
+        if (value?.contextInfo) return value.contextInfo;
+    }
+    return msg?.contextInfo || null;
+}
+
+function getQuotedMessage(message, chat) {
+    const contextInfo = getContextInfo(message);
+    const quotedMessage = contextInfo?.quotedMessage;
+    const quotedId = contextInfo?.stanzaId;
+
+    if (!quotedMessage || !quotedId) return null;
+
+    const participant =
+        contextInfo?.participant ||
+        contextInfo?.remoteJid ||
+        chat ||
+        null;
+
+    const stored =
+        messageStore.get(`${chat}:${quotedId}`) ||
+        [...messageStore.values()].find(x =>
+            x?.key?.id === quotedId &&
+            x?.key?.remoteJid === chat
+        );
+
+    const key = stored?.key || {
+        remoteJid: chat,
+        id: quotedId,
+        participant,
+        fromMe: false
+    };
+
+    return {
+        key,
+        message: stored?.message || quotedMessage,
+        id: key.id || quotedId,
+        chat: key.remoteJid || chat,
+        sender: key.participant || key.senderPn || participant,
+        fromMe: key.fromMe === true
+    };
+}
+
+function createMessageContext(message) {
+    const key = message?.key || {};
+    const chat = key.remoteJid || null;
+
+    const sender =
+        key.participant ||
+        key.senderPn ||
+        key.participantPn ||
+        chat ||
+        null;
+
+    const fromMe = key.fromMe === true;
+
+    const ownerJid = global.ownerr;
+
+    const isOwner =
+        fromMe ||
+        isSameJid(sender, ownerJid) ||
+        isSameJid(key.senderPn, ownerJid);
+
+    const rawText =
+        extractMessageText(message?.message) || '';
+
+    global.vv = {
+        key: {
+            participant: '13135550002@s.whatsapp.net',
+            remoteJid: '17608914335-1615035634@g.us',
+        },
+        message: {
+            conversation: rawText
+        }
+    };
+
+    const prefix = global.prefix || '.';
+
+    const trimmed = rawText.trim();
+
+    const hasPrefix =
+        trimmed.startsWith(prefix);
+
+    const commandInput =
+        hasPrefix
+            ? trimmed.slice(prefix.length).trim()
+            : trimmed;
+
+    const parts =
+        commandInput
+            ? commandInput.split(/\s+/g)
+            : [];
+
+    const command =
+        parts.shift()?.toLowerCase() || '';
+
+    const args = parts;
+
+    const text =
+        args.join(' ');
+
+    return {
+        ...message,
+        key,
+        chat,
+        sender,
+        fromMe,
+        isOwner,
+        isGroup:
+            typeof chat === 'string' &&
+            chat.endsWith('@g.us'),
+        text: rawText,
+        body: rawText,
+        command,
+        args,
+        textCommand: text,
+        prefix: hasPrefix ? prefix : '',
+        quoted:
+            getQuotedMessage(
+                message?.message,
+                chat
+            ),
+        reply: async (
+            text,
+            chatId,
+            options
+        ) => {
+            if (!sock) return null;
+
+            const target =
+                chatId || chat;
+
+            if (!target) return null;
+
+            const content =
+                typeof text === 'string'
+                    ? { text }
+                    : text;
+
+            const sendOptions = {
+                contextInfo: {
+                    mentionedJid: [],
+                    groupMentions: [],
+                    isForwarded: false,
+                    forwardedNewsletterMessageInfo: {
+                        newsletterJid:
+                            '120363252742621904@newsletter',
+                        newsletterName:
+                            global.title || 'Vinzz',
+                        serverMessageId: -1
+                    }
+                },
+                quoted: global.vv, onTarget: true,
+                ...(options || {})
+            };
+
+            return sock.sendMessage(
+                target,
+                content,
+                sendOptions
+            );
+        },
+        send: async (
+            content,
+            options = {}
+        ) => {
+            if (!sock || !chat) {
+                return null;
+            }
+
+            return sock.sendMessage(
+                chat,
+                content,
+                options
+            );
+        }
+    };
+}
+
+function getCommandInputFromMessage(m) {
+    if (!m?.isOwner) return null;
+
+    const input = String(m.text || '').trim();
+    if (!input) return null;
+
+    const prefix = String(global.prefix || '.');
+
+    if (!input.startsWith(prefix)) {
+        return null;
+    }
+
+    const commandInput = input.slice(prefix.length).trim();
+    if (!commandInput) return null;
+
+    const firstToken = commandInput.split(/\s+/g)[0] || '';
+
+    if (!/^[a-z0-9_]+$/i.test(firstToken)) {
+        return null;
+    }
+
+    return commandInput;
+}
+
+// ------------------------------------------------------------
+// COMMANDS
+// ------------------------------------------------------------
+
+async function handleCommand(
+    input,
+    m = null
+) {
+    const trimmed = input.trim();
+
+    if (!trimmed) {
+        return;
+    }
+
+    const args = trimmed.split(/\s+/g);
+    const command = args.shift()?.toLowerCase();
+    const text = args.join(' ');
+
+    try {
+        const plugin = getPlugin(command);
+
+        if (!plugin) {
+            console.log(
+                `\x1b[31mCommand tidak ditemukan: ${command}\x1b[0m`
+            );
+            return;
+        }
+
+        await plugin.run({
+            sock,
+            m,
+            args,
+            text,
+            command,
+            messageStore,
+            MAX_MESSAGES,
+            delay,
+            fs,
+            path,
+            util,
+            crypto,
+            normalizeJid,
+            getMessageType,
+            extractMessageText,
+            unwrapMessage,
+            getContextInfo,
+            getQuotedMessage,
+            createMessageContext,
+            getPluginCommands,
+            detectSession,
+            connectionState,
+            sessionType,
+            sessionPath,
+            reconnectAttempts,
+            currentWaVersion,
+            messageCount,
+            lastDisconnect,
+            ownerr: global.ownerr,
+            shutdown,
+            connectWhatsApp,
+            ACTIVE_SESSION_DIR,
+            debug,
+            info,
+            warn,
+            errlog,
+            exec
+        });
+    } catch (error) {
+        errlog(
+            `Error menjalankan "${command}"`,
+            error
+        );
+    }
+}
+
+// ------------------------------------------------------------
+// CONNECT
+// ------------------------------------------------------------
+
+const SESSIONS_ROOT = path.resolve('./session');
+
+async function selectOrCreateSession() {
+    if (!fs.existsSync(SESSIONS_ROOT)) {
+        fs.mkdirSync(SESSIONS_ROOT, { recursive: true });
+    }
+
+    const existingDirs = fs.readdirSync(SESSIONS_ROOT, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name);
+
+    const choices = existingDirs.map(dirName => ({
+        title: `📂 ${dirName}`,
+        value: dirName
+    }));
+
+    choices.unshift({
+        title: '➕ [Add New Session]',
+        value: 'NEW_SESSION'
+    });
+
+    const response = await prompts({
+        type: 'select',
+        name: 'selectedSession',
+        message: 'Pilih session yang ingin digunakan:',
+        choices: choices,
+        initial: 0
+    });
+
+    if (!response.selectedSession) {
+        console.log('\nOperasi dibatalkan.');
+        process.exit(0);
+    }
+
+    let targetSessionFolder = response.selectedSession;
+
+    if (targetSessionFolder === 'NEW_SESSION') {
+        const nameInput = await prompts({
+            type: 'text',
+            name: 'sessionName',
+            message: 'Please add name of this session:'
+        });
+
+        const rawName = nameInput.sessionName?.trim();
+
+        if (!rawName) {
+            targetSessionFolder = `session-62xx-${Date.now().toString().slice(-4)}`;
+            info(`Nama kosong, session dinamai otomatis: ${targetSessionFolder}`);
+        } else {
+            targetSessionFolder = `session-${rawName.replace(/\s+/g, '-').toLowerCase()}`;
+        }
+
+        const fullPath = path.join(SESSIONS_ROOT, targetSessionFolder);
+        if (!fs.existsSync(fullPath)) {
+            fs.mkdirSync(fullPath, { recursive: true });
+        }
+    }
+
+    return path.join(SESSIONS_ROOT, targetSessionFolder);
+}
+
+
+async function connectWhatsApp(targetSessionDir = SESSION_DIR) {
+
+
+    if (
+        shuttingDown
+    ) {
+        return;
+    }
+
+    connectionState =
+        'connecting';
+
+    console.log('');
+    console.log(
+        '\x1b[36m=========================================='
+    );
+    console.log(
+        '       WHATSAPP SMART CONNECTION'
+    );
+    console.log(
+        '==========================================\x1b[0m'
+    );
+
+    debug(
+        'Node',
+        process.version
+    );
+
+    debug(
+        'Platform',
+        process.platform
+    );
+
+    debug(
+        'Architecture',
+        process.arch
+    );
+
+    debug(
+        'CWD',
+        process.cwd()
+    );
+
+    debug(
+        'Session directory',
+        SESSION_DIR
+    );
+
+    // --------------------------------------------------------
+    // DETECT SESSION
+    // --------------------------------------------------------
+
+    const detected =
+        detectSession(targetSessionDir);
+
+    sessionType =
+        detected.type;
+
+    sessionPath =
+        detected.path;
+
+    console.log('');
+    console.log(
+        `[SESSION] Type       : ${sessionType}`
+    );
+
+    console.log(
+        `[SESSION] Path       : ${
+            sessionPath ?? '-'
+        }`
+    );
+
+    console.log(
+        `[SESSION] Registered : ${
+            detected.registered
+        }`
+    );
+
+    debug(
+        'Session detection',
+        detected
+    );
+
+if (
+    !detected.registered
+) {
+    loginMethod =
+        await chooseLoginMethod();
+
+    console.log('');
+
+    info(
+        `Login method: ${
+            loginMethod === 'pairing'
+                ? 'PAIRING CODE'
+                : 'QR CODE'
+        }`
+    );
+}
+
+    // --------------------------------------------------------
+    // AUTH
+    // --------------------------------------------------------
+
+    let authState;
+    let saveCreds;
+    let closeAuth = null;
+
+    if (sessionType === 'sqlite') {
+        console.log('[SESSION] Menggunakan SQLite auth.');
+        const sqlite = await useSQLiteAuthState(sessionPath);
+        authState = sqlite.state;
+        saveCreds = sqlite.saveCreds;
+        closeAuth = sqlite.close;
+    } else if (sessionType === 'multifile') {
+        console.log('[SESSION] Menggunakan MultiFile auth.');
+        const multi = await useMultiFileAuthState(targetSessionDir);
+        authState = multi.state;
+        saveCreds = multi.saveCreds;
+    } else {
+        console.log('[SESSION] Belum menemukan auth session.');
+        console.log('[SESSION] Membuat session MultiFile baru.');
+
+        if (typeof useMultiFileAuthState !== 'function') {
+            throw new Error('useMultiFileAuthState tidak tersedia pada fork ini.');
+        }
+
+        const multi = await useMultiFileAuthState(targetSessionDir);
+        authState = multi.state;
+        saveCreds = multi.saveCreds;
+
+        sessionType = 'multifile';
+        sessionPath = targetSessionDir;
+    }
+
+    debug(
+        'Credentials registered',
+        authState?.creds?.registered
+    );
+
+    // --------------------------------------------------------
+    // WA WEB VERSION
+    // --------------------------------------------------------
+
+    const version =
+        await getLatestVersion();
+
+    // --------------------------------------------------------
+    // SOCKET CONFIG
+    // --------------------------------------------------------
+
+    const config = {
+        auth: {
+            creds:
+                authState.creds,
+
+            keys:
+                typeof makeCacheableSignalKeyStore ===
+                'function'
+                    ? makeCacheableSignalKeyStore(
+                        authState.keys,
+                        pinoLogger()
+                    )
+                    : authState.keys
+        },
+
+        logger:
+            pinoLogger(),
+
+        browser:
+    typeof Browsers?.macOS === 'function'
+        ? Browsers.macOS('Safari')
+        : [
+            'Mac OS',
+            'Safari',
+            '14.4.1'
+        ]
+    };
+
+    if (version) {
+        config.version =
+            version;
+    }
+
+    debug(
+        'Socket config',
+        {
+            version:
+                config.version,
+
+            browser:
+                config.browser,
+
+            sessionType,
+
+            registered:
+                authState?.creds?.registered
+        }
+    );
+
+    // --------------------------------------------------------
+    // SOCKET
+    // --------------------------------------------------------
+
+    sock =
+        makeWASocket(
+            config
+        );
+
+    debug(
+        'Socket berhasil dibuat'
+    );
+
+if (
+    !authState.creds.registered &&
+    loginMethod === 'pairing'
+) {
+    const phone = await new Promise(resolve => {
+        // Matikan sementara handler terminal
+        rl.pause();
+
+        const tempRl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: true
+        });
+
+        tempRl.question(
+            'Masukkan nomor WhatsApp (contoh 628123456789): ',
+            answer => {
+                tempRl.close();
+                rl.resume();
+                resolve(answer);
+            }
+        );
+    });
+
+    const number = phone.replace(/\D/g, '');
+
+    if (!number) {
+        warn('Nomor tidak valid.');
+        return;
+    }
+
+    try {
+        info('Menunggu socket siap...');
+
+        await new Promise(resolve =>
+            setTimeout(resolve, 6000)
+        );
+
+        info('Meminta pairing code...');
+
+        const customCode = 'VINZZOFC';
+
+        const code =
+            await sock.requestPairingCode(
+                number,
+                customCode
+            );
+
+        console.log('');
+        console.log(
+            `🔑 PAIRING CODE: ${code}`
+        );
+        console.log('');
+        info('Masukkan pairing code tersebut di WhatsApp.');
+
+    } catch (error) {
+        errlog(
+            'Gagal meminta pairing code',
+            error
+        );
+    }
+}
+
+    // --------------------------------------------------------
+    // CREDENTIALS
+    // --------------------------------------------------------
+
+    sock.ev.on(
+        'creds.update',
+        async creds => {
+
+            try {
+
+                debug(
+                    'creds.update'
+                );
+
+                // Untuk state auth yang digunakan socket,
+                // Baileys sudah memutasi authState.creds.
+                await saveCreds(
+                    creds
+                );
+
+            } catch (error) {
+
+                errlog(
+                    'Gagal menyimpan credentials',
+                    error
+                );
+            }
+        }
+    );
+
+    // --------------------------------------------------------
+    // CONNECTION UPDATE
+    // --------------------------------------------------------
+
+    sock.ev.on(
+        'connection.update',
+        async update => {
+
+            lastConnectionUpdate =
+                update;
+
+            debug(
+                'connection.update',
+                update
+            );
+
+            const {
+                connection,
+                lastDisconnect,
+                qr,
+                isNewLogin,
+                receivedPendingNotifications
+            } = update;
+
+            if (
+                connection
+            ) {
+                connectionState =
+                    connection;
+            }
+
+            // ----------------------------
+            // QR
+            // ----------------------------
+
+if (qr) {
+
+    if (loginMethod === 'qr') {
+
+        console.log('');
+        console.log(
+            '\x1b[33m📱 Scan QR WhatsApp ini:\x1b[0m'
+        );
+
+        await renderQR(qr);
+
+    } else {
+
+        debug(
+            'QR diabaikan karena login method Pairing Code'
+        );
+    }
+}
+
+            // ----------------------------
+            // CONNECTING
+            // ----------------------------
+
+            if (
+                connection ===
+                'connecting'
+            ) {
+
+                warn(
+                    'Sedang menghubungkan...'
+                );
+            }
+
+            // ----------------------------
+            // OPEN
+            // ----------------------------
+
+            if (
+                connection ===
+                'open'
+            ) {
+
+                reconnectAttempts =
+                    0;
+
+                connectionState =
+                    'open';
+
+                lastDisconnectInfo =
+                    null;
+
+                info(
+                    'BERHASIL TERHUBUNG KE WHATSAPP!'
+                );
+
+                console.log('');
+
+                if (
+                    sock?.user
+                ) {
+
+                    info(
+                        `Account: ${
+                            sock.user.id ??
+                            '-'
+                        }`
+                    );
+
+                    if (
+                        sock.user.name
+                    ) {
+                        info(
+                            `Name: ${
+                                sock.user.name
+                            }`
+                        );
+                    }
+                }
+
+                debug(
+                    'Pending notifications',
+                    receivedPendingNotifications
+                );
+
+                prompt();
+            }
+
+            // ----------------------------
+            // CLOSE
+            // ----------------------------
+
+            if (
+                connection ===
+                'close'
+            ) {
+
+                const disconnect =
+                    parseDisconnect(
+                        lastDisconnect
+                    );
+
+                lastDisconnectInfo =
+                    disconnect;
+
+                connectionState =
+                    'closed';
+
+                terminalStarted =
+                    false;
+
+                console.log('');
+                console.log(
+                    '\x1b[31m========== CONNECTION CLOSED ==========\x1b[0m'
+                );
+
+                debug(
+                    'Disconnect info',
+                    disconnect
+                );
+
+                warn(
+                    `Disconnect: ${
+                        disconnect.message
+                    }`
+                );
+
+                if (
+                    disconnect.statusCode !==
+                    null
+                ) {
+                    warn(
+                        `Status code: ${
+                            disconnect.statusCode
+                        }`
+                    );
+                }
+
+                if (
+                    disconnect.reason
+                ) {
+                    warn(
+                        `Reason: ${
+                            disconnect.reason
+                        }`
+                    );
+                }
+
+                if (
+                    disconnect.location
+                ) {
+                    warn(
+                        `Location: ${
+                            disconnect.location
+                        }`
+                    );
+                }
+
+                // Tutup DB handle kalau SQLite
+                try {
+                    closeAuth?.();
+                } catch {}
+
+                sock =
+                    null;
+
+if (!shuttingDown) {
+    if (disconnect.statusCode === 401) {
+        warn('Login ditolak / session tidak valid.');
+        warn('Hapus session lalu jalankan ulang.');
+
+        return;
+    }
+
+    scheduleReconnect();
+}
+            }
+        }
+    );
+
+// --------------------------------------------------------
+// INCOMING MESSAGES
+// --------------------------------------------------------
+
+sock.ev.on(
+    'messages.upsert',
+    async ({ messages, type }) => {
+
+        if (!Array.isArray(messages)) {
+            return;
+        }
+
+        for (
+            const message
+            of messages
+        ) {
+
+            if (!message) {
+                continue;
+            }
+saveMessage(message);
+            const key =
+                message.key;
+
+            const remoteJid =
+                key?.remoteJid ??
+                null;
+
+            const sender =
+                key?.participant ??
+                remoteJid ??
+                null;
+
+            const fromMe =
+                key?.fromMe === true;
+
+            const isGroup =
+                typeof remoteJid ===
+                'string' &&
+                remoteJid.endsWith(
+                    '@g.us'
+                );
+
+            const status =
+                isGroup
+                    ? 'GROUP'
+                    : 'PRIVATE';
+
+            const text =
+                extractMessageText(
+                    message.message
+                ) ||
+                null;
+
+            const messageType =
+                getMessageType(
+                    message.message
+                ) ??
+                'unknown';
+
+            const senderName =
+                message.pushName ??
+                null;
+
+            let groupName =
+                null;
+
+            // Ambil nama grup kalau pesan dari grup
+            if (isGroup) {
+
+                try {
+
+                    const metadata =
+                        await sock.groupMetadata(
+                            remoteJid
+                        );
+
+                    groupName =
+                        metadata?.subject ??
+                        null;
+
+                } catch {
+
+                    groupName =
+                        null;
+
+                }
+            }
+
+            // Jangan tampilkan message kosong
+            if (
+                !message.message
+            ) {
+                continue;
+            }
+
+            messageCount++;
+
+            console.log('');
+            console.log(
+                '\x1b[35m╔══════════════════════════════════════════════════╗\x1b[0m'
+            );
+
+            console.log(
+                '\x1b[35m║              📩 PESAN MASUK BARU                 ║\x1b[0m'
+            );
+
+            console.log(
+                '\x1b[35m╚══════════════════════════════════════════════════╝\x1b[0m'
+            );
+
+            console.log('');
+
+            console.log(
+                `📌 STATUS       : ${
+                    status
+                }`
+            );
+
+            console.log(
+                `📨 EVENT        : ${
+                    type ??
+                    'unknown'
+                }`
+            );
+
+            console.log(
+                `👤 PENGIRIM     : ${
+                    sender ??
+                    'null'
+                }`
+            );
+
+            console.log(
+                `📛 NAMA         : ${
+                    senderName ??
+                    'null'
+                }`
+            );
+
+            console.log(
+                `💬 CHAT         : ${
+                    remoteJid ??
+                    'null'
+                }`
+            );
+
+            console.log(
+                `👥 GRUP         : ${
+                    groupName ??
+                    'null'
+                }`
+            );
+
+            console.log(
+                `📦 JENIS PESAN  : ${
+                    messageType
+                }`
+            );
+
+            console.log(
+                `↩️ DARI SAYA     : ${
+                    fromMe
+                }`
+            );
+
+            console.log('');
+
+            console.log(
+                '📝 ISI PESAN'
+            );
+
+            console.log(
+                '──────────────────────────────────────────────────'
+            );
+
+            console.log(
+                text ??
+                '[Tidak ada teks]'
+            );
+
+            console.log(
+                '──────────────────────────────────────────────────'
+            );
+
+            console.log('');
+
+            console.log(
+                `🆔 MESSAGE ID   : ${
+                    key?.id ??
+                    'null'
+                }`
+            );
+
+            console.log(
+                `🕒 WAKTU        : ${
+                    message.messageTimestamp
+                        ? new Date(
+                            Number(
+                                message.messageTimestamp
+                            ) * 1000
+                        ).toISOString()
+                        : 'null'
+                }`
+            );
+
+            console.log('');
+
+            console.log(
+                '\x1b[35m════════════════════════════════════════════════════\x1b[0m'
+            );
+
+            console.log('');
+
+            const m = createMessageContext(message);
+            const commandInput = getCommandInputFromMessage(m);
+
+            if (commandInput && m.isOwner) {
+                try {
+                    await handleCommand(commandInput, m);
+                } catch (error) {
+                    errlog('WA command gagal', error);
+                    try {
+                        await m.reply({ text: `Error: ${error?.message || error}` });
+                    } catch {}
+                }
+            }
+        }
+    }
+);
+
+    // --------------------------------------------------------
+    // GROUP / PRESENCE DEBUG
+    // --------------------------------------------------------
+
+    sock.ev.on(
+        'presence.update',
+        update => {
+            debug(
+                'presence.update',
+                update
+            );
+        }
+    );
+
+    if (
+        typeof closeAuth ===
+        'function'
+    ) {
+        // closeAuth dikelola saat connection close
+    }
+}
+
+// ------------------------------------------------------------
+// Pino lazy logger
+// ------------------------------------------------------------
+
+function pinoLogger() {
+
+    // Import synchronous sudah tersedia lewat dynamic import?
+    // Pino belum di-import di atas supaya script fleksibel.
+    // Gunakan require tidak bisa pada ESM, jadi ambil dari cache
+    // menggunakan createRequire.
+    return loggerInstance;
+}
+
+let loggerInstance;
+
+{
+    const {
+        createRequire
+    } = await import(
+        'module'
+    );
+
+    const require =
+        createRequire(
+            import.meta.url
+        );
+
+    const pino =
+        require('pino');
+
+    loggerInstance =
+        pino({
+            level: LOG_LEVEL
+        });
+}
+
+// ------------------------------------------------------------
+// SHUTDOWN
+// ------------------------------------------------------------
+
+async function shutdown() {
+
+    if (
+        shuttingDown
+    ) {
+        return;
+    }
+
+    shuttingDown =
+        true;
+
+    console.log('');
+    warn(
+        'Shutdown dimulai...'
+    );
+
+    if (
+        reconnectTimer
+    ) {
+        clearTimeout(
+            reconnectTimer
+        );
+
+        reconnectTimer =
+            null;
+    }
+
+    try {
+        if (sock) {
+            sock.end();
+        }
+    } catch {}
+
+    try {
+        rl.close();
+    } catch {}
+
+    info(
+        'Bot dihentikan.'
+    );
+
+    process.exit(0);
+}
+
+// ------------------------------------------------------------
+// GLOBAL ERRORS
+// ------------------------------------------------------------
+
+process.on(
+    'uncaughtException',
+    error => {
+
+        errlog(
+            'UNCAUGHT EXCEPTION',
+            error
+        );
+    }
+);
+
+process.on(
+    'unhandledRejection',
+    reason => {
+
+        errlog(
+            'UNHANDLED REJECTION',
+            reason
+        );
+    }
+);
+
+process.on(
+    'SIGINT',
+    async () => {
+        await shutdown();
+    }
+);
+
+process.on(
+    'SIGTERM',
+    async () => {
+        await shutdown();
+    }
+);
+
+// ------------------------------------------------------------
+// START
+// ------------------------------------------------------------
+
+console.clear();
+
+console.log(
+    '\x1b[36m=========================================='
+);
+
+console.log(
+    '          SMART WHATSAPP CLI'
+);
+
+console.log(
+    '==========================================\x1b[0m'
+);
+
+console.log('');
+
+let ACTIVE_SESSION_DIR = null;
+
+async function startApp() {
+    console.clear();
+    console.log('\x1b[36m==========================================');
+    console.log('          SMART WHATSAPP CLI');
+    console.log('==========================================\x1b[0m\n');
+
+    // 1. Pilih session saat readline CLI belum aktif (Joystick/Panah Lancar)
+    ACTIVE_SESSION_DIR = await selectOrCreateSession();
+    
+    // 2. Inisialisasi Readline & Prompt HIJAU setelah selection selesai
+    initReadline();
+
+    info(`Session aktif: ${path.basename(ACTIVE_SESSION_DIR)}`);
+    console.log('');
+
+    // 3. Connect ke WhatsApp
+    await connectWhatsApp(ACTIVE_SESSION_DIR);
+}
+
+await loadPlugins({ info, errlog });
+watchPlugins({ info, errlog });
+startApp();
+
+export { createMessageContext, getQuotedMessage, handleCommand, messageStore };