@manybot/manybot 5.1.0 → 5.2.1

package/src/kernel/pluginLoader.js

@@ -1,177 +0,0 @@
-/**
- * pluginLoader.js
- *
- * Responsible for:
- *   1. Reading active plugins (config.js imports this module and give the list)
- *   2. Loading each plugin from ~/.manybot/plugins folder
- *   3. Registering in pluginRegistry with status and public exports
- *   4. Exposing pluginRegistry to kernel and pluginApi
- *
- */
-
-import fs                from "fs";
-import path              from "path";
-import { logger }        from "#logger";
-import { t }             from "#i18n";
-import { pathToFileURL } from "url";
-import { PATHS }         from "#config";
-import { buildSetupApi } from "#manyapi";
-
-const PLUGINS_DIR = path.join(PATHS.HOME, "plugins");
-
-/**
- * Each entry in registry:
- * {
- *   name:    string,
- *   status:  "active" | "disabled" | "error",
- *   run:     async function({ msg, chat, api }) — plugin default function
- *   exports: any — what plugin exposed via `export const api = { ... }`
- *   error:   Error | null
- * }
- *
- * @type {Map<string, object>}
- */
-export const pluginRegistry = new Map();
-
-/**
- * Load all active plugins listed in `activePlugins`.
- * Called once during bot initialization.
- *
- * @param {string[]} activePlugins — active plugin names (from .conf)
- */
-export async function loadPlugins(activePlugins) {
-  if (!fs.existsSync(PLUGINS_DIR)) {
-    fs.mkdirSync(PLUGINS_DIR, { recursive: true });
-  }
-
-  for (const name of activePlugins) {
-    await loadPlugin(name);
-  }
-
-  const total   = pluginRegistry.size;
-  const ativos  = [...pluginRegistry.values()].filter(p => p.status === "active").length;
-  const erros   = total - ativos;
-
-  logger.success(t("system.pluginsLoaded", {
-    count: ativos,
-    errors: erros ? t("system.pluginsLoadedWithErrors", { count: erros }) : ""
-  }));
-}
-
-/**
- * Call setup(api) on all plugins that export it.
- * Executed once after bot connects to WhatsApp.
- *
- * @param {object} api — api without message context (only sendTo, log, schedule...)
- */
-export async function setupPlugins(client) {
-  for (const plugin of pluginRegistry.values()) {
-    if (plugin.status !== "active" || !plugin.setup)
-      continue;
-  
-    try {
-      const api = buildSetupApi(
-        client,
-        pluginRegistry,
-        plugin.name
-      );
-  
-      await plugin.setup(api);
-  
-    } catch (err) {
-      logger.error(
-        t("system.pluginSetupFailed", {
-          name: plugin.name,
-          message: err.message
-        })
-      );
-    }
-  }
-}
-
-async function findPluginPath(name) {
-  const dir = path.join(PLUGINS_DIR, name);
-  const manifest = path.join(dir, "manyplug.json");
-
-  if (!fs.existsSync(manifest))
-    return null;
-
-  const { main = "index.js" } =
-    JSON.parse(
-      await fs.promises.readFile(
-        manifest,
-        "utf8"
-      )
-    );
-
-  const entry =
-    path.join(
-      dir,
-      main
-    );
-
-  return (
-    fs.existsSync(entry)
-      ? entry
-      : null
-  );
-}
-
-/**
- * Carrega um único plugin pelo nome.
- * @param {string} name
- */
-async function loadPlugin(name) {
-  const pluginPath = await findPluginPath(name);
-  if (!pluginPath) {
-    logger.warn(t("system.pluginNotFound", { name, path: path.join(PLUGINS_DIR, name) }));
-    pluginRegistry.set(name, { name, status: "disabled", run: null, exports: null, error: null });
-    return;
-  }
-
-  if (!fs.existsSync(pluginPath)) {
-    logger.warn(t("system.pluginNotFound", { name, path: pluginPath }));
-    pluginRegistry.set(name, { name, status: "disabled", run: null, exports: null, error: null });
-    return;
-  }
-
-  try {
-    const mod = await import(pathToFileURL(pluginPath).href);
-
-    // Plugin must export a default function — this is called on every message
-    if (typeof mod.default !== "function") {
-      throw new Error(`Plugin "${name}" does not export a default function`);
-    }
-
-    pluginRegistry.set(name, {
-      name,
-      status:  "active",
-      run:     mod.default,
-      setup:   mod.setup ?? null,
-      exports: mod.api ?? null,
-      error:   null,
-      guardOptions: mod.guardOptions ?? {},
-    });
-
-    logger.info(t("system.pluginLoaded", { name }));
-  } catch (err) {
-    logger.error(t("system.pluginLoadFailed", { name, message: err.message }));
-    pluginRegistry.set(name, { name, status: "error", run: null, exports: null, error: err });
-  }
-}
-
-export async function cleanupPlugins() {
-  for (const plugin of pluginRegistry.values()) {
-    try {
-      await plugin.exports?.events?.cleanup?.();
-
-    } catch (err) {
-      logger.error(
-        t("system.pluginCleanupFailed", {
-          name: plugin.name,
-          message: err.message
-        })
-      );
-    }
-  }
-}

package/src/kernel/pluginState.js

@@ -1,99 +0,0 @@
-/**
- * pluginState.js
- *
- * Tracks plugin execution state per chat.
- * Used to implement the service vs non-service behavior:
- * - Services (service: true) can run regardless of state
- * - Non-services are blocked when another plugin is running in the same chat
- */
-
-import { logger } from "#logger";
-
-/**
- * Map<chatId, { pluginName: string, startedAt: Date }>
- * Tracks which plugin is currently "holding the lock" in each chat
- */
-const runningPlugins = new Map();
-
-/**
- * Check if any plugin is currently running in a specific chat
- * @param {string} chatId - Chat ID (serialized)
- * @returns {boolean}
- */
-export function isPluginRunning(chatId) {
-  return runningPlugins.has(chatId);
-}
-
-/**
- * Get info about the plugin running in a chat
- * @param {string} chatId - Chat ID (serialized)
- * @returns {{ pluginName: string, startedAt: Date } | null}
- */
-export function getRunningPlugin(chatId) {
-  return runningPlugins.get(chatId) ?? null;
-}
-
-/**
- * Mark a plugin as running in a chat
- * @param {string} chatId - Chat ID (serialized)
- * @param {string} pluginName - Name of the plugin taking the lock
- */
-export function startPluginRun(chatId, pluginName) {
-  runningPlugins.set(chatId, {
-    pluginName,
-    startedAt: new Date()
-  });
-  logger.debug(`Plugin "${pluginName}" started in chat ${chatId}`);
-}
-
-/**
- * Mark a plugin as finished in a chat
- * @param {string} chatId - Chat ID (serialized)
- * @param {string} pluginName - Name of the plugin releasing the lock
- */
-export function endPluginRun(chatId, pluginName) {
-  const current = runningPlugins.get(chatId);
-  if (current && current.pluginName === pluginName) {
-    runningPlugins.delete(chatId);
-    logger.debug(`Plugin "${pluginName}" ended in chat ${chatId}`);
-  }
-}
-
-/**
- * Force clear the running state for a chat
- * Useful for cleanup or admin commands
- * @param {string} chatId - Chat ID (serialized)
- */
-export function clearPluginRun(chatId) {
-  runningPlugins.delete(chatId);
-}
-
-/**
- * Get all chats where a specific plugin is running
- * @param {string} pluginName - Plugin name
- * @returns {string[]} Array of chat IDs
- */
-export function getChatsWithPlugin(pluginName) {
-  const chats = [];
-  for (const [chatId, info] of runningPlugins.entries()) {
-    if (info.pluginName === pluginName) {
-      chats.push(chatId);
-    }
-  }
-  return chats;
-}
-
-/**
- * Get stats about running plugins
- * @returns {{ total: number, byPlugin: Record<string, number> }}
- */
-export function getStats() {
-  const byPlugin = {};
-  for (const info of runningPlugins.values()) {
-    byPlugin[info.pluginName] = (byPlugin[info.pluginName] || 0) + 1;
-  }
-  return {
-    total: runningPlugins.size,
-    byPlugin
-  };
-}

package/src/kernel/scheduler.js

@@ -1,48 +0,0 @@
-/**
- * scheduler.js
- *
- * Allows plugins to register scheduled tasks via cron.
- * Uses node-cron underneath, but plugins never import node-cron directly —
- * they only call api.schedule(cron, fn).
- *
- * Usage in plugin:
- *   import { schedule } from "many";
- *   schedule("0 9 * * 1", async () => { await api.send("Good morning!"); });
- */
-
-import cron   from "node-cron";
-import { logger } from "#logger";
-import { t }      from "#i18n";
-
-/** List of active tasks (for eventual teardown) */
-const tasks = [];
-
-/**
- * Register a cron task.
- * @param {string}   expression  — cron expression e.g., "0 9 * * 1"
- * @param {Function} fn          — async function to execute
- * @param {string}   pluginName  — plugin name (for logging)
- */
-export function schedule(expression, fn, pluginName = "unknown") {
-  if (!cron.validate(expression)) {
-    logger.warn(t("system.schedulerInvalidCron", { name: pluginName, expression }));
-    return;
-  }
-
-  const task = cron.schedule(expression, async () => {
-    try {
-      await fn();
-    } catch (err) {
-      logger.error(t("system.schedulerError", { name: pluginName, message: err.message }));
-    }
-  });
-
-  tasks.push({ pluginName, expression, task });
-  logger.info(t("system.schedulerRegistered", { name: pluginName, expression }));
-}
-
-/** Stop all schedules (useful for shutdown) */
-export function stopAll() {
-  tasks.forEach(({ task }) => task.stop());
-  tasks.length = 0;
-}

package/src/kernel/sendGuard.js

@@ -1,166 +0,0 @@
-/**
- * sendGuard.js
- *
- * Anti-detection throttle layer for all outbound sends.
- *
- * Three protections applied before every message:
- *   1. Global token bucket  — hard cap on messages/second across all chats
- *   2. Per-chat cooldown    — minimum gap between sends to the same chat
- *   3. Human jitter         — random delay to break robotic timing patterns
- *
- * Text sends also simulate the typing indicator so the chat shows
- * "typing…" for a realistic duration before the message arrives.
- */
-
-import { logger } from "#logger";
-
-// ── Tunables ──────────────────────────────────────────────────────────────────
-// Adjust conservatively — WhatsApp is more sensitive to burst than average rate.
-
-/** Hard cap: max messages per second, globally (across all chats). */
-const GLOBAL_MSG_PER_SEC = 3;
-
-/** Minimum ms between two sends to the same chat. */
-const CHAT_COOLDOWN_MS = 900;
-
-/** Random jitter window added before every send (ms). */
-const JITTER_MS = { min: 400, max: 1400 };
-
-/** Typing speed used to calculate indicator duration (chars/sec). */
-const TYPING_CPS = 55;
-
-/** Upper cap on typing simulation, regardless of message length. */
-const TYPING_MAX_MS = 4500;
-
-/** Fixed indicator duration for media sends (ms), before jitter. */
-const MEDIA_INDICATOR_MS = { min: 800, max: 2000 };
-
-// ── Global token bucket ───────────────────────────────────────────────────────
-
-const MS_PER_TOKEN = 1000 / GLOBAL_MSG_PER_SEC;
-
-let tokens     = GLOBAL_MSG_PER_SEC;
-let lastRefill = Date.now();
-
-/**
- * Consume one send token.
- * Returns the number of ms to wait if no token is available (0 = proceed now).
- */
-function consumeGlobalToken() {
-  const now     = Date.now();
-  const elapsed = now - lastRefill;
-
-  tokens     = Math.min(GLOBAL_MSG_PER_SEC, tokens + elapsed / MS_PER_TOKEN);
-  lastRefill = now;
-
-  if (tokens >= 1) {
-    tokens -= 1;
-    return 0;
-  }
-
-  return Math.ceil((1 - tokens) * MS_PER_TOKEN);
-}
-
-// ── Per-chat cooldown ─────────────────────────────────────────────────────────
-
-/** chatId → timestamp of the last outbound send */
-const lastSentAt = new Map();
-
-function chatCooldownMs(chatId) {
-  const last = lastSentAt.get(chatId) ?? 0;
-  const wait = last + CHAT_COOLDOWN_MS - Date.now();
-  return wait > 0 ? wait : 0;
-}
-
-function recordSend(chatId) {
-  lastSentAt.set(chatId, Date.now());
-}
-
-// ── Helpers ───────────────────────────────────────────────────────────────────
-
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-
-function randomJitter() {
-  return JITTER_MS.min + Math.random() * (JITTER_MS.max - JITTER_MS.min);
-}
-
-
-/**
- * How long the typing indicator should appear before sending text.
- * Based on simulated typing speed, capped at TYPING_MAX_MS.
- * @param {string} text
- * @returns {number} ms
- */
-export function typingDuration(text) {
-  if (typeof text !== "string" || text.length === 0) return 0;
-  return Math.min((text.length / TYPING_CPS) * 1000, TYPING_MAX_MS);
-}
-
-/**
- * A human-feeling duration for media "processing" indicator.
- * Randomized so repeated sends don't have identical pauses.
- * @returns {number} ms
- */
-export function mediaDuration() {
-  return MEDIA_INDICATOR_MS.min
-    + Math.random() * (MEDIA_INDICATOR_MS.max - MEDIA_INDICATOR_MS.min);
-}
-
-// ── Public API ────────────────────────────────────────────────────────────────
-
-/**
- * Wait for a safe send slot: global rate → per-chat cooldown → jitter.
- * Must be called before every outbound message.
- *
- * @param {string} chatId
- * @param {object} [opts]
- * @param {boolean} [opts.cooldown=true]  — set to `false` to skip per-chat cooldown.
- *                                          Use for plugins that reply instantly and
- *                                          don't benefit from anti-detection pacing
- *                                          (e.g. sticker). Global rate limit is kept.
- * @param {boolean} [opts.jitter=true]    — set to `false` to skip random jitter delay.
- */
-export async function waitForSendSlot(chatId, { cooldown = true, jitter = true } = {}) {
-  const tokenWait = consumeGlobalToken();
-  if (tokenWait > 0) {
-    logger.debug(`[sendGuard] global rate hit — queuing ${tokenWait}ms`);
-    await sleep(tokenWait);
-  }
-
-  if (cooldown) {
-    const coolWait = chatCooldownMs(chatId);
-    if (coolWait > 0) {
-      logger.debug(`[sendGuard] chat cooldown (${chatId}) — waiting ${coolWait}ms`);
-      await sleep(coolWait);
-    }
-  }
-
-  if (jitter) {
-    await sleep(randomJitter());
-  }
-
-  recordSend(chatId);
-}
-
-/**
- * Show a WhatsApp presence indicator for `ms` milliseconds, then clear it.
- * Best-effort — errors are swallowed so they never break a send.
- *
- * @param {import("whatsapp-web.js").Chat} chat
- * @param {number}                         ms
- * @param {"typing"|"recording"}           [state="typing"]
- */
-export async function simulateState(chat, ms, state = "typing") {
-  if (!chat || ms <= 0) return;
-  try {
-    if (state === "recording") {
-      await chat.sendStateRecording();
-    } else {
-      await chat.sendStateTyping();
-    }
-    await sleep(ms);
-    await chat.clearState();
-  } catch (err) {
-    logger.debug(`[sendGuard] state simulation failed (non-fatal): ${err.message}`);
-  }
-}

package/src/locales/es.json

@@ -1,62 +0,0 @@
-{
-  "bot": {
-    "starting": "Iniciando ManyBot...",
-    "initialized": "Cliente inicializado. Esperando conexión con WhatsApp...",
-    "ready": "¡Bot está listo!",
-    "error": {
-      "uncaught": "Excepción no capturada",
-      "unhandled": "Rechazo no manejado"
-    },
-    "signal": {
-      "sigterm": "Proceso interrumpida. Apagando..."
-    }
-  },
-  "log": {
-    "info": "INFO",
-    "success": "OK",
-    "warn": "WARN",
-    "error": "ERROR",
-    "msg": "MSG",
-    "cmd": "CMD",
-    "done": "DONE",
-    "context": {
-      "group": "grupo",
-      "from": "De",
-      "type": "Tipo",
-      "replyTo": "Responde a"
-    }
-  },
-  "system": {
-    "environment": "Entorno: {{platform}} — usando {{puppeteer}}",
-    "environmentTermux": "Entorno: Termux — usando Chromium del sistema",
-    "connected": "¡WhatsApp conectado y listo!",
-    "disconnected": "Desconectado — motivo: {{reason}}",
-    "reconnecting": "Reconectando en {{seconds}}s...",
-    "reinitializing": "Reinicializando cliente...",
-    "qrSaved": "Código QR guardado en: {{path}}",
-    "qrOpen": "Abrir con: termux-open qr.png",
-    "qrSaveFailed": "Error al guardar el Código QR:",
-    "qrScan": "Escanea el Código QR abajo:",
-    "clientId": "Client ID: {{id}}",
-    "pluginsFolderNotFound": "Carpeta de plugins no encontrada. Ningún plugin cargado.",
-    "pluginsLoaded": "Plugins cargados: {{count}} activos{{errors}}",
-    "pluginsLoadedWithErrors": ", {{count}} con error",
-    "pluginSetupFailed": "Error en la configuración del plugin \"{{name}}\": {{message}}",
-    "pluginNotFound": "Plugin \"{{name}}\" no encontrado en {{path}}",
-    "pluginLoaded": "Plugin cargado: {{name}}",
-    "pluginLoadFailed": "Error al cargar el plugin \"{{name}}\": {{message}}",
-    "pluginDisabledAfterError": "Plugin \"{{name}}\" desactivado después del error: {{message}}",
-    "schedulerInvalidCron": "Plugin \"{{name}}\" registró expresión cron inválida: \"{{expression}}\"",
-    "schedulerError": "Error en la programación del plugin \"{{name}}\": {{message}}",
-    "schedulerRegistered": "Programación registrada — plugin \"{{name}}\" → \"{{expression}}\"",
-    "downloadJobFailed": "Error en el trabajo de descarga — {{message}}"
-  },
-  "errors": {
-    "pluginLoad": "Error al cargar el plugin",
-    "messageProcess": "Error al procesar el mensaje",
-    "stack": "Stack",
-    "chromeNotFound": "No se ha encontrado Chrome. Descargando...",
-    "couldNotDownloadChrome": "No se ha podido descargar Chrome: ",
-    "OSNotSupported": "Sistema operativo no compatible: {{os}}. Si tienes alguna duda, consulta: https://manybot.stxerr.dev/docs/getting-started/"
-  }
-}

package/src/logger/logger.js

@@ -1,32 +0,0 @@
-const c = {
-  reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
-  green: "\x1b[32m", yellow: "\x1b[33m", cyan: "\x1b[36m",
-  red: "\x1b[31m", gray: "\x1b[90m", white: "\x1b[37m",
-  blue: "\x1b[34m", magenta: "\x1b[35m",
-};
-
-/**
- * ManyBot central logger.
- * Each method only handles output — no business logic or external I/O.
- */
-export const logger = {
-  info:    (...a) => console.log(`${c.cyan  }INFO  ${c.reset}`, ...a),
-  success: (...a) => console.log(`${c.green }OK    ${c.reset}`, ...a),
-  warn:    (...a) => console.log(`${c.yellow}WARN  ${c.reset}`, ...a),
-  error:   (...a) => console.log(`${c.red   }ERROR ${c.reset}`, ...a),
-  debug:   (...a) => console.log(`${c.blue  }DEBUG ${c.reset}`, ...a),
-
-  cmd: (cmd, extra = "") =>
-    console.log(
-      `${c.gray}${now()}${c.reset}${c.yellow}CMD    ${c.reset}` +
-      `${c.bold}${cmd}${c.reset}` +
-      (extra ? `  ${c.dim}${extra}${c.reset}` : "")
-    ),
-
-  done: (cmd, detail = "") =>
-    console.log(
-      `${c.gray}${now()}${c.reset}${c.green}DONE   ${c.reset}` +
-      `${c.dim}${cmd}${c.reset}` +
-      (detail ? ` — ${detail}` : "")
-    ),
-};