@manybot/manybot 5.1.0 → 5.2.1

package/src/client/banner.js

@@ -1,57 +0,0 @@
-const C = {
-  reset: "\x1b[0m",
-  bold: "\x1b[1m",
-
-  blue: "\x1b[94m",
-  magenta: "\x1b[95m",
-  cyan: "\x1b[96m",
-  gray: "\x1b[90m",
-  yellow: "\x1b[93m",
-};
-
-import { readFileSync } from "fs";
-import { fileURLToPath } from "url";
-import path from "path";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const v = JSON.parse(
-  readFileSync(
-    path.join(__dirname, "../../package.json"),
-    "utf8"
-  )
-).version;
-
-export function printBanner() {
-  const banner = [
-    `                             _           _  `,
-    `                            | |         | | `,
-    ` _ __ ___   __ _ _ __  _   _| |__   ___ | |_`,
-    `| '_ \` _ \\ / _\` | '_ \\| | | | '_ \\ / _ \\| __`,
-    `| | | | | | (_| | | | | |_| | |_) | (_) | |_`,
-    `|_| |_| |_|\\__,_|_| |_|\\__, |_.__/ \\___/ \\__`,
-    `                        __/ |               `,
-    ` ${v}                 |___/                `
-  ];
-
-  console.log(`${C.bold}${C.blue}`);
-  console.log(banner.join("\n"));
-  console.log(C.reset);
-
-  console.log(
-    `  made with ${C.magenta}<3${C.reset} by ${C.bold}${C.cyan}SyntaxError!${C.reset} ${C.gray}<me@stxerr.dev>${C.reset}`
-  );
-
-  console.log();
-
-  console.log(
-    `  ${C.gray}website${C.reset} : ${C.yellow}https://manybot.stxerr.dev${C.reset}`
-  );
-
-  console.log(
-    `  ${C.gray}github ${C.reset} : ${C.yellow}https://github.com/many-bot${C.reset}`
-  );
-
-  console.log();
-}

package/src/client/whatsappClient.js

@@ -1,185 +0,0 @@
-/* whatsappClient
- *
- * Initialize client and connect to WhatsApp
- *
- * if PHONE_NUMBER is set on config, it will request a verficiation code
- * but if it is not, it will display a QR Code on the screen to scan using your phone
- *
- * */
-
-import pkg                         from "whatsapp-web.js";
-import fs                          from "fs";
-import path                        from "path";
-import { fileURLToPath }           from "url";
-import { PHONE_NUMBER, CLIENT_ID } from "#config";
-import { logger }                  from "#logger";
-import qrcode                      from "qrcode-terminal";
-import { t }                       from "#i18n"
-import { CONFIG_DIR }              from "#config";
-import { extract }                 from "tar";
-import { pipeline }                from "node:stream/promises";
-import { Readable }                from "node:stream";
-import { Transform }               from "node:stream";
-const os = process.platform;
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const DATA_PATH = path.join(CONFIG_DIR, "sessions");
-
-const chromeDir = path.join(CONFIG_DIR, "chrome");
-
-const bins = {
-  linux: "chrome",
-  win32: "chrome.exe"
-}
-
-const chrome = path.join(chromeDir, bins[os]);
-
-if (!fs.existsSync(chrome)) {
-  try {
-    logger.warn(t("errors.chromeNotFound"));
-    const tmpDir  = "/tmp/manybot-chrome";
-    const tmpPath = path.join(tmpDir, "chrome.tar.gz");
-    const urls = {
-      linux: "https://api.manybot.stxerr.dev/download-chrome-linux",
-      win32: "https://api.manybot.stxerr.dev/download-chrome-win"
-    }
-
-    const url = urls[os];
-    if (!url) throw new Error(t("errors.OSNotSupported", { os }));
-
-    fs.mkdirSync(tmpDir, { recursive: true });
-
-    const res = await fetch(url);
-    if (!res.ok) throw new Error(`HTTP ${res.status}`);
-
-    const expected = Number(res.headers.get("content-length"));
-    let received   = 0;
-    const frames   = ["|","/","-","\\"];
-    let frame      = 0;
-    let spinner;
-
-    const file = fs.createWriteStream(tmpPath);
-
-    spinner = setInterval(() => {
-      const pct = expected
-        ? ` ${Math.floor((received / expected) * 100)}%`
-        : ` ${(received / 1024 / 1024).toFixed(1)}MB`;
-      process.stderr.write(`\r${frames[frame++ % frames.length]} Baixando Chrome...${pct}`);
-    }, 80);
-
-    const counter = new Transform({
-      transform(chunk, _enc, cb) {
-        received += chunk.length;
-        cb(null, chunk);
-      }
-    });
-
-    try {
-      await pipeline(
-        Readable.fromWeb(res.body),
-        counter,
-        file
-      );
-    } finally {
-      clearInterval(spinner);
-      process.stderr.write("\r\x1b[2K");
-    }
-
-    if (expected && received !== expected) {
-      throw new Error("Download incompleto");
-    }
-
-    await extract({ file: tmpPath, cwd: CONFIG_DIR, gzip: true });
-  } catch (err) {
-    throw new Error(t("errors.couldNotDownloadChrome") + err.message);
-  }
-
-}
-export const { Client, LocalAuth, MessageMedia } = pkg;
-
-// -- Instance --------------------------------------------------
-const clientOptions = {
-  authStrategy: new LocalAuth({
-    clientId: CLIENT_ID,
-    dataPath: DATA_PATH
-  }),
-  puppeteer: {
-    executablePath: chrome,
-    headless: true,
-    args: [
-      '--no-sandbox',
-      '--disable-setuid-sandbox'
-    ],
-  },
-};
-
-// -- Qr Handle --------------------------------------------------
-export function handleQR(qr) {
-  logger.info(t("system.qrScan"));
-  qrcode.generate(qr, { small: true });
-}
-
-// -- Handle pairing code ---------------------------------------
-export function handlePairingCode(code) {
-  logger.info(t("system.pairingCodeTitle"));
-  logger.info(t("system.pairingCodeValue", { code: code }));
-  logger.info(t("system.pairingCodeInstructions"));
-}
-
-// -- Phone Number Validation ------------------------------------
-const AUTH_STATE_PATH = path.join(__dirname, `../../.auth_${CLIENT_ID}.json`);
-
-// Validates if phone string has 10-15 characters
-function isValidPhoneNumber(phone) {
-  if (!phone || typeof phone !== 'string') return false;
-  const phoneRegex = /^\d{10,15}$/;
-  return phoneRegex.test(phone);
-}
-
-// Checks if phone number changed since last authentication
-function hasPhoneNumberChanged(currentPhone) {
-  try {
-    if (!fs.existsSync(AUTH_STATE_PATH)) return false;
-    const state = JSON.parse(fs.readFileSync(AUTH_STATE_PATH, 'utf8'));
-    const storedPhone = state.phoneNumber || null;
-    return storedPhone !== currentPhone;
-  } catch {
-    return false;
-  }
-}
-
-// Saves phone number to auth state file
-function savePhoneNumber(phone) {
-  try {
-    fs.writeFileSync(AUTH_STATE_PATH, JSON.stringify({ phoneNumber: phone, savedAt: new Date().toISOString() }));
-  } catch {
-    return false;
-  }
-}
-
-// Check if phone number changed and force re-authentication if needed
-if (PHONE_NUMBER && hasPhoneNumberChanged(PHONE_NUMBER)) {
-  // Delete auth folder to force fresh authentication
-  const authPath = path.join(__dirname, `../../.wwebjs_auth/session-${CLIENT_ID}`);
-  if (fs.existsSync(authPath)) {
-    fs.rmSync(authPath, { recursive: true, force: true });
-  }
-} 
-
-// Add phone number pairing if PHONE_NUMBER is configured and valid
-if (PHONE_NUMBER) {
-  if (isValidPhoneNumber(PHONE_NUMBER)) {
-    clientOptions.pairWithPhoneNumber = {
-      phoneNumber: PHONE_NUMBER,
-      showNotification: true,
-    };
-  }
-  savePhoneNumber(PHONE_NUMBER);
-}
-
-export const client = new Client(clientOptions);
-
-
-export default client;

package/src/config.js

@@ -1,288 +0,0 @@
-/**
- * config.js
- *
- * Loads config from up to four files, merged in strict precedence order:
- *
- *   defaults  <  legacy .conf  <  TOML
- *
- * Legacy files (frozen — no new keys):
- *   ~/.manybot/manybot.conf
- *   ~/.manybot/manyplug.conf
- *
- * TOML files (all new features go here):
- *   ~/.manybot/manybot.toml
- *   ~/.manybot/manyplug.toml
- *
- * The final CONFIG object always has the same shape regardless of which
- * files are present. Plugins must never see a structural difference.
- */
-
-import fs from "fs/promises";
-import os from "os";
-import path from "path";
-import { parse as parseToml } from "smol-toml";
-import { logger } from "#logger";
-
-// ---------------------------------------------------------------------------
-// Paths
-// ---------------------------------------------------------------------------
-
-export const CONFIG_DIR       = path.join(os.homedir(), ".manybot");
-
-/** @deprecated Use TOML_CONFIG_FILE. Frozen — no new keys. */
-export const CONFIG_FILE      = path.join(CONFIG_DIR, "manybot.conf");
-/** @deprecated Use TOML_PLUGIN_FILE. Frozen — no new keys. */
-export const PLUGIN_FILE      = path.join(CONFIG_DIR, "manyplug.conf");
-
-export const TOML_CONFIG_FILE = path.join(CONFIG_DIR, "manybot.toml");
-export const TOML_PLUGIN_FILE = path.join(CONFIG_DIR, "manyplug.toml");
-
-// ---------------------------------------------------------------------------
-// Legacy .conf parser (frozen — do not extend)
-// ---------------------------------------------------------------------------
-
-function parseValue(value) {
-  value = value.trim();
-  if (
-    (value.startsWith('"') && value.endsWith('"')) ||
-    (value.startsWith("'") && value.endsWith("'"))
-  ) {
-    value = value.slice(1, -1);
-  }
-  if (value === "true")  return true;
-  if (value === "false") return false;
-  return value;
-}
-
-function stripInlineComment(line) {
-  let result = "";
-  let quote  = null;
-  for (let i = 0; i < line.length; i++) {
-    const ch = line[i];
-    if ((ch === '"' || ch === "'") && line[i - 1] !== "\\") {
-      if (quote === ch)   quote = null;
-      else if (!quote)    quote = ch;
-    }
-    if (ch === "#" && !quote) break;
-    result += ch;
-  }
-  return result.trim();
-}
-
-function parseConf(raw) {
-  const lines       = raw.split(/\r?\n/);
-  const mergedLines = [];
-  let insideList    = false;
-  let buffer        = "";
-
-  for (let line of lines) {
-    line = stripInlineComment(line);
-    if (!line) continue;
-
-    if (!insideList) {
-      if (/=\s*\[$/.test(line)) {
-        insideList = true;
-        buffer     = line;
-      } else {
-        mergedLines.push(line);
-      }
-    } else {
-      buffer += " " + line;
-      if (line.includes("]")) {
-        mergedLines.push(buffer);
-        buffer     = "";
-        insideList = false;
-      }
-    }
-  }
-
-  const config = {};
-  for (const line of mergedLines) {
-    const idx = line.indexOf("=");
-    if (idx === -1) continue;
-    const key   = line.slice(0, idx).trim();
-    let   value = line.slice(idx + 1).trim();
-
-    if (value.startsWith("[") && value.endsWith("]")) {
-      config[key] = value
-        .slice(1, -1)
-        .split(",")
-        .map(v  => parseValue(v))
-        .filter(v => v !== "");
-      continue;
-    }
-    config[key] = parseValue(value);
-  }
-  return config;
-}
-
-// ---------------------------------------------------------------------------
-// TOML migration
-// ---------------------------------------------------------------------------
-
-function escapeTomlString(s) {
-  return s
-    .replaceAll("\\", "\\\\")
-    .replaceAll('"', '\\"');
-}
-
-function toToml(obj) {
-  return Object.entries(obj)
-    .map(([k, v]) => {
-      if (Array.isArray(v))
-        return `${k} = [${v.map(JSON.stringify).join(", ")}]`;
-
-      if (v == null || v === "")
-        return `${k} = ""`;
-
-      return typeof v === "string"
-        ? `${k} = "${escapeTomlString(v)}"`
-        : `${k} = ${v}`;
-    })
-    .join("\n") + "\n";
-}
-
-async function migrateLegacyIfNeeded() {
-  if (await fileExists(TOML_CONFIG_FILE))
-    return;
-
-  const migrate = async (src, dest, omit = []) => {
-    const raw = await readFileSafe(src);
-    if (!raw) return false;
-
-    const cfg = parseConf(raw);
-
-    for (const k of omit)
-      delete cfg[k];
-
-    await fs.writeFile(dest, toToml(cfg), "utf8");
-    await fs.rename(src, `${src}.bak`);
-
-    return true;
-  };
-
-  const migrated =
-    await migrate(CONFIG_FILE, TOML_CONFIG_FILE, ["PLUGINS"]) ||
-    await migrate(PLUGIN_FILE, TOML_PLUGIN_FILE);
-
-  if (migrated)
-    logger.success("Config migrated to TOML");
-}
-
-// ---------------------------------------------------------------------------
-// File helpers
-// ---------------------------------------------------------------------------
-
-async function fileExists(file) {
-  try   { await fs.stat(file); return true; }
-  catch { return false; }
-}
-
-async function readFileSafe(file) {
-  try {
-    return await fs.readFile(file, "utf-8");
-  } catch (err) {
-    if (err.code !== "ENOENT") logger.warn(`Error reading ${file}: ${err.message}`);
-    return null;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Bootstrap: ensure at least one config file exists
-// ---------------------------------------------------------------------------
-
-const DEFAULT_TOML =
-`# ManyBot configuration file
-# See https://manybot.stxerr.dev/docs/config to learn more
-
-CLIENT_ID    = "manybot"
-CMD_PREFIX   = "!"
-CHATS        = []
-LANGUAGE     = "en"
-PHONE_NUMBER = ""
-`;
-
-await fs.mkdir(CONFIG_DIR, { recursive: true });
-
-await migrateLegacyIfNeeded();
-
-if (!await fileExists(TOML_CONFIG_FILE)) {
-  logger.warn(`Creating ${TOML_CONFIG_FILE}`);
-  await fs.writeFile(TOML_CONFIG_FILE, DEFAULT_TOML);
-}
-
-// ---------------------------------------------------------------------------
-// Layer 1 — tOML
-// ---------------------------------------------------------------------------
-
-const legacyLayer = {};
-
-// ---------------------------------------------------------------------------
-// Layer 2 — TOML  (all new features land here)
-// ---------------------------------------------------------------------------
-
-let tomlLayer = {};
-
-async function loadToml(file, label) {
-  const raw = await readFileSafe(file);
-  if (raw === null) return {};
-  try {
-    return parseToml(raw);
-  } catch (err) {
-    logger.warn(`Error parsing ${label}: ${err.message}`);
-    return {};
-  }
-}
-
-tomlLayer = {
-  ...await loadToml(TOML_CONFIG_FILE, "manybot.toml"),
-  ...await loadToml(TOML_PLUGIN_FILE, "manyplug.toml"),
-};
-
-// ---------------------------------------------------------------------------
-// Merge + normalize
-//
-// Normalization runs once on the final merged object so both legacy and TOML
-// layers are treated identically. Add new normalization rules here only.
-// ---------------------------------------------------------------------------
-
-const DEFAULTS = {
-  CMD_PREFIX:   "!",
-  CLIENT_ID:    "manybot",
-  CHATS:        [],
-  PLUGINS:      [],
-  LANGUAGE:     "en",
-  PHONE_NUMBER: null,
-};
-
-function normalize(cfg) {
-  // Empty string and absent PHONE_NUMBER are both treated as null so plugins
-  // can always do a simple truthiness check regardless of config source.
-  if (cfg.PHONE_NUMBER === "") cfg.PHONE_NUMBER = null;
-  return cfg;
-}
-
-export const CONFIG = normalize({
-  ...DEFAULTS,
-  ...legacyLayer, // legacy .conf overrides defaults
-  ...tomlLayer,   // TOML overrides legacy .conf
-});
-
-// ---------------------------------------------------------------------------
-// Named exports — identical shape regardless of config source
-// ---------------------------------------------------------------------------
-
-export const CLIENT_ID    = CONFIG.CLIENT_ID;
-export const CMD_PREFIX   = CONFIG.CMD_PREFIX;
-export const CHATS        = CONFIG.CHATS;
-export const PLUGINS      = CONFIG.PLUGINS;
-export const LANGUAGE     = CONFIG.LANGUAGE;
-export const PHONE_NUMBER = CONFIG.PHONE_NUMBER;
-
-export const PATHS = {
-  HOME:            CONFIG_DIR,
-  CONFIG_FILE,
-  PLUGIN_FILE,
-  TOML_CONFIG_FILE,
-  TOML_PLUGIN_FILE,
-};

package/src/download/queue.js

@@ -1,55 +0,0 @@
-/**
- * src/download/queue.js
- *
- * Sequential execution queue for heavy jobs (downloads, conversions).
- * Ensures only one job runs at a time — without overloading yt-dlp or ffmpeg.
- *
- * Plugin passes a `workFn` that does everything: download, convert, send.
- * Queue only handles sequence and error handling.
- *
- * Usage:
- *   import { enqueue } from "../../src/download/queue.js";
- *   enqueue(async () => { ... all plugin logic ... }, onError);
- */
-
-import { logger } from "#logger";
-import { t }      from "#i18n";
-
-/**
- * @typedef {{
- *   workFn:   () => Promise<void>,
- *   errorFn:  (err: Error) => Promise<void>,
- * }} Job
- */
-
-/** @type {Job[]} */
-let queue = [];
-let processing = false;
-
-/**
- * Add job to queue and start processing if idle.
- *
- * @param {Function} workFn   — async () => void  — all plugin logic
- * @param {Function} errorFn  — async (err) => void  — called if workFn throws
- */
-export function enqueue(workFn, errorFn) {
-  queue.push({ workFn, errorFn });
-  if (!processing) processQueue();
-}
-
-async function processQueue() {
-  processing = true;
-  while (queue.length) {
-    await processJob(queue.shift());
-  }
-  processing = false;
-}
-
-async function processJob({ workFn, errorFn }) {
-  try {
-    await workFn();
-  } catch (err) {
-    logger.error(t("system.downloadJobFailed", { message: err.message }));
-    try { await errorFn(err); } catch { }
-  }
-}