main.js

/* If You Copy, Don`t Delete This Credit!!! 
  Don`t Sell This Script Or I Take Immediately 
  Yang Jual Script Ini Report/Hangusin Aja Akunnya Atau Pukulin ae orangnya
  Move To Pairing Code
  Buat Yg Nggk muncul Codenya Itu Disebabkan Oleh Banyaknya Plugins
  Jika Ingin Mengambil Sesi, Backup Semua File Plugins & Hapus Semua File Plugins
  Setelah Sudah Kalian Bisa Mengembalikan Semua File Pluginsnya Agar Bisa Dipakai
  Regards from YanXiao ♡
*/

process.env["NODE_TLS_REJECT_UNAUTHORIZED"] = "0";
import "./config.js";

import os from "os";
import { glob } from "glob";
import path, { join } from "path";
import fs from "fs";
import { platform } from "process";
import { fileURLToPath, pathToFileURL } from "url";
import { createRequire } from "module"; // Bring in the ability to create the 'require' method
global.__filename = function filename(
  pathURL = import.meta.url,
  rmPrefix = platform !== "win32",
) {
  return rmPrefix
    ? /file:\/\/\//.test(pathURL)
      ? fileURLToPath(pathURL)
      : pathURL
    : pathToFileURL(pathURL).toString();
};
global.__dirname = function dirname(pathURL) {
  return path.dirname(global.__filename(pathURL, true));
};
global.__require = function require(dir = import.meta.url) {
  return createRequire(dir);
};

import {
  readdirSync,
  statSync,
  unlinkSync,
  existsSync,
  readFileSync,
  watch,
} from "fs";
import yargs from "yargs";
import { spawn } from "child_process";
import lodash from "lodash";
import syntaxerror from "syntax-error";
import chalk from "chalk";
import { tmpdir } from "os";
import readline from "readline";
import { format } from "util";
import pino from "pino";
import ws from "ws";
import {
  useMultiFileAuthState,
  DisconnectReason,
  fetchLatestBaileysVersion,
  makeInMemoryStore,
  makeCacheableSignalKeyStore,
  PHONENUMBER_MCC,
} from "@adiwajshing/baileys";
import { Low, JSONFile } from "lowdb";
import { makeWASocket, protoType, serialize } from "./lib/simple.js";
import { mongoDB, mongoDBV2 } from "./lib/mongoDB.js";

const { CONNECTING } = ws;
const { chain } = lodash;
const PORT = process.env.PORT || process.env.SERVER_PORT || 3000;

protoType();
serialize();

global.API = (name, path = "/", query = {}, apikeyqueryname) =>
  (name in global.APIs ? global.APIs[name] : name) +
  path +
  (query || apikeyqueryname
    ? "?" +
      new URLSearchParams(
        Object.entries({
          ...query,
          ...(apikeyqueryname
            ? {
                [apikeyqueryname]:
                  global.APIKeys[
                    name in global.APIs ? global.APIs[name] : name
                  ],
              }
            : {}),
        }),
      )
    : "");
// global.Fn = function functionCallBack(fn, ...args) { return fn.call(global.conn, ...args) }
global.timestamp = {
  start: new Date(),
};

const __dirname = global.__dirname(import.meta.url);

global.opts = new Object(
  yargs(process.argv.slice(2)).exitProcess(false).parse(),
);
global.prefix = new RegExp(
  "^[" +
    (opts["prefix"] || "‎xzXZ/i!#$%+£¢€¥^°=¶∆×÷π√✓©®:;?&.\\-").replace(
      /[|\\{}()[\]^$+*?.\-\^]/g,
      "\\$&",
    ) +
    "]",
);

global.db = new Low(
  /https?:\/\//.test(opts["db"] || "")
    ? new cloudDBAdapter(opts["db"])
    : /mongodb(\+srv)?:\/\//i.test(opts["db"])
      ? opts["mongodbv2"]
        ? new mongoDBV2(opts["db"])
        : new mongoDB(opts["db"])
      : new JSONFile(`${opts._[0] ? opts._[0] + "_" : ""}database.json`),
);
global.DATABASE = global.db; // Backwards Compatibility
global.loadDatabase = async function loadDatabase() {
  if (db.READ)
    return new Promise((resolve) =>
      setInterval(async function () {
        if (!db.READ) {
          clearInterval(this);
          resolve(db.data == null ? global.loadDatabase() : db.data);
        }
      }, 1 * 1000),
    );
  if (db.data !== null) return;
  db.READ = true;
  await db.read().catch(console.error);
  db.READ = null;
  db.data = {
    users: {},
    chats: {},
    stats: {},
    msgs: {},
    sticker: {},
    settings: {},
    ...(db.data || {}),
  };
  global.db.chain = chain(db.data);
};
loadDatabase();
const useStore = !process.argv.includes("--use-store");
const usePairingCode = process.argv.includes("--use-pairing-code");
const useMobile = process.argv.includes("--mobile");

var question = function (text) {
  return new Promise(function (resolve) {
    rl.question(text, resolve);
  });
};
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

const store = useStore ? makeInMemoryStore({ level: "silent" }) : undefined;

store?.readFromFile("./elaina_store.json");
// save every 10s
setInterval(() => {
  store?.writeToFile("./elaina_store.json");
}, 10_000);

const { version, isLatest } = await fetchLatestBaileysVersion();
const { state, saveCreds } = await useMultiFileAuthState("./sessions");
const connectionOptions = {
  version,
  logger: pino({ level: "silent" }),
  printQRInTerminal: !usePairingCode,
  browser: ["Mac OS", "Safari", "10.15.7"],
  auth: {
    creds: state.creds,
    keys: makeCacheableSignalKeyStore(
      state.keys,
      pino().child({
        level: "silent",
        stream: "store",
      }),
    ),
  },
  getMessage: async (key) => {
    const messageData = await store.loadMessage(key.remoteJid, key.id);
    return messageData?.message || undefined;
  },
  generateHighQualityLinkPreview: true,
  patchMessageBeforeSending: (message) => {
    const requiresPatch = !!(
      message.buttonsMessage ||
      message.templateMessage ||
      message.listMessage
    );
    if (requiresPatch) {
      message = {
        viewOnceMessage: {
          message: {
            messageContextInfo: {
              deviceListMetadataVersion: 2,
              deviceListMetadata: {},
            },
            ...message,
          },
        },
      };
    }

    return message;
  },
};

global.conn = makeWASocket(connectionOptions);
conn.isInit = false;

if (usePairingCode && !conn.authState.creds.registered) {
  if (useMobile) throw new Error("Cannot use pairing code with mobile api");
  const { registration } = { registration: {} };
  let phoneNumber = "";
  do {
    phoneNumber = await question(
      chalk.blueBright(
        "Input a Valid number start with region code. Example : 62xxx:\n",
      ),
    );
  } while (
    !Object.keys(PHONENUMBER_MCC).some((v) => phoneNumber.startsWith(v))
  );
  rl.close();
  phoneNumber = phoneNumber.replace(/\D/g, "");
  console.log(chalk.bgWhite(chalk.blue("Generating code...")));
  setTimeout(async () => {
    let code = await conn.requestPairingCode(phoneNumber);
    code = code?.match(/.{1,4}/g)?.join("-") || code;
    console.log(
      chalk.black(chalk.bgGreen(`Your Pairing Code : `)),
      chalk.black(chalk.white(code)),
    );
  }, 3000);
}

if (!opts["test"]) {
  (await import("./server.js")).default(5000);
  setInterval(async () => {
    if (global.db.data) await global.db.write().catch(console.error);
    // if (opts['autocleartmp']) try {
    clearTmp();
    //  } catch (e) { console.error(e) }
  }, 60 * 1000);
}

function clearTmp() {
  const tmp = [tmpdir(), join(__dirname, "./tmp")];
  const filename = [];
  tmp.forEach((dirname) =>
    readdirSync(dirname).forEach((file) => filename.push(join(dirname, file))),
  );
  return filename.map((file) => {
    const stats = statSync(file);
    if (stats.isFile() && Date.now() - stats.mtimeMs >= 1000 * 60 * 3)
      return unlinkSync(file); // 3 minutes
    return false;
  });
}

function clearSessions(folder = "sessions") {
  let filename = [];
  readdirSync(folder).forEach((file) => filename.push(join(folder, file)));
  return filename.map((file) => {
    let stats = statSync(file);
    if (stats.isFile() && Date.now() - stats.mtimeMs >= 1000 * 60 * 120) {
      // 1 hours
      console.log("Deleted sessions", file);
      return unlinkSync(file);
    }
    return false;
  });
}

async function connectionUpdate(update) {
  const {
    receivedPendingNotifications,
    connection,
    lastDisconnect,
    isOnline,
    isNewLogin,
  } = update;
  global.stopped = connection;

  if (isNewLogin) {
    conn.isInit = true;
  }

  if (connection == "connecting") {
    console.log(
      chalk.redBright("⚡ Mengaktifkan Bot, Mohon tunggu sebentar..."),
    );
  } else if (connection == "open") {
    console.log(chalk.green("✅ Tersambung"));
  }

  if (isOnline == true) {
    console.log(chalk.green("Status Aktif"));
  } else if (isOnline == false) {
    console.log(chalk.red("Status Mati"));
  }

  if (receivedPendingNotifications) {
    console.log(chalk.yellow("Menunggu Pesan Baru"));
  }

  if (connection == "close") {
    console.log(chalk.red("⏱️ koneksi terputus & mencoba menyambung ulang..."));
  }

  global.timestamp.connect = new Date();

  if (
    lastDisconnect &&
    lastDisconnect.error &&
    lastDisconnect.error.output &&
    lastDisconnect.error.output.statusCode !== DisconnectReason.loggedOut &&
    conn.ws.readyState !== CONNECTING
  ) {
    console.log(await global.reloadHandler(true));
  }

  if (global.db.data == null) {
    await global.loadDatabase();
  }
}

process.on("uncaughtException", console.error);
// let strQuot = /(["'])(?:(?=(\\?))\2.)*?\1/

let isInit = true;
let handler = await import("./handler.js");
global.reloadHandler = async function (restatConn) {
  /*try {
        const Handler = await import(`./handler.js?update=${Date.now()}`).catch(console.error)*/
  try {
    // Jika anda menggunakan replit, gunakan yang sevenHoursLater dan tambahkan // pada const Handler
    // Default: server/vps/panel, replit + 7 jam buat jam indonesia
    // const sevenHoursLater = Date.now() + 7 * 60 * 60 * 1000;
    const Handler = await import(`./handler.js?update=${Date.now()}`).catch(
      console.error,
    );
    // const Handler = await import(`./handler.js?update=${sevenHoursLater}`).catch(console.error)
    if (Object.keys(Handler || {}).length) handler = Handler;
  } catch (e) {
    console.error(e);
  }
  if (restatConn) {
    const oldChats = global.conn.chats;
    try {
      global.conn.ws.close();
    } catch {}
    conn.ev.removeAllListeners();
    global.conn = makeWASocket(connectionOptions, { chats: oldChats });
    isInit = true;
  }
  if (!isInit) {
    conn.ev.off("messages.upsert", conn.handler);
    conn.ev.off("group-participants.update", conn.participantsUpdate);
    conn.ev.off("groups.update", conn.groupsUpdate);
    conn.ev.off("message.delete", conn.onDelete);
    conn.ev.off("connection.update", conn.connectionUpdate);
    conn.ev.off("creds.update", conn.credsUpdate);
  }

  conn.welcome =
    "❖━━━━━━[ ᴡᴇʟᴄᴏᴍᴇ Kobokers ]━━━━━━❖\n\n┏––––––━━━━━━━━•\n│☘︎ @subject\n┣━━━━━━━━┅┅┅\n│( ☔ Hallo @user)\n├[ ɪɴᴛʀᴏ ]—\n│ ɴᴀᴍᴀ: \n│ ᴜᴍᴜʀ: \n│ ɢᴇɴᴅᴇʀ:\n┗––––––━━┅┅┅\n\n––––––┅┅ ᴅᴇsᴄʀɪᴘᴛɪᴏɴ ┅┅––––––\n@desc";
  conn.bye = "❖━━━━━━[ ʟᴇᴀᴠɪɴɢ ]━━━━━━❖\n𝚂𝚊𝚢𝚘𝚗𝚊𝚛𝚊𝚊 @user 👋😃";
  conn.spromote = "@user Sekarang jadi admin!";
  conn.sdemote = "@user Sekarang bukan lagi admin!";
  conn.sDesc = "Deskripsi telah diubah menjadi \n@desc";
  conn.sSubject = "Judul grup telah diubah menjadi \n@subject";
  conn.sIcon = "Icon grup telah diubah!";
  conn.sRevoke = "Link group telah diubah ke \n@revoke";
  conn.sAnnounceOn =
    "Group telah di tutup!\nsekarang hanya admin yang dapat mengirim pesan.";
  conn.sAnnounceOff =
    "Group telah di buka!\nsekarang semua peserta dapat mengirim pesan.";
  conn.sRestrictOn = "Edit Info Grup di ubah ke hanya admin!";
  conn.sRestrictOff = "Edit Info Grup di ubah ke semua peserta!";

  conn.handler = handler.handler.bind(global.conn);
  conn.participantsUpdate = handler.participantsUpdate.bind(global.conn);
  conn.groupsUpdate = handler.groupsUpdate.bind(global.conn);
  conn.onDelete = handler.deleteUpdate.bind(global.conn);
  conn.connectionUpdate = connectionUpdate.bind(global.conn);
  conn.credsUpdate = saveCreds.bind(global.conn);

  conn.ev.on("messages.upsert", conn.handler);
  conn.ev.on("group-participants.update", conn.participantsUpdate);
  conn.ev.on("groups.update", conn.groupsUpdate);
  conn.ev.on("message.delete", conn.onDelete);
  conn.ev.on("connection.update", conn.connectionUpdate);
  conn.ev.on("creds.update", conn.credsUpdate);
  isInit = false;
  return true;
};

global.plugins = {};
const pluginFolder = join(__dirname, "./plugins");
const pluginFilter = (filename) => /\.js$/.test(filename);

async function filesInit() {
  try {
    const pluginsDirectory = path.join(__dirname, "plugins");
    const pattern = path.join(pluginsDirectory, "**/*.js");
    const CommandsFiles = glob.sync(pattern);
    
    for (let file of CommandsFiles) {
      const filename = path.basename(file)
      try {	
        const module = await import(file);
        global.plugins[filename] = module.default || module;
      } catch (e) {
        conn.logger.error(e);
        delete global.plugins[filename];
      }
    }
  } catch (e) {
    conn.logger.error(e);
  }
}

filesInit()
  .then((_) => console.log(Object.keys(global.plugins)))
  .catch(console.error);

global.reload = async (_ev, filename) => {
  if (pluginFilter(filename)) {
    let dir = global.__filename(join(pluginFolder, filename), true);
    if (filename in global.plugins) {
      if (existsSync(dir))
        conn.logger.info(`re - require plugin '${filename}'`);
      else {
        conn.logger.warn(`deleted plugin '${filename}'`);
        return delete global.plugins[filename];
      }
    } else conn.logger.info(`requiring new plugin '${filename}'`);
    let err = syntaxerror(readFileSync(dir), filename, {
      sourceType: "module",
      allowAwaitOutsideFunction: true,
    });
    if (err)
      conn.logger.error(
        `syntax error while loading '${filename}'\n${format(err)}`,
      );
    else
      try {
        console.log(global.__filename(dir))
        const module = await import(
          `${global.__filename(dir)}?update=${Date.now()}`
        );
        global.plugins[filename] = module.default || module;
      } catch (e) {
        conn.logger.error(`error require plugin '${filename}\n${format(e)}'`);
      } finally {
        global.plugins = Object.fromEntries(
          Object.entries(global.plugins).sort(([a], [b]) => a.localeCompare(b)),
        );
      }
  }
};
Object.freeze(global.reload);
watch(pluginFolder, { recursive: true }, (_eventType, filename) => {
  global.reload(null, filename);
});
await global.reloadHandler();

function formatFilename(filename) {
  let dir = join(__dirname, "./");
  // fix invalid regular expresion when run in windows
  if (os.platform() === "win32") dir = dir.replace(/\\/g, "\\\\");
  // '^' mean only replace if starts with
  const regex = new RegExp(`^${dir}`);
  const formated = filename.replace(regex, "");
  return formated;
}

// Quick Test

async function _quickTest() {
  let test = await Promise.all(
    [
      spawn("ffmpeg"),
      spawn("ffprobe"),
      spawn("ffmpeg", [
        "-hide_banner",
        "-loglevel",
        "error",
        "-filter_complex",
        "color",
        "-frames:v",
        "1",
        "-f",
        "webp",
        "-",
      ]),
      spawn("convert"),
      spawn("magick"),
      spawn("gm"),
      spawn("find", ["--version"]),
    ].map((p) => {
      return Promise.race([
        new Promise((resolve) => {
          p.on("close", (code) => {
            resolve(code !== 127);
          });
        }),
        new Promise((resolve) => {
          p.on("error", (_) => resolve(false));
        }),
      ]);
    }),
  );
  let [ffmpeg, ffprobe, ffmpegWebp, convert, magick, gm, find] = test;
  console.log(test);
  let s = (global.support = {
    ffmpeg,
    ffprobe,
    ffmpegWebp,
    convert,
    magick,
    gm,
    find,
  });
  // require('./lib/sticker').support = s
  Object.freeze(global.support);

  if (!s.ffmpeg) {
    conn.logger.warn(
      `Silahkan install ffmpeg terlebih dahulu agar bisa mengirim video`,
    );
  }

  if (s.ffmpeg && !s.ffmpegWebp) {
    conn.logger.warn(
      "Sticker Mungkin Tidak Beranimasi tanpa libwebp di ffmpeg (--enable-ibwebp while compiling ffmpeg)",
    );
  }

  if (!s.convert && !s.magick && !s.gm) {
    conn.logger.warn(
      "Fitur Stiker Mungkin Tidak Bekerja Tanpa imagemagick dan libwebp di ffmpeg belum terinstall (pkg install imagemagick)",
    );
  }
}

_quickTest()
  .then(() =>
    conn.logger.info("☑️ Quick Test Done , nama file session ~> creds.json"),
  )
  .catch(console.error);