@manybot/manybot 4.4.0 → 5.1.0

package/package.json

@@ -5,7 +5,7 @@
     "name": "SyntaxError!",
     "email": "me@stxerr.dev"
   },
-  "version": "4.4.0",
+  "version": "5.1.0",
   "license": "GPL-3.0-only",
   "private": false,
   "engines": {
@@ -37,6 +37,7 @@
   "dependencies": {
     "node-webpmux": "^3.2.1",
     "qrcode-terminal": "^0.12.0",
+    "smol-toml": "^1.7.0",
     "tar": "^7.5.16",
     "whatsapp-web.js": "^1.24.0"
   },
@@ -44,6 +45,7 @@
     "#client/*": "./src/client/*.js",
     "#kernel/*": "./src/kernel/*.js",
     "#manyapi": "./src/kernel/pluginApi.js",
+    "#sendguard": "./src/kernel/sendGuard.js",
     "#logger": "./src/logger/logger.js",
     "#utils/*": "./src/utils/*.js",
     "#i18n": "./src/i18n/index.js",

package/src/client/whatsappClient.js

@@ -20,20 +20,27 @@ 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 chrome = path.join(CONFIG_DIR, "chrome/chrome")
+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 os = process.platform;
     const urls = {
       linux: "https://api.manybot.stxerr.dev/download-chrome-linux",
       win32: "https://api.manybot.stxerr.dev/download-chrome-win"
@@ -41,7 +48,7 @@ if (!fs.existsSync(chrome)) {
 
     const url = urls[os];
     if (!url) throw new Error(t("errors.OSNotSupported", { os }));
-    
+
     fs.mkdirSync(tmpDir, { recursive: true });
 
     const res = await fetch(url);
@@ -77,7 +84,7 @@ if (!fs.existsSync(chrome)) {
       );
     } finally {
       clearInterval(spinner);
-      process.stderr.write("\r\x1b[2K"); // limpa a linha
+      process.stderr.write("\r\x1b[2K");
     }
 
     if (expected && received !== expected) {

package/src/config.js

@@ -1,178 +1,277 @@
 /**
  * config.js
  *
- * Loads:
+ * 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
  *
- * Merges both files into a single configuration object.
+ * 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";
 
-export const CONFIG_DIR = path.join(os.homedir(), ".manybot");
-export const CONFIG_FILE = path.join(CONFIG_DIR, "manybot.conf");
-export const PLUGIN_FILE = path.join(CONFIG_DIR, "manyplug.conf");
+// ---------------------------------------------------------------------------
+// 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)
+// ---------------------------------------------------------------------------
 
-/**
- * Converts strings to native JS values.
- */
 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;
-
+  if (value === "true")  return true;
+  if (value === "false") return false;
   return value;
 }
 
-/**
- * Reads comments safely.
- * Ignores # inside quoted strings.
- */
 function stripInlineComment(line) {
   let result = "";
-  let quote = null;
-
+  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 (quote === ch)   quote = null;
+      else if (!quote)    quote = ch;
     }
-
-    if (ch === "#" && !quote)
-      break;
-
+    if (ch === "#" && !quote) break;
     result += ch;
   }
-
   return result.trim();
 }
 
-/**
- * Parses manybot.conf syntax.
- */
 function parseConf(raw) {
-  const lines = raw.split(/\r?\n/);
-
+  const lines       = raw.split(/\r?\n/);
   const mergedLines = [];
-
-  let insideList = false;
-  let buffer = "";
+  let insideList    = false;
+  let buffer        = "";
 
   for (let line of lines) {
     line = stripInlineComment(line);
-
-    if (!line)
-      continue;
+    if (!line) continue;
 
     if (!insideList) {
       if (/=\s*\[$/.test(line)) {
         insideList = true;
-        buffer = line;
+        buffer     = line;
       } else {
         mergedLines.push(line);
       }
     } else {
       buffer += " " + line;
-
       if (line.includes("]")) {
         mergedLines.push(buffer);
-        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 (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))
+        .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 "";
+    if (err.code !== "ENOENT") logger.warn(`Error reading ${file}: ${err.message}`);
+    return null;
   }
 }
 
-const defaultConfig = 
-`
-# Many bot configuration file
+// ---------------------------------------------------------------------------
+// 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=
+CLIENT_ID    = "manybot"
+CMD_PREFIX   = "!"
+CHATS        = []
+LANGUAGE     = "en"
+PHONE_NUMBER = ""
 `;
 
-try {
-  await fs.stat(CONFIG_FILE);
-} catch {
-  logger.warn("Configuration file not found: ", CONFIG_FILE, ". Creating a new one.");
+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
+// ---------------------------------------------------------------------------
 
-  await fs.mkdir(CONFIG_DIR, { recursive: true });
-  await fs.writeFile(CONFIG_FILE, defaultConfig);
+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 {};
+  }
 }
 
-const baseConfig = await readFileSafe(CONFIG_FILE);
-const pluginConfig = await readFileSafe(PLUGIN_FILE);
+tomlLayer = {
+  ...await loadToml(TOML_CONFIG_FILE, "manybot.toml"),
+  ...await loadToml(TOML_PLUGIN_FILE, "manyplug.toml"),
+};
 
-export const CONFIG = {
-  CMD_PREFIX: "!",
-  CLIENT_ID: "manybot",
-  CHATS: [],
-  PLUGINS: [],
-  LANGUAGE: "en",
+// ---------------------------------------------------------------------------
+// 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,
-  ...parseConf(baseConfig + "\n" + pluginConfig),
 };
 
+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;
@@ -180,11 +279,10 @@ export const PLUGINS      = CONFIG.PLUGINS;
 export const LANGUAGE     = CONFIG.LANGUAGE;
 export const PHONE_NUMBER = CONFIG.PHONE_NUMBER;
 
-/**
- * Useful paths for plugins/modules.
- */
 export const PATHS = {
-  HOME: CONFIG_DIR,
+  HOME:            CONFIG_DIR,
   CONFIG_FILE,
-  PLUGIN_FILE
+  PLUGIN_FILE,
+  TOML_CONFIG_FILE,
+  TOML_PLUGIN_FILE,
 };

package/src/kernel/messageHandler.js

@@ -6,30 +6,83 @@
  * Order:
  *   1. Filter allowed chats (CHATS from .conf)
  *      — if CHATS is empty, accepts all chats
- *   2. Log the message
- *   3. Pass context to all active plugins
+ *   2. Per-chat incoming debounce (prevents command spam from
+ *      saturating the outbound send queue)
+ *   3. Log the message
+ *   4. Pass context to all active plugins
  *
  * Kernel knows no commands — only distributes.
  * Each plugin decides on its own whether to act or ignore.
+ *
+ * Per-plugin overrides (via plugin.guardOptions):
+ *   typing {boolean}  — set to `false` to skip the typing indicator
+ *                       and clearState for this plugin. Useful for
+ *                       plugins that reply instantly (e.g. sticker)
+ *                       where the typing state only adds latency.
+ */
+import { CHATS }           from "#config";
+import { getChatId }       from "#utils/getChatId";
+import { buildApi }        from "#manyapi";
+import { pluginRegistry }  from "#kernel/pluginLoader";
+import { runPlugin }       from "#kernel/pluginGuard";
+import client              from "#client/whatsappClient";
+import { logger }          from "#logger";
+
+/**
+ * Minimum ms between processing two messages from the same chat.
+ * Does NOT drop messages — debounces rapid bursts so plugins
+ * aren't invoked faster than the send guard can pace their replies.
+ * Set to 0 to disable.
  */
+const INCOMING_DEBOUNCE_MS = 300;
 
-import { CHATS }  from "#config";
-import { getChatId }           from "#utils/getChatId";
-import { buildApi }            from "#manyapi";
-import { pluginRegistry }      from "#kernel/pluginLoader";
-import { runPlugin }           from "#kernel/pluginGuard";
-import client                  from "#client/whatsappClient";
+/** chatId → timestamp of last processed message */
+const lastProcessedAt = new Map();
 
 export async function handleMessage(msg) {
   const chat = await msg.getChat();
   const chatId = getChatId(chat);
 
-  if (CHATS.length > 0 && !CHATS.includes(chatId)) return;
+  if (CHATS.length > 0 && !CHATS.includes(chatId))
+    return;
 
-  const baseCtx = buildApi({ msg, chat, client, pluginRegistry });
+  if (INCOMING_DEBOUNCE_MS > 0) {
+    const now = Date.now();
+    const last = lastProcessedAt.get(chatId) ?? 0;
+    const gap = now - last;
+    if (gap < INCOMING_DEBOUNCE_MS) {
+      const wait = INCOMING_DEBOUNCE_MS - gap;
+      logger.debug(`[messageHandler] ${chatId} delayed ${wait}ms`);
+      await new Promise(r => setTimeout(r, wait));
+    }
+    lastProcessedAt.set(chatId, Date.now());
+  }
 
   for (const plugin of pluginRegistry.values()) {
-    const ctx = { ...baseCtx, storage: buildStorageApi(plugin.name) };
-    await runPlugin(plugin, ctx);
+    const ctx = buildApi({
+      msg,
+      chat,
+      client,
+      pluginRegistry,
+      pluginName: plugin.name,
+    });
+
+    const useTyping = plugin.guardOptions?.typing !== false;
+    let typing;
+
+    if (useTyping) {
+      typing = setInterval(() => chat.sendStateTyping(), 4000);
+    }
+
+    try {
+      await runPlugin(plugin, ctx);
+    } finally {
+      if (useTyping) {
+        clearInterval(typing);
+        try {
+          await chat.clearState();
+        } catch {}
+      }
+    }
   }
 }