@manybot/manybot 5.1.0 → 5.2.1

package/src/i18n/index.js

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

@@ -1,88 +0,0 @@
-/**
- * messageHandler.js
- *
- * Central pipeline for received messages.
- *
- * Order:
- *   1. Filter allowed chats (CHATS from .conf)
- *      — if CHATS is empty, accepts all chats
- *   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;
-
-/** 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 (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 = 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 {}
-      }
-    }
-  }
-}