@manybot/manybot 4.0.1

package/src/kernel/pluginLoader.js

@@ -0,0 +1,112 @@
+/**
+ * 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";
+
+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(api) {
+  for (const plugin of pluginRegistry.values()) {
+    if (plugin.status !== "active" || !plugin.setup) continue;
+    try {
+      await plugin.setup(api);
+    } catch (err) {
+      logger.error(t("system.pluginSetupFailed", { name: plugin.name, message: err.message }));
+    }
+  }
+}
+
+/**
+ * Carrega um único plugin pelo nome.
+ * @param {string} name
+ */
+async function loadPlugin(name) {
+  const pluginPath = path.join(PLUGINS_DIR, name, "index.js");
+
+  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,     // opcional — chamado uma vez na inicialização
+      exports: mod.api ?? null,
+      error:   null,
+    });
+
+    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 });
+  }
+}

package/src/kernel/pluginState.js

@@ -0,0 +1,99 @@
+/**
+ * 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

@@ -0,0 +1,48 @@
+/**
+ * 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/locales/en.json

@@ -0,0 +1,64 @@
+{
+  "bot": {
+    "starting": "Starting ManyBot...",
+    "initialized": "Client initialized. Waiting for WhatsApp connection...",
+    "ready": "Bot is ready!",
+    "error": {
+      "uncaught": "Uncaught exception",
+      "unhandled": "Unhandled rejection"
+    },
+    "signal": {
+      "sigterm": "Process interrupted. Shutting down..."
+    }
+  },
+  "log": {
+    "info": "INFO",
+    "success": "OK",
+    "warn": "WARN",
+    "error": "ERROR",
+    "msg": "MSG",
+    "cmd": "CMD",
+    "done": "DONE",
+    "context": {
+      "group": "group",
+      "from": "From",
+      "type": "Type",
+      "replyTo": "replies to"
+    }
+  },
+  "system": {
+    "environment": "Environment: {{platform}} — using {{puppeteer}}",
+    "environmentTermux": "Environment: Termux — using system Chromium",
+    "connected": "WhatsApp connected and ready!",
+    "disconnected": "Disconnected — reason: {{reason}}",
+    "reconnecting": "Reconnecting in {{seconds}}s...",
+    "reinitializing": "Reinitializing client...",
+    "qrSaved": "QR Code saved to: {{path}}",
+    "qrOpen": "Open with: termux-open qr.png",
+    "qrSaveFailed": "Failed to save QR Code:",
+    "qrScan": "Scan the QR Code below:",
+    "pairingCodeTitle": "Pairing code:",
+    "pairingCodeValue": "→ {{code}} ←",
+    "pairingCodeInstructions": "Enter this code in WhatsApp: Menu → Linked devices → Link with phone number",
+    "phoneNumberInvalid": "Invalid phone number: {{number}}. Expected format: 5511999999999 (country code + area code + number, no spaces or special characters)",
+    "phoneNumberChanged": "Phone number changed. Restarting authentication...",
+    "clientId": "Client ID: {{id}}",
+    "pluginsFolderNotFound": "Plugins folder not found. No plugins loaded.",
+    "pluginsLoaded": "Plugins loaded: {{count}} active{{errors}}",
+    "pluginsLoadedWithErrors": ", {{count}} with error",
+    "pluginSetupFailed": "Plugin \"{{name}}\" setup failed: {{message}}",
+    "pluginNotFound": "Plugin \"{{name}}\" not found at {{path}}",
+    "pluginLoaded": "Plugin loaded: {{name}}",
+    "pluginLoadFailed": "Failed to load plugin \"{{name}}\": {{message}}",
+    "pluginDisabledAfterError": "Plugin \"{{name}}\" disabled after error: {{message}}",
+    "schedulerInvalidCron": "Plugin \"{{name}}\" registered invalid cron expression: \"{{expression}}\"",
+    "schedulerError": "Plugin \"{{name}}\" scheduling error: {{message}}",
+    "schedulerRegistered": "Schedule registered — plugin \"{{name}}\" → \"{{expression}}\"",
+    "downloadJobFailed": "Download job failed — {{message}}"
+  },
+  "errors": {
+    "pluginLoad": "Failed to load plugin",
+    "messageProcess": "Failed to process message",
+    "stack": "Stack"
+  }
+}

package/src/locales/es.json

@@ -0,0 +1,59 @@
+{
+  "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"
+  }
+}

package/src/locales/pt.json

@@ -0,0 +1,64 @@
+{
+  "bot": {
+    "starting": "Iniciando ManyBot...",
+    "initialized": "Cliente inicializado. Aguardando conexão com WhatsApp...",
+    "ready": "Bot está pronto!",
+    "error": {
+      "uncaught": "Exceção não capturada",
+      "unhandled": "Rejeição não tratada"
+    },
+    "signal": {
+      "sigterm": "Processo interrompido. Desligando..."
+    }
+  },
+  "log": {
+    "info": "INFO",
+    "success": "OK",
+    "warn": "WARN",
+    "error": "ERRO",
+    "msg": "MSG",
+    "cmd": "CMD",
+    "done": "DONE",
+    "context": {
+      "group": "grupo",
+      "from": "De",
+      "type": "Tipo",
+      "replyTo": "Responde"
+    }
+  },
+  "system": {
+    "environment": "Ambiente: {{platform}} — usando {{puppeteer}}",
+    "environmentTermux": "Ambiente: Termux — usando Chromium do sistema",
+    "connected": "WhatsApp conectado e pronto!",
+    "disconnected": "Desconectado — motivo: {{reason}}",
+    "reconnecting": "Reconectando em {{seconds}}s...",
+    "reinitializing": "Reinicializando cliente...",
+    "qrSaved": "QR Code salvo em: {{path}}",
+    "qrOpen": "Abra com: termux-open qr.png",
+    "qrSaveFailed": "Falha ao salvar QR Code:",
+    "qrScan": "Escaneie o QR Code abaixo:",
+    "pairingCodeTitle": "Código de pareamento:",
+    "pairingCodeValue": "→ {{code}} ←",
+    "pairingCodeInstructions": "Digite este código no WhatsApp: Menu → Dispositivos conectados → Conectar com número de telefone",
+    "phoneNumberInvalid": "Número de telefone inválido: {{number}}. Formato esperado: 5511999999999 (código do país + DDD + número, sem espaços ou caracteres especiais)",
+    "phoneNumberChanged": "Número de telefone alterado. Reiniciando autenticação...",
+    "clientId": "Client ID: {{id}}",
+    "pluginsFolderNotFound": "Pasta de plugins não encontrada. Nenhum plugin carregado.",
+    "pluginsLoaded": "Plugins carregados: {{count}} ativos{{errors}}",
+    "pluginsLoadedWithErrors": ", {{count}} com erro",
+    "pluginSetupFailed": "Falha na configuração do plugin \"{{name}}\": {{message}}",
+    "pluginNotFound": "Plugin \"{{name}}\" não encontrado em {{path}}",
+    "pluginLoaded": "Plugin carregado: {{name}}",
+    "pluginLoadFailed": "Falha ao carregar plugin \"{{name}}\": {{message}}",
+    "pluginDisabledAfterError": "Plugin \"{{name}}\" desativado após erro: {{message}}",
+    "schedulerInvalidCron": "Plugin \"{{name}}\" registrou expressão cron inválida: \"{{expression}}\"",
+    "schedulerError": "Erro no agendamento do plugin \"{{name}}\": {{message}}",
+    "schedulerRegistered": "Agendamento registrado — plugin \"{{name}}\" → \"{{expression}}\"",
+    "downloadJobFailed": "Falha no job de download — {{message}}"
+  },
+  "errors": {
+    "pluginLoad": "Falha ao carregar plugin",
+    "messageProcess": "Falha ao processar mensagem",
+    "stack": "Stack"
+  }
+}

package/src/logger/logger.js

@@ -0,0 +1,31 @@
+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),
+
+  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}` : "")
+    ),
+};

package/src/main.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+
+/**
+ * main.js
+ *
+ * ManyBot entry point.
+ * Initializes WhatsApp client and loads plugins.
+ */
+
+import Module from "module";
+import path from "path";
+
+process.env.NODE_PATH = path.resolve(process.cwd(), "node_modules");
+Module._initPaths();
+
+import client, { handleQR, handlePairingCode } from "#client/whatsappClient";
+import { handleMessage }                       from "#kernel/messageHandler";
+import { loadPlugins, setupPlugins }           from "#kernel/pluginLoader";
+import { buildSetupApi }                       from "#manyapi";
+import { logger }                              from "#logger";
+import { PLUGINS }                             from "#config";
+import { t }                                   from "#i18n";
+import { printBanner }                         from "#client/banner";
+import { CLIENT_ID }                           from "#config";
+
+logger.info(t("bot.starting"));
+
+// Global safety net — no error should crash the bot
+process.on("uncaughtException", (err) => {
+  logger.error(`${t("bot.error.uncaught")} — ${err.message}`,
+    `\n             ${t("errors.stack")}: ${err.stack?.split("\n")[1]?.trim() ?? ""}`);
+});
+
+process.on("unhandledRejection", (reason) => {
+  const msg = reason instanceof Error ? reason.message : String(reason);
+  logger.error(`${t("bot.error.unhandled")} — ${msg}`);
+});
+
+// Clean shutdown
+process.on("SIGTERM", async () => {
+  logger.error(t("bot.signal.sigterm"));
+  process.exit(0);
+});
+
+let state = "BOOT";
+// BOOT → AUTH → SYNC → READY
+
+function setState(next) {
+  state = next;
+}
+
+client.on("loading_screen", (p, msg) => {
+  setState("SYNC");
+  logger.info(`loading ${p}% ${msg}`);
+});
+
+client.on("ready", async () => {
+  setState("READY_INIT");
+
+  logger.success(t("system.connected"));
+  logger.info(t("system.clientId", { id: CLIENT_ID }));
+
+  printBanner();
+
+  await loadPlugins(PLUGINS);
+  await setupPlugins(buildSetupApi(client));
+
+  // buffer anti-replay / sync ghost messages
+  setTimeout(() => {
+    setState("READY");
+  }, 2000);
+});
+
+client.on("message_create", async (msg) => {
+  if (state !== "READY") return;
+
+  if (!msg.body && !msg.hasMedia) return;
+
+  try {
+    await handleMessage(msg);
+  } catch (err) {
+    logger.error(err);
+  }
+});
+
+client.on("disconnected", (reason) => {
+  logger.warn(t("system.disconnected", { reason }));
+  logger.info(t("system.reconnecting", { seconds: 5 }));
+  setTimeout(() => {
+    logger.info(t("system.reinitializing"));
+    client.initialize();
+  }, 5000);
+});
+
+// -- Events ----------------------------------------------------
+client.on("code", (code) => {
+  handlePairingCode(code);
+});
+
+client.on("qr", (qr) => {
+  handleQR(qr);
+});
+
+client.initialize();
+logger.info(t("bot.initialized"));

package/src/utils/file.js

@@ -0,0 +1,9 @@
+import fs from "fs";
+import path from "path";
+
+export function emptyFolder(folder) {
+    fs.readdirSync(folder).forEach(file => {
+        const filePath = path.join(folder, file);
+        if (fs.lstatSync(filePath).isFile()) fs.unlinkSync(filePath);
+    });
+}

package/src/utils/getChatId.js

@@ -0,0 +1,3 @@
+export function getChatId(chat) {
+    return chat.id._serialized;
+}