vinzzsync-wacli 1.0.0

package/lib/sqlAuth.js

@@ -0,0 +1,109 @@
+/**
+ * Custom SQLite Auth Store untuk Baileys
+ * by Ryuu
+ */
+
+import Database from "better-sqlite3";
+import { proto, BufferJSON, initAuthCreds } from "@vkazee/baileys";
+
+/**
+ * Membuat atau mengambil auth state dari SQLite
+ * @param {string} dbPath - Lokasi file SQLite (contoh: "./auth.db")
+ */
+export async function useSQLiteAuthState(dbPath = "./auth.db") {
+  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();
+
+  const load = (key) => {
+  const row = db.prepare("SELECT value FROM baileys_state WHERE key = ?").get(key);
+  if (!row) return null;
+  try {
+    return JSON.parse(row.value.toString(), BufferJSON.reviver);
+  } catch {
+    return null;
+  }
+};
+
+const save = (key, data) => {
+  const json = JSON.stringify(data, BufferJSON.replacer);
+  const buf = Buffer.from(json, "utf8");
+  db.prepare("REPLACE INTO baileys_state (key, value) VALUES (?, ?)").run(key, buf);
+};
+
+  const creds = load("creds") || initAuthCreds();
+
+  const keys = {};
+  const categories = [
+    "pre-key",
+    "session",
+    "sender-key",
+    "app-state-sync-key",
+    "app-state-sync-version"
+  ];
+
+  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 {
+        keys[category][row.key.slice(category.length + 1)] = JSON.parse(row.value.toString());
+      } catch {}
+    }
+  }
+
+  async function saveCreds() {
+    save("creds", creds);
+  }
+
+  const set = (category, id, value) => {
+    const key = `${category}:${id}`;
+    save(key, value);
+  };
+
+  const get = (category, id) => {
+    const key = `${category}:${id}`;
+    return load(key);
+  };
+
+  const del = (category, id) => {
+    const key = `${category}:${id}`;
+    db.prepare("DELETE FROM baileys_state WHERE key = ?").run(key);
+  };
+
+  return {
+  state: {
+    creds,
+    keys: {
+      get: async (type, ids) => {
+        const data = {};
+        for (const id of ids) {
+          const value = load(`${type}:${id}`);
+          if (value) 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);
+          }
+        }
+      }
+    }
+  },
+  saveCreds: async () => save("creds", creds)
+    };
+    setInterval(async () => {
+  await save("creds", creds);
+}, 30_000);
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "vinzzsync-wacli",
+  "version": "1.0.0",
+  "description": "WhatsApp CLI Controler",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "dependencies": {
+    "@img/sharp-wasm32": "^0.35.4",
+    "@vkazee/baileys": "^7.0.0-rc.9-patch.4",
+    "archiver": "^8.0.0",
+    "baileys-mbuilder": "^0.0.1-security",
+    "better-sqlite3": "^13.0.3",
+    "fluent-ffmpeg": "^2.1.3",
+    "prompts": "^2.4.2",
+    "qrcode-terminal": "^0.12.0",
+    "sharp": "^0.35.4"
+  }
+}

package/plugins/_loader.js

@@ -0,0 +1,191 @@
+import fs from 'fs';
+import path from 'path';
+import { pathToFileURL } from 'url';
+
+const plugins = new Map();
+
+const commandOrder = [
+    'help',
+    'send',
+    'me',
+    'profile',
+    'status',
+    'session',
+    'ping',
+    'reconnect',
+    'clear',
+    'groups',
+    'cms',
+    'dmsg',
+    'smsg',
+    'q',
+    'fr',
+    'fitnah',
+    'cekch',
+    'cekgb',
+    'fadm',
+    'evfil',
+    'cmfil',
+    'eval',
+    'cmd',
+    'exec',
+    'exit'
+];
+
+let pluginDir = path.resolve('./plugins');
+let watcher = null;
+let reloadTimer = null;
+let loading = false;
+
+async function loadPlugins({ info, errlog } = {}) {
+    if (loading) return plugins;
+
+    loading = true;
+
+    try {
+        plugins.clear();
+
+        if (!fs.existsSync(pluginDir)) {
+            fs.mkdirSync(pluginDir, { recursive: true });
+        }
+
+        const files = fs.readdirSync(pluginDir)
+            .filter(file => file.endsWith('.js'))
+            .filter(file => file !== '_loader.js')
+            .sort();
+
+        for (const file of files) {
+            const filePath = path.join(pluginDir, file);
+
+            try {
+                const url =
+                    `${pathToFileURL(filePath).href}?v=${Date.now()}_${Math.random()}`;
+
+                const mod = await import(url);
+                const plugin = mod.default;
+
+                if (!plugin) continue;
+                if (!plugin.command || typeof plugin.run !== 'function') continue;
+
+                const commands = Array.isArray(plugin.command)
+                    ? plugin.command
+                    : [plugin.command];
+
+                for (const command of commands) {
+                    const name = String(command)
+                        .trim()
+                        .toLowerCase();
+
+                    if (!name) continue;
+
+                    plugins.set(name, plugin);
+                }
+
+                if (typeof info === 'function') {
+                    info(`Plugin loaded: ${file}`);
+                }
+            } catch (error) {
+                if (typeof errlog === 'function') {
+                    errlog(`Plugin gagal dimuat: ${file}`, error);
+                } else {
+                    console.error(`Plugin gagal dimuat: ${file}`, error);
+                }
+            }
+        }
+    } finally {
+        loading = false;
+    }
+
+    return plugins;
+}
+
+function getPlugin(command) {
+    return plugins.get(
+        String(command || '').trim().toLowerCase()
+    );
+}
+
+function getPlugins() {
+    return plugins;
+}
+
+function getPluginCommands() {
+    const loaded = [...plugins.keys()];
+
+    const ordered = commandOrder.filter(
+        command => loaded.includes(command)
+    );
+
+    const remaining = loaded.filter(
+        command => !commandOrder.includes(command)
+    );
+
+    return [...ordered, ...remaining];
+}
+
+function watchPlugins(options = {}) {
+    const {
+        info,
+        errlog
+    } = options;
+
+    if (watcher) {
+        watcher.close();
+        watcher = null;
+    }
+
+    if (!fs.existsSync(pluginDir)) {
+        fs.mkdirSync(pluginDir, { recursive: true });
+    }
+
+    watcher = fs.watch(
+        pluginDir,
+        { persistent: true },
+        (eventType, filename) => {
+            if (!filename) return;
+
+            const file = filename.toString();
+
+            if (!file.endsWith('.js')) return;
+            if (file === '_loader.js') return;
+
+            clearTimeout(reloadTimer);
+
+            reloadTimer = setTimeout(async () => {
+                try {
+                    await loadPlugins({
+                        info: null,
+                        errlog
+                    });
+
+                    if (typeof info === 'function') {
+                        info(`Plugin registry diperbarui: ${file}`);
+                    }
+                } catch (error) {
+                    if (typeof errlog === 'function') {
+                        errlog('Gagal reload plugin', error);
+                    }
+                }
+            }, 300);
+        }
+    );
+
+    if (typeof info === 'function') {
+        info(`Plugin watcher aktif: ${pluginDir}`);
+    }
+
+    return watcher;
+}
+
+async function reloadPlugins(options = {}) {
+    return loadPlugins(options);
+}
+
+export {
+    loadPlugins,
+    reloadPlugins,
+    watchPlugins,
+    getPlugin,
+    getPlugins,
+    getPluginCommands
+};

package/plugins/addplugins.js

@@ -0,0 +1,93 @@
+import fs from 'fs';
+import path from 'path';
+
+export default {
+    command: 'addplugins',
+
+    async run(ctx) {
+        const {
+            m,
+            args,
+            extractMessageText
+        } = ctx;
+
+        if (!m?.chat) return;
+
+        const name = String(args?.[0] || '')
+            .replace(/\.js$/i, '');
+
+        if (!name) {
+            await m.reply({
+                text: 'Gunakan: .addplugins <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 diubah.'
+            });
+            return;
+        }
+
+        if (!m.quoted) {
+            await m.reply({
+                text: 'Reply pesan yang berisi source plugin.'
+            });
+            return;
+        }
+
+        let source = '';
+
+        try {
+            source =
+                extractMessageText?.(m.quoted.message) ||
+                m.quoted.text ||
+                m.quoted.body ||
+                '';
+        } catch {}
+
+        source = String(source).trim();
+
+        if (!source) {
+            await m.reply({
+                text: 'Quoted message tidak berisi source plugin.'
+            });
+            return;
+        }
+
+        const pluginDir = path.resolve('./plugins');
+
+        if (!fs.existsSync(pluginDir)) {
+            fs.mkdirSync(pluginDir, {
+                recursive: true
+            });
+        }
+
+        const filePath = path.join(
+            pluginDir,
+            `${name}.js`
+        );
+
+        const existed = fs.existsSync(filePath);
+
+        fs.writeFileSync(
+            filePath,
+            source,
+            'utf8'
+        );
+
+        await m.reply({
+            text: existed
+                ? `Plugin diperbarui: ${name}.js`
+                : `Plugin ditambahkan: ${name}.js`
+        });
+    }
+};

package/plugins/backup.js

@@ -0,0 +1,91 @@
+import fs from 'fs';
+import path from 'path';
+import { exec } from 'child_process';
+
+function runExec(command) {
+    return new Promise((resolve, reject) => {
+        exec(command, {
+            cwd: process.cwd(),
+            maxBuffer: 1024 * 1024 * 20
+        }, (error, stdout, stderr) => {
+            if (error) {
+                reject(
+                    new Error(
+                        stderr?.trim() ||
+                        stdout?.trim() ||
+                        error.message
+                    )
+                );
+                return;
+            }
+
+            resolve(stdout);
+        });
+    });
+}
+
+export default {
+    command: 'backup',
+
+    async run({ m, sock }) {
+        const backupDir = '/tmp';
+
+        const stamp = new Date()
+            .toISOString()
+            .replace(/[:.]/g, '-');
+
+        const fileName = `backup-${stamp}.zip`;
+        const zipPath = path.join(backupDir, fileName);
+
+        const command =
+            `zip -r -q ${JSON.stringify(zipPath)} . -x ${JSON.stringify('./node_modules/*')} ${JSON.stringify('./session/*')} ${JSON.stringify('./.git/*')}`;
+
+        try {
+            await runExec(command);
+
+            if (!fs.existsSync(zipPath)) {
+                throw new Error('File backup tidak terbentuk');
+            }
+
+            const stat = fs.statSync(zipPath);
+            const size = (stat.size / 1024 / 1024).toFixed(2);
+
+            await sock.sendMessage(
+                m.chat,
+                {
+                    document: {
+                        url: zipPath
+                    },
+                    mimetype: 'application/zip',
+                    fileName,
+                    caption:
+                        `BACKUP SELESAI\n\n` +
+                        `File : ${fileName}\n` +
+                        `Size : ${size} MB\n\n` +
+                        `Exclude:\n` +
+                        `- node_modules\n` +
+                        `- session\n` +
+                        `- .git`
+                },
+                {
+                    quoted: global.v
+                }
+            );
+
+            if (fs.existsSync(zipPath)) {
+                fs.unlinkSync(zipPath);
+            }
+        } catch (error) {
+            const result =
+                `BACKUP GAGAL\n\n${error?.message || error}`;
+
+            if (m?.reply) {
+                await m.reply({
+                    text: result
+                });
+            } else {
+                console.error(result);
+            }
+        }
+    }
+};

package/plugins/cekch.js

@@ -0,0 +1,157 @@
+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: 'cekch',
+
+    async run({
+        m,
+        text,
+        sock
+    }) {
+        let input =
+            text.trim();
+
+        if (!input) {
+            out(m, 
+                "Format:\n" +
+                "cekch <id channel / link channel>"
+            );
+
+            return;
+        }
+
+        try {
+            let info;
+
+            if (
+                input.endsWith(
+                    "@newsletter"
+                )
+            ) {
+                info =
+                    await sock.newsletterMetadata(
+                        "jid",
+                        input
+                    );
+            } else {
+                input =
+                    input.replace(
+                        /\/+$/,
+                        ""
+                    );
+
+                let inviteCode =
+                    input.split("/").pop();
+
+                if (!inviteCode) {
+                    out(m, 
+                        "[CEKCH] ID atau link tidak valid!"
+                    );
+
+                    return;
+                }
+
+                info =
+                    await sock.newsletterMetadata(
+                        "invite",
+                        inviteCode
+                    );
+            }
+
+            const meta =
+                info.thread_metadata || {};
+
+            const formatTime =
+                timestamp => {
+                    if (!timestamp) {
+                        return "-";
+                    }
+
+                    const date =
+                        new Date(
+                            Number(timestamp) * 1000
+                        );
+
+                    return date.toLocaleString(
+                        "id-ID",
+                        {
+                            timeZone:
+                                "Asia/Jakarta",
+                            dateStyle:
+                                "full",
+                            timeStyle:
+                                "medium"
+                        }
+                    );
+                };
+
+            const verification =
+                meta.verification ||
+                info.verification ||
+                "-";
+
+            out(m, `
+╔════════════════════════════════════╗
+║           CHANNEL INFO             ║
+╚════════════════════════════════════╝
+
+📛 Nama
+${meta.name?.text || "-"}
+
+🆔 Channel ID
+${info.id || "-"}
+
+📌 Status
+${info.state?.type || "-"}
+
+✓ Verifikasi
+${verification}
+
+👥 Subscriber
+${Number(
+    meta.subscribers_count || 0
+).toLocaleString("id-ID")}
+
+👤 Role Akun
+${info.viewer_metadata?.role || "GUEST"}
+
+🔔 Notifikasi
+${info.viewer_metadata?.mute || "-"}
+
+🔗 Invite Code
+${meta.invite || "-"}
+
+🌐 Link Channel
+${meta.invite
+    ? `https://whatsapp.com/channel/${meta.invite}`
+    : "-"}
+
+🏷️ Handle
+${meta.handle || "-"}
+
+📅 Dibuat
+${formatTime(meta.creation_time)}
+
+🕒 Terakhir Diupdate
+${formatTime(meta.update_time)}
+
+📝 Deskripsi
+${meta.description?.text || "-"}
+
+══════════════════════════════════════
+        `);
+        } catch (err) {
+            out(m, 
+                "[CEKCH] Gagal mengambil info channel:",
+                err.message || err
+            );
+        }
+    }
+};