@manybot/manybot 4.0.1

package/src/i18n/index.js

@@ -0,0 +1,235 @@
+/**
+ * i18n/index.js
+ *
+ * Internationalization system for ManyBot.
+ * Loads translations based on LANGUAGE configuration.
+ * Fallback is always English (en).
+ *
+ * Plugins can use createPluginT() to have isolated i18n.
+ */
+
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { CONFIG } from "#config";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const LOCALES_DIR = path.join(__dirname, "..", "locales");
+
+// Default language (fallback)
+const DEFAULT_LANG = "en";
+
+// Cache of loaded translations
+const translations = new Map();
+
+/**
+ * Loads a translation JSON file
+ * @param {string} lang - language code (en, pt, es)
+ * @returns {object|null}
+ */
+function loadLocale(lang) {
+  if (translations.has(lang)) {
+    return translations.get(lang);
+  }
+
+  const filePath = path.join(LOCALES_DIR, `${lang}.json`);
+
+  try {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    const content = fs.readFileSync(filePath, "utf8");
+    const data = JSON.parse(content);
+    translations.set(lang, data);
+    return data;
+  } catch (err) {
+    console.error(`[i18n] Failed to load locale ${lang}:`, err.message);
+    return null;
+  }
+}
+
+/**
+ * Gets configured language or default
+ * @returns {string}
+ */
+function getConfiguredLang() {
+  const lang = CONFIG.LANGUAGE?.trim().toLowerCase();
+  if (!lang) return DEFAULT_LANG;
+
+  // Check if file exists
+  const filePath = path.join(LOCALES_DIR, `${lang}.json`);
+  if (!fs.existsSync(filePath)) {
+    console.warn(`[i18n] Language "${lang}" not found, falling back to "${DEFAULT_LANG}"`);
+    return DEFAULT_LANG;
+  }
+
+  return lang;
+}
+
+// Load languages
+const currentLang = getConfiguredLang();
+const currentTranslations = loadLocale(currentLang) || {};
+const fallbackTranslations = loadLocale(DEFAULT_LANG) || {};
+
+/**
+ * Gets a nested value from an object using dot path
+ * @param {object} obj
+ * @param {string} key - path like "system.connected"
+ * @returns {string|undefined}
+ */
+function getNestedValue(obj, key) {
+  const parts = key.split(".");
+  let current = obj;
+
+  for (const part of parts) {
+    if (current === null || current === undefined || typeof current !== "object") {
+      return undefined;
+    }
+    current = current[part];
+  }
+
+  return current;
+}
+
+/**
+ * Replaces placeholders {{key}} with values from context
+ * @param {string} str
+ * @param {object} context
+ * @returns {string}
+ */
+function interpolate(str, context = {}) {
+  return str.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    return context[key] !== undefined ? String(context[key]) : match;
+  });
+}
+
+/**
+ * Main translation function
+ * @param {string} key - translation key (e.g., "system.connected")
+ * @param {object} context - values to interpolate {{key}}
+ * @returns {string}
+ */
+export function t(key, context = {}) {
+  // Try current language first
+  let value = getNestedValue(currentTranslations, key);
+
+  // Fallback to English if not found
+  if (value === undefined) {
+    value = getNestedValue(fallbackTranslations, key);
+  }
+
+  // If still not found, return the key
+  if (value === undefined) {
+    return key;
+  }
+
+  // If not string, convert
+  if (typeof value !== "string") {
+    return String(value);
+  }
+
+  // Interpolate values
+  return interpolate(value, context);
+}
+
+/**
+ * Creates an isolated translation function for a plugin.
+ * Plugins should have their own locale/ folder with en.json, es.json, etc.
+ *
+ * Usage in plugin:
+ *   import { createPluginT } from "../../i18n/index.js";
+ *   const { t } = createPluginT(import.meta.url);
+ *
+ * Folder structure:
+ *   myPlugin/
+ *     index.js
+ *     locale/
+ *       en.json
+ *       es.json
+ *       pt.json
+ *
+ * @param {string} pluginMetaUrl - import.meta.url from the plugin
+ * @returns {{ t: Function, lang: string }}
+ */
+export function createPluginT(pluginMetaUrl) {
+  const pluginDir = path.dirname(fileURLToPath(pluginMetaUrl));
+  const pluginLocaleDir = path.join(pluginDir, "locale");
+
+  // Get bot's configured language
+  const targetLang = currentLang;
+
+  // Load plugin translations
+  let pluginTranslations = {};
+  let pluginFallback = {};
+
+  try {
+    // Try to load the configured language
+    const targetPath = path.join(pluginLocaleDir, `${targetLang}.json`);
+    if (fs.existsSync(targetPath)) {
+      pluginTranslations = JSON.parse(fs.readFileSync(targetPath, "utf8"));
+    }
+
+    // Always load English as fallback
+    const fallbackPath = path.join(pluginLocaleDir, `${DEFAULT_LANG}.json`);
+    if (fs.existsSync(fallbackPath)) {
+      pluginFallback = JSON.parse(fs.readFileSync(fallbackPath, "utf8"));
+    }
+  } catch (err) {
+    // Silent fail - plugin may not have translations
+  }
+
+  /**
+   * Plugin-specific translation function
+   * @param {string} key
+   * @param {object} context
+   * @returns {string}
+   */
+  function pluginT(key, context = {}) {
+    // Try plugin's target language first
+    let value = getNestedValue(pluginTranslations, key);
+
+    // Fallback to plugin's English
+    if (value === undefined) {
+      value = getNestedValue(pluginFallback, key);
+    }
+
+    // If still not found, return the key
+    if (value === undefined) {
+      return key;
+    }
+
+    if (typeof value !== "string") {
+      return String(value);
+    }
+
+    return interpolate(value, context);
+  }
+
+  return { t: pluginT, lang: targetLang };
+}
+
+/**
+ * Reloads translations (useful for hot-reload)
+ */
+export function reloadTranslations() {
+  translations.clear();
+  const lang = getConfiguredLang();
+  const newTranslations = loadLocale(lang) || {};
+  const newFallback = loadLocale(DEFAULT_LANG) || {};
+
+  // Update references
+  Object.assign(currentTranslations, newTranslations);
+  Object.assign(fallbackTranslations, newFallback);
+
+  console.log(`[i18n] Translations reloaded for language: ${lang}`);
+}
+
+/**
+ * Returns current language
+ * @returns {string}
+ */
+export function getCurrentLang() {
+  return currentLang;
+}
+
+export default { t, createPluginT, reloadTranslations, getCurrentLang };

package/src/kernel/messageHandler.js

@@ -0,0 +1,39 @@
+/**
+ * messageHandler.js
+ *
+ * Central pipeline for received messages.
+ *
+ * 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
+ *
+ * Kernel knows no commands — only distributes.
+ * Each plugin decides on its own whether to act or ignore.
+ */
+
+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";
+
+export async function handleMessage(msg) {
+  const chat = await msg.getChat();
+  const chatId = getChatId(chat);
+
+  if (CHATS.length > 0 && !CHATS.includes(chatId)) return;
+
+  const ctx = buildApi({
+    msg,
+    chat,
+    client,
+    pluginRegistry
+  });
+
+  for (const plugin of pluginRegistry.values()) {
+    await runPlugin(plugin, ctx);
+  }
+}

package/src/kernel/pluginApi.js

@@ -0,0 +1,303 @@
+/**
+ * pluginApi.js
+ *
+ * Builds the `ctx` object each plugin receives.
+ * Plugins can only do what's here — never touch client directly.
+ *
+ * `chat` is already filtered by kernel (only allowed chats from .conf),
+ * so plugins don't need and can't choose destination.
+ */
+
+import { logger }                              from "#logger";
+import { t, createPluginT, reloadTranslations,
+         getCurrentLang }                      from "#i18n";
+import { CONFIG }                              from "#config";
+import { enqueue }                             from "#download";
+import { emptyFolder }                         from "#utils/file";
+import { getChatId }                           from "#utils/getChatId";
+import pkg                                     from "whatsapp-web.js";
+import { client }                              from "#client/whatsappClient";
+
+const { MessageMedia } = pkg;
+
+// ── Config API ───────────────────────────────────────────────────────────────
+
+function buildConfigApi() {
+  return {
+    /**
+     * Get a config value with optional default.
+     * @param {string} key
+     * @param {any} [defaultValue]
+     */
+    get(key, defaultValue = null) {
+      return CONFIG[key] ?? defaultValue;
+    },
+
+    /** Full config object — read only. */
+    all: CONFIG,
+  };
+}
+
+// ── i18n API ─────────────────────────────────────────────────────────────────
+
+function buildI18nApi() {
+  return {
+    /** Translate a core key. */
+    t,
+
+    /**
+     * Create a scoped t() for a plugin's own locale files.
+     * @param {string} pluginMetaUrl — pass import.meta.url from the plugin
+     */
+    createT: createPluginT,
+
+    /** Reload all translations (e.g. after language change). */
+    reload: reloadTranslations,
+
+    /** Returns current language code. */
+    getCurrentLang,
+  };
+}
+
+// ── Utils API ────────────────────────────────────────────────────────────────
+
+function buildUtilsApi() {
+  return {
+    /**
+     * Empty a folder's contents without removing the folder itself.
+     * @param {string} folder
+     */
+    emptyFolder,
+
+    /**
+     * Get the serialized chat ID from a chat object.
+     * @param {import("whatsapp-web.js").Chat} chat
+     */
+    getChatId,
+  };
+}
+
+// ── Download API ─────────────────────────────────────────────────────────────
+
+function buildDownloadApi() {
+  return {
+    /**
+     * Enqueue a download work function.
+     * @param {Function} workFn
+     * @param {Function} [errorFn]
+     */
+    enqueue,
+  };
+}
+
+// ── Plugin registry API ──────────────────────────────────────────────────────
+
+function buildPluginsApi(pluginRegistry) {
+  return {
+    /**
+     * Return public API of another plugin, or null if not active.
+     * @param {string} name
+     * @returns {any|null}
+     */
+    get(name) {
+      return pluginRegistry.get(name)?.exports ?? null;
+    },
+
+    /**
+     * Return public API of another plugin, or throw if not active.
+     * Analogous to require() — use when the dependency is mandatory.
+     * @param {string} name
+     * @returns {any}
+     */
+    require(name) {
+      const plugin = pluginRegistry.get(name);
+      if (!plugin || plugin.status !== "active") {
+        throw new Error(`Plugin dependency "${name}" is not active.`);
+      }
+      return plugin.exports;
+    },
+
+    /**
+     * Check if a plugin is active.
+     * @param {string} name
+     * @returns {boolean}
+     */
+    exists(name) {
+      return pluginRegistry.get(name)?.status === "active";
+    },
+  };
+}
+
+// ── Log API ──────────────────────────────────────────────────────────────────
+
+const log = {
+  info:    (...a) => logger.info(...a),
+  warn:    (...a) => logger.warn(...a),
+  error:   (...a) => logger.error(...a),
+  success: (...a) => logger.success(...a),
+};
+
+// ── Internal media helpers ───────────────────────────────────────────────────
+
+function mediaFromSource(source, mimetype = "image/webp") {
+  return typeof source === "string"
+    ? MessageMedia.fromFilePath(source)
+    : new MessageMedia(mimetype, source.toString("base64"));
+}
+
+/**
+ * Returns send methods bound to a target that exposes `.sendMessage()`.
+ * Used for both current-chat and sendTo variants.
+ * @param {{ sendMessage: Function }} target
+ */
+function makeSender(target) {
+  return {
+    async text(content) {
+      return target.sendMessage(content);
+    },
+    async image(filePath, caption = "") {
+      const media = MessageMedia.fromFilePath(filePath);
+      return target.sendMessage(media, { caption });
+    },
+    async video(filePath, caption = "") {
+      const media = MessageMedia.fromFilePath(filePath);
+      return target.sendMessage(media, { caption });
+    },
+    async audio(filePath) {
+      const media = MessageMedia.fromFilePath(filePath);
+      return target.sendMessage(media, { sendAudioAsVoice: true });
+    },
+    async sticker(source) {
+      const media = mediaFromSource(source);
+      return target.sendMessage(media, { sendMediaAsSticker: true });
+    },
+  };
+}
+
+/** Adapts client.sendMessage(chatId, ...) to the makeSender interface. */
+function chatIdTarget(client, chatId) {
+  return {
+    sendMessage: (content, opts) => client.sendMessage(chatId, content, opts),
+  };
+}
+
+// ── Setup API ────────────────────────────────────────────────────────────────
+
+/**
+ * Setup API — without message context.
+ * Passed to plugin.setup(ctx) during initialization.
+ *
+ * @param {import("whatsapp-web.js").Client} client
+ * @param {Map<string, any>} pluginRegistry
+ * @returns {object}
+ */
+export function buildSetupApi(client, pluginRegistry) {
+  return {
+    sendTo:        (chatId, text)              => client.sendMessage(chatId, text),
+    sendImageTo:   (chatId, filePath, caption) => makeSender(chatIdTarget(client, chatId)).image(filePath, caption),
+    sendVideoTo:   (chatId, filePath, caption) => makeSender(chatIdTarget(client, chatId)).video(filePath, caption),
+    sendAudioTo:   (chatId, filePath)          => makeSender(chatIdTarget(client, chatId)).audio(filePath),
+    sendStickerTo: (chatId, source)            => makeSender(chatIdTarget(client, chatId)).sticker(source),
+
+    log,
+    t,
+    config:   buildConfigApi(),
+    i18n:     buildI18nApi(),
+    utils:    buildUtilsApi(),
+    download: buildDownloadApi(),
+    plugins:  buildPluginsApi(pluginRegistry),
+    botId:    client.info?.wid?._serialized ?? null,
+  };
+}
+
+// ── Runtime API ──────────────────────────────────────────────────────────────
+
+/**
+ * Runtime API — full context with message and chat.
+ * Passed to plugin.default(ctx) on every message.
+ *
+ * @param {object}                            params
+ * @param {import("whatsapp-web.js").Message} params.msg
+ * @param {import("whatsapp-web.js").Chat}    params.chat
+ * @param {import("whatsapp-web.js").Client}  params.client
+ * @param {Map<string, any>}                  params.pluginRegistry
+ * @returns {object} ctx
+ */
+export function buildApi({ msg, chat, client, pluginRegistry }) {
+
+  const currentSender = makeSender(chat);
+
+  return {
+
+    // ── msg ──────────────────────────────────────────────────
+
+    msg: {
+      body:       msg.body ?? "",
+      type:       msg.type,
+      fromMe:     msg.fromMe,
+      sender:     msg.author || msg.from,
+      senderName: msg._data?.notifyName || String(msg.from).replace(/(:\d+)?@.*$/, ""),
+      args:       msg.body?.trim().split(/\s+/) ?? [],
+
+      /** Check if message starts with a command. */
+      is(cmd) {
+        return msg.body?.trim().toLowerCase().startsWith(cmd.toLowerCase());
+      },
+
+      hasMedia:  msg.hasMedia,
+      isGif:     msg._data?.isGif ?? false,
+
+      async downloadMedia() {
+        const media = await msg.downloadMedia();
+        if (!media) return null;
+        return { mimetype: media.mimetype, data: media.data };
+      },
+
+      hasReply: msg.hasQuotedMsg,
+
+      async getReply() {
+        if (!msg.hasQuotedMsg) return null;
+        return msg.getQuotedMessage();
+      },
+
+      async reply(text) {
+        return msg.reply(text);
+      },
+    },
+
+    // ── chat ─────────────────────────────────────────────────
+
+    chat: {
+      id:      chat.id._serialized,
+      name:    chat.name || chat.id.user,
+      isGroup: /@g\.us$/.test(chat.id._serialized),
+    },
+
+    // ── send (current chat) ──────────────────────────────────
+
+    send:        (text)              => currentSender.text(text),
+    sendImage:   (filePath, caption) => currentSender.image(filePath, caption),
+    sendVideo:   (filePath, caption) => currentSender.video(filePath, caption),
+    sendAudio:   (filePath)          => currentSender.audio(filePath),
+    sendSticker: (source)            => currentSender.sticker(source),
+
+    // ── sendTo (specific chat) ───────────────────────────────
+
+    sendTo:        (chatId, text)              => client.sendMessage(chatId, text),
+    sendImageTo:   (chatId, filePath, caption) => makeSender(chatIdTarget(client, chatId)).image(filePath, caption),
+    sendVideoTo:   (chatId, filePath, caption) => makeSender(chatIdTarget(client, chatId)).video(filePath, caption),
+    sendAudioTo:   (chatId, filePath)          => makeSender(chatIdTarget(client, chatId)).audio(filePath),
+    sendStickerTo: (chatId, source)            => makeSender(chatIdTarget(client, chatId)).sticker(source),
+
+    // ── system ───────────────────────────────────────────────
+
+    log,
+    t,
+    config:   buildConfigApi(),
+    i18n:     buildI18nApi(),
+    utils:    buildUtilsApi(),
+    download: buildDownloadApi(),
+    plugins:  buildPluginsApi(pluginRegistry),
+    botId: client.info?.wid?._serialized ?? null,
+  };
+}

package/src/kernel/pluginGuard.js

@@ -0,0 +1,37 @@
+/**
+ * pluginGuard.js
+ *
+ * Runs a plugin safely.
+ * If plugin throws an error:
+ *   - Logs error with context
+ *   - Marks plugin as "error" in registry
+ *   - Never crashes the bot
+ *
+ * Disabled or errored plugins are silently ignored.
+ */
+
+import { logger }         from "#logger";
+import { t }              from "#i18n";
+import { pluginRegistry } from "#kernel/pluginLoader";
+
+/**
+ * @param {object} plugin   — pluginRegistry entry
+ * @param {object} context  — buildApi ctx
+ */
+export async function runPlugin(plugin, context) {
+  if (plugin.status !== "active") return;
+
+  try {
+    await plugin.run(context);
+  } catch (err) {
+    // Disable plugin to prevent further breakage
+    plugin.status = "error";
+    plugin.error  = err;
+    pluginRegistry.set(plugin.name, plugin);
+
+    logger.error(
+      t("system.pluginDisabledAfterError", { name: plugin.name, message: err.message }),
+      `\n             ${t("errors.stack")}: ${err.stack?.split("\n")[1]?.trim() ?? ""}`
+    );
+  }
+}