@manybot/manybot 5.2.0 → 5.2.1

package/dist/kernel/settingsDb.js

@@ -0,0 +1,205 @@
+/**
+ * settingsDb.ts
+ *
+ * Persistent per-chat settings backed by SQLite.
+ * Exposed to plugins via ctx.settings.
+ *
+ * Two concerns live here:
+ *   1. Plugin settings  — arbitrary key/value per (plugin, chat)
+ *   2. Community links  — grouping chats under a shared community ID
+ *
+ * Plugins never touch the DB directly — only through buildSettingsApi().
+ */
+import Database from "better-sqlite3";
+import path from "path";
+import { mkdirSync } from "fs";
+import { CONFIG_DIR } from "#config";
+// ── DB init ───────────────────────────────────────────────────────────────────
+const DB_PATH = path.join(CONFIG_DIR, "settings.db");
+mkdirSync(path.dirname(DB_PATH), { recursive: true });
+const db = new Database(DB_PATH);
+db.pragma("journal_mode = WAL");
+db.pragma("foreign_keys = ON");
+db.exec(`
+  CREATE TABLE IF NOT EXISTS plugin_settings (
+    plugin_name  TEXT NOT NULL,
+    chat_id      TEXT NOT NULL,
+    key          TEXT NOT NULL,
+    value        TEXT NOT NULL,
+    updated_at   INTEGER NOT NULL DEFAULT (unixepoch()),
+    PRIMARY KEY  (plugin_name, chat_id, key)
+  );
+
+  CREATE TABLE IF NOT EXISTS community_links (
+    chat_id      TEXT PRIMARY KEY,
+    community_id TEXT NOT NULL,
+    linked_at    INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_community
+    ON community_links (community_id);
+`);
+// ── Prepared statements ───────────────────────────────────────────────────────
+const stmts = {
+    get: db.prepare("SELECT value FROM plugin_settings WHERE plugin_name = ? AND chat_id = ? AND key = ?"),
+    getAll: db.prepare("SELECT key, value FROM plugin_settings WHERE plugin_name = ? AND chat_id = ?"),
+    set: db.prepare(`
+    INSERT INTO plugin_settings (plugin_name, chat_id, key, value, updated_at)
+    VALUES (?, ?, ?, ?, unixepoch())
+    ON CONFLICT (plugin_name, chat_id, key)
+    DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
+  `),
+    delete: db.prepare("DELETE FROM plugin_settings WHERE plugin_name = ? AND chat_id = ? AND key = ?"),
+    deleteAll: db.prepare("DELETE FROM plugin_settings WHERE plugin_name = ? AND chat_id = ?"),
+    getCommunityId: db.prepare("SELECT community_id FROM community_links WHERE chat_id = ?"),
+    getCommunityChats: db.prepare("SELECT chat_id FROM community_links WHERE community_id = ?"),
+    link: db.prepare(`
+    INSERT INTO community_links (chat_id, community_id, linked_at)
+    VALUES (?, ?, unixepoch())
+    ON CONFLICT (chat_id)
+    DO UPDATE SET community_id = excluded.community_id, linked_at = excluded.linked_at
+  `),
+    unlink: db.prepare("DELETE FROM community_links WHERE chat_id = ?"),
+};
+// ── Core helpers ──────────────────────────────────────────────────────────────
+function dbGet(pluginName, chatId, key) {
+    const row = stmts.get.get(pluginName, chatId, key);
+    if (!row)
+        return undefined;
+    try {
+        return JSON.parse(row.value);
+    }
+    catch {
+        return row.value;
+    }
+}
+function dbGetAll(pluginName, chatId) {
+    const rows = stmts.getAll.all(pluginName, chatId);
+    return Object.fromEntries(rows.map(({ key, value }) => {
+        try {
+            return [key, JSON.parse(value)];
+        }
+        catch {
+            return [key, value];
+        }
+    }));
+}
+function dbSet(pluginName, chatId, key, value) {
+    stmts.set.run(pluginName, chatId, key, JSON.stringify(value));
+}
+function dbDelete(pluginName, chatId, key) {
+    stmts.delete.run(pluginName, chatId, key);
+}
+function dbDeleteAll(pluginName, chatId) {
+    stmts.deleteAll.run(pluginName, chatId);
+}
+// ── Scoped accessor factory ───────────────────────────────────────────────────
+/**
+ * Returns a settings accessor for a specific (pluginName, chatId) pair.
+ * Used both for the current chat and for forChat(id) cross-chat reads.
+ */
+function scopedAccessor(pluginName, chatId) {
+    return {
+        /**
+         * Get a setting value. Returns `defaultValue` (default: undefined) if not set.
+         * @param {string} key
+         * @param {*}      [defaultValue]
+         */
+        get(key, defaultValue = undefined) {
+            const val = dbGet(pluginName, chatId, key);
+            return val !== undefined ? val : defaultValue;
+        },
+        /**
+         * Get all settings for this chat as a plain object.
+         * @returns {Record<string, *>}
+         */
+        getAll() {
+            return dbGetAll(pluginName, chatId);
+        },
+        /**
+         * Set a setting value. Any JSON-serializable value is accepted.
+         * @param {string} key
+         * @param {*}      value
+         */
+        set(key, value) {
+            dbSet(pluginName, chatId, key, value);
+        },
+        /**
+         * Delete a single setting key.
+         * @param {string} key
+         */
+        delete(key) {
+            dbDelete(pluginName, chatId, key);
+        },
+        /**
+         * Delete all settings for this chat under this plugin.
+         */
+        deleteAll() {
+            dbDeleteAll(pluginName, chatId);
+        },
+    };
+}
+// ── Public API builder ────────────────────────────────────────────────────────
+/**
+ * Builds ctx.settings for a given runtime context.
+ *
+ * ctx.settings          — scoped to current chat
+ * ctx.settings.global   — scoped to a synthetic "_global" chat ID
+ * ctx.settings.forChat  — cross-chat read (any chatId)
+ * ctx.settings.link     — community membership
+ *
+ * @param {string} pluginName
+ * @param {string} chatId       — current chat's serialized ID
+ */
+export function buildSettingsApi(pluginName, chatId) {
+    const current = scopedAccessor(pluginName, chatId);
+    return {
+        ...current,
+        /**
+         * Bot-wide settings, not tied to any specific chat.
+         * Stored under the synthetic key "_global".
+         */
+        global: scopedAccessor(pluginName, "_global"),
+        /**
+         * Access settings of any other chat by ID.
+         * Useful for cross-chat features like community-wide XP.
+         * @param {string} targetChatId
+         */
+        forChat(targetChatId) {
+            return scopedAccessor(pluginName, targetChatId);
+        },
+        /**
+         * Link the current chat to a community by ID.
+         * The community ID is any string you choose — typically a name or UUID.
+         * Replaces any existing link for this chat.
+         * @param {string} communityId
+         */
+        link(communityId) {
+            stmts.link.run(chatId, communityId);
+        },
+        /**
+         * Unlink the current chat from its community.
+         */
+        unlink() {
+            stmts.unlink.run(chatId);
+        },
+        /**
+         * Returns the community ID this chat belongs to, or null.
+         * @returns {string | null}
+         */
+        getCommunityId() {
+            return stmts.getCommunityId.get(chatId)?.community_id ?? null;
+        },
+        /**
+         * Returns all chat IDs that belong to the same community as the current chat.
+         * Returns [] if this chat has no community link.
+         * @returns {string[]}
+         */
+        getCommunityChats() {
+            const row = stmts.getCommunityId.get(chatId);
+            if (!row)
+                return [];
+            return stmts.getCommunityChats.all(row.community_id).map((r) => r.chat_id);
+        },
+    };
+}

package/dist/locales/en.json

@@ -0,0 +1,52 @@
+{
+  "bot": {
+    "initialized": "Client initialized. Waiting for WhatsApp connection...",
+    "ready": "Bot is ready!",
+    "error": {
+      "uncaught": "Uncaught exception",
+      "unhandled": "Unhandled rejection"
+    },
+    "signal": {
+      "sigterm": "Process interrupted. Shutting down..."
+    }
+  },
+  "system": {
+    "connected": "WhatsApp connected and ready!",
+    "disconnected": "Disconnected — reason: {{reason}}",
+    "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)",
+    "clientId": "Client ID: {{id}}",
+    "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}}",
+    "pluginReloaded": "Plugin reloaded: {{name}}",
+    "pluginLoadFailed": "Failed to load plugin \"{{name}}\": {{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}}",
+    "reconnecting": "Reconnecting in {{secs}}s...",
+    "sessionExpired": "Session expired or logged out — removing local session and restarting..."
+  },
+  "errors": {
+    "stack": "Stack"
+  },
+  "onboarding": {
+    "intro": "ManyBot — first login",
+    "methodPrompt": "How do you want to connect your WhatsApp account?",
+    "methodPhone": "Enter phone number",
+    "methodPhoneHint": "pairing code",
+    "methodQr": "Show QR code",
+    "methodQrHint": "scan with your phone",
+    "phonePrompt": "Phone number (with country code, digits only)",
+    "phoneValidation": "Digits only, with country code. E.g.: 5511999999999",
+    "outroQr": "Scan the QR code that will appear next.",
+    "outroPhone": "Wait for the pairing code that will appear next.",
+    "cancelled": "Login cancelled."
+  }
+}

package/dist/locales/es.json

@@ -0,0 +1,52 @@
+{
+  "bot": {
+    "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..."
+    }
+  },
+  "system": {
+    "connected": "¡WhatsApp conectado y listo!",
+    "disconnected": "Desconectado — motivo: {{reason}}",
+    "qrScan": "Escanea el Código QR abajo:",
+    "pairingCodeTitle": "Código de emparejamiento:",
+    "pairingCodeValue": "→ {{code}} ←",
+    "pairingCodeInstructions": "Ingresa este código en WhatsApp: Menú → Dispositivos vinculados → Vincular con número de teléfono",
+    "phoneNumberInvalid": "Número de teléfono inválido: {{number}}. Formato esperado: 5511999999999 (código de país + área + número, sin espacios ni caracteres especiales)",
+    "clientId": "Client ID: {{id}}",
+    "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}}",
+    "pluginReloaded": "Plugin recargado: {{name}}",
+    "pluginLoadFailed": "Error al cargar el plugin \"{{name}}\": {{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}}",
+    "reconnecting": "Reconectando en {{secs}}s...",
+    "sessionExpired": "Sesión expirada o cerrada — eliminando sesión local y reiniciando..."
+  },
+  "errors": {
+    "stack": "Stack"
+  },
+  "onboarding": {
+    "intro": "ManyBot — primer inicio de sesión",
+    "methodPrompt": "¿Cómo quieres conectar tu cuenta de WhatsApp?",
+    "methodPhone": "Ingresar número de teléfono",
+    "methodPhoneHint": "código de emparejamiento",
+    "methodQr": "Mostrar código QR",
+    "methodQrHint": "escanea con tu teléfono",
+    "phonePrompt": "Número de teléfono (con código de país, solo dígitos)",
+    "phoneValidation": "Solo dígitos, con código de país. Ej.: 5511999999999",
+    "outroQr": "Escanea el código QR que aparecerá a continuación.",
+    "outroPhone": "Espera el código de emparejamiento que aparecerá a continuación.",
+    "cancelled": "Inicio de sesión cancelado."
+  }
+}

package/dist/locales/pt.json

@@ -0,0 +1,52 @@
+{
+  "bot": {
+    "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..."
+    }
+  },
+  "system": {
+    "connected": "WhatsApp conectado e pronto!",
+    "disconnected": "Desconectado — motivo: {{reason}}",
+    "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)",
+    "clientId": "Client ID: {{id}}",
+    "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}}",
+    "pluginReloaded": "Plugin recarregado: {{name}}",
+    "pluginLoadFailed": "Falha ao carregar plugin \"{{name}}\": {{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}}",
+    "reconnecting": "Reconectando em {{secs}}s...",
+    "sessionExpired": "Sessão expirada ou desconectada — removendo sessão local e reiniciando..."
+  },
+  "errors": {
+    "stack": "Stack"
+  },
+  "onboarding": {
+    "intro": "ManyBot — primeiro login",
+    "methodPrompt": "Como você quer conectar sua conta do WhatsApp?",
+    "methodPhone": "Digitar número de telefone",
+    "methodPhoneHint": "código de pareamento",
+    "methodQr": "Mostrar QR code",
+    "methodQrHint": "escaneie com seu celular",
+    "phonePrompt": "Número de telefone (com código do país, somente dígitos)",
+    "phoneValidation": "Somente dígitos, com código do país. Ex.: 5511999999999",
+    "outroQr": "Escaneie o QR code que vai aparecer a seguir.",
+    "outroPhone": "Aguarde o código de pareamento que vai aparecer a seguir.",
+    "cancelled": "Login cancelado."
+  }
+}

package/dist/logger/logger.js

@@ -0,0 +1,16 @@
+const c = {
+    reset: "\x1b[0m",
+    green: "\x1b[32m", yellow: "\x1b[33m", cyan: "\x1b[36m",
+    red: "\x1b[31m", blue: "\x1b[34m",
+};
+/**
+ * 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),
+};

package/dist/main.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env tsx
+/**
+ * main.ts
+ *
+ * ManyBot entry point.
+ * Orchestrates process lifecycle, error handling, and driver startup.
+ */
+import Module from "module";
+import path from "path";
+process.env.NODE_PATH = path.resolve(process.cwd(), "node_modules");
+Module._initPaths();
+import { initializeSelectedDriver } from "#drivers/index.js";
+import { cleanupPlugins } from "#kernel/pluginLoader.js";
+import { stopAll as stopScheduler } from "#kernel/scheduler.js";
+import { logger } from "#logger";
+import { t } from "#i18n";
+let shuttingDown = false;
+const activeDriver = initializeSelectedDriver();
+async function shutdown(reason, isError = false) {
+    if (shuttingDown)
+        return;
+    shuttingDown = true;
+    if (isError) {
+        logger.error(`${t("bot.error.uncaught")}: ${reason}`);
+    }
+    else {
+        logger.warn(t("bot.signal.sigterm", { signal: reason }));
+    }
+    try {
+        await cleanupPlugins();
+    }
+    catch (err) {
+        logger.error(`Error cleaning up plugins: ${err.message}`);
+    }
+    stopScheduler();
+    try {
+        await activeDriver.disconnect();
+    }
+    catch (err) {
+        logger.error(`Error disconnecting driver: ${err.message}`);
+    }
+    process.exit(isError ? 1 : 0);
+}
+// Global error listeners
+process.on("uncaughtException", (err) => {
+    const stackFrame = err.stack?.split("\n")[1]?.trim() ?? "";
+    shutdown(`${err.message}\n             ${t("errors.stack")}: ${stackFrame}`, true);
+});
+process.on("unhandledRejection", (reason) => {
+    const msg = reason instanceof Error ? reason.message : String(reason);
+    shutdown(`${t("bot.error.unhandled")}: ${msg}`, true);
+});
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+process.on("SIGINT", () => shutdown("SIGINT"));
+// ── --getid mode (provisional) ───────────────────────────────────────────
+// Usage: npm run start -- --getid
+// Connects, waits for the next message to arrive from any chat, and prints
+// the JID to the console, to paste into CHATS/TEST_CHAT in manybot.toml.
+// Does not enter the normal bot flow (plugins are not loaded).
+if (process.argv.includes("--getid")) {
+    if (!activeDriver.getId) {
+        logger.error(`Current driver does not support --getid.`);
+        process.exit(1);
+    }
+    activeDriver.getId()
+        .then(() => process.exit(0))
+        .catch((err) => {
+        logger.error(`--getid mode failed: ${err.message}`);
+        process.exit(1);
+    });
+}
+else {
+    // Start bot
+    logger.info(t("bot.initialized"));
+    activeDriver.connect()
+        .then(() => {
+        logger.success(t("bot.ready"));
+    })
+        .catch((err) => {
+        shutdown(`Failed to connect driver: ${err.message}`, true);
+    });
+}

package/dist/types.js

@@ -0,0 +1,16 @@
+/**
+ * src/types.ts
+ *
+ * Shared WhatsApp-facing types, imported everywhere as "#types" (see
+ * tsconfig.json paths / package.json imports). Kept as a single module so
+ * call sites don't need to know whether a type comes straight from
+ * Baileys or from ManyBot's own store/adapter layer.
+ *
+ * Types that are only meaningful within the plugin-API builder itself
+ * (the shape of `ctx`, `ctx.msg`, the chainable sender returned by
+ * ctx.send/ctx.msg.reply, etc.) are NOT defined here — they're inferred
+ * with `ReturnType<typeof ...>` right next to the functions that build
+ * them, in drivers/whatsapp/api/index.ts, to avoid circular type
+ * definitions.
+ */
+export {};

package/dist/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/package.json

@@ -5,7 +5,7 @@
     "name": "SyntaxError!",
     "email": "me@stxerr.dev"
   },
-  "version": "5.2.0",
+  "version": "5.2.1",
   "license": "GPL-3.0-only",
   "private": false,
   "engines": {