@manybot/manybot 5.2.0 → 5.2.1

package/dist/drivers/whatsapp/index.js

@@ -0,0 +1,164 @@
+/**
+ * drivers/whatsapp/index.ts
+ *
+ * Main WhatsApp driver entry point.
+ * Implements the BotDriver interface for WhatsApp (Baileys).
+ *
+ * Responsibilities:
+ * - Socket lifecycle (connect/disconnect)
+ * - Message routing to kernel
+ * - Plugin context building (via buildApi)
+ * - Event handling and plugin execution
+ */
+import { createSocket, normalizeJid, AUTH_DIR } from "./sdk/baileysSock.js";
+import { handleMessage } from "./messageHandler.js";
+import { loadPlugins, setupPlugins } from "#kernel/pluginLoader.js";
+import { logger } from "#logger";
+import { PLUGINS, CLIENT_ID } from "#config";
+import { t } from "#i18n";
+import { printBanner } from "#client/banner.js";
+import { DisconnectReason } from "@whiskeysockets/baileys";
+import fs from "fs/promises";
+let state = "BOOT";
+let shuttingDown = false;
+let currentSock = null;
+let currentStore = null;
+async function startBot() {
+    const { sock, store } = await createSocket();
+    currentSock = sock;
+    currentStore = store;
+    // ── Normal bot mode ─────────────────────────────────────────────────────────
+    sock.ev.on("connection.update", async (update) => {
+        const { connection, lastDisconnect } = update;
+        if (connection === "open") {
+            state = "READY_INIT";
+            logger.success(t("system.connected"));
+            logger.info(t("system.clientId", { id: CLIENT_ID }));
+            printBanner();
+            await loadPlugins(PLUGINS);
+            await setupPlugins(sock, store);
+            // buffer anti-replay / sync ghost messages
+            setTimeout(() => { state = "READY"; }, 2000);
+        }
+        if (connection === "close") {
+            const code = lastDisconnect?.error?.output?.statusCode;
+            const loggedOut = code === DisconnectReason.loggedOut;
+            state = "BOOT";
+            logger.warn(t("system.disconnected", { reason: String(code) }));
+            if (loggedOut) {
+                logger.warn(t("system.sessionExpired"));
+                try {
+                    await fs.rm(AUTH_DIR, { recursive: true, force: true });
+                }
+                catch (e) {
+                    logger.error(`[whatsapp] Failed to remove session dir: ${e.message}`);
+                }
+                if (!shuttingDown)
+                    setTimeout(() => startBot(), 1000);
+            }
+            else if (!shuttingDown) {
+                logger.info(t("system.reconnecting", { secs: 5 }));
+                setTimeout(() => startBot(), 5000);
+            }
+        }
+    });
+    // Incoming messages
+    sock.ev.on("messages.upsert", async ({ messages, type }) => {
+        if (type !== "notify" || state !== "READY")
+            return;
+        for (const msg of messages) {
+            // Skip empty messages (e.g. presence updates)
+            const body = getBodyQuick(msg);
+            if (!body && !msgHasMediaQuick(msg))
+                continue;
+            try {
+                await handleMessage(msg, sock, store);
+            }
+            catch (e) {
+                const err = e instanceof Error ? e : new Error(String(e));
+                logger.error(`${err.message}\n${err.stack}`);
+            }
+        }
+    });
+}
+/** Quick body extraction to avoid importing helpers here. */
+function getBodyQuick(msg) {
+    const m = msg.message;
+    if (!m)
+        return "";
+    return (m.conversation ??
+        m.extendedTextMessage?.text ??
+        m.imageMessage?.caption ??
+        m.videoMessage?.caption ??
+        "");
+}
+function msgHasMediaQuick(msg) {
+    const m = msg.message;
+    return !!(m?.imageMessage || m?.videoMessage || m?.audioMessage || m?.documentMessage || m?.stickerMessage);
+}
+export const whatsappDriver = {
+    async connect() {
+        shuttingDown = false;
+        await startBot();
+    },
+    async disconnect() {
+        shuttingDown = true;
+        if (currentSock) {
+            try {
+                currentSock.ev?.removeAllListeners();
+            }
+            catch { }
+            try {
+                currentSock.end(undefined);
+            }
+            catch { }
+            currentSock = null;
+            currentStore = null;
+        }
+    },
+    /**
+     * Diagnostic mode: connects normally (reusing an already saved
+     * session/QR), but instead of loading plugins, just waits for the
+     * NEXT message to arrive — from any chat, from any sender, whether
+     * it's your own message or someone else's — prints the normalized
+     * JID and the chat name (if any), and exits.
+     *
+     * Intentionally does not go through the CHATS/fromMe/dedup filters of
+     * handleMessage: the only goal here is to discover the JID so you can
+     * configure CHATS/TEST_CHAT afterward, so there's no reason to filter
+     * anything out yet.
+     */
+    async getId() {
+        const { sock } = await createSocket();
+        logger.info("[getid] Connecting... wait for the QR/pairing prompt if this is the first run.");
+        await new Promise((resolve) => {
+            let done = false;
+            sock.ev.on("connection.update", (update) => {
+                if (update.connection === "open") {
+                    logger.success("[getid] Connected. Send ANY message in the chat you want to identify.");
+                }
+            });
+            sock.ev.on("messages.upsert", ({ messages, type }) => {
+                if (done || type !== "notify")
+                    return;
+                const msg = messages[0];
+                const rawJid = msg?.key?.remoteJid;
+                if (!rawJid)
+                    return;
+                done = true;
+                const jid = normalizeJid(rawJid);
+                const name = msg?.pushName ?? "";
+                logger.success(`[getid] JID: ${jid}`);
+                if (name)
+                    logger.info(`[getid] Chat/sender: ${name}`);
+                logger.info("[getid] Paste this value into CHATS or TEST_CHAT in manybot.toml.");
+                resolve();
+            });
+        });
+        try {
+            sock.ev?.removeAllListeners();
+            sock.end(undefined);
+        }
+        catch { }
+    },
+};

package/dist/drivers/whatsapp/loginPrompt.js

@@ -0,0 +1,81 @@
+/**
+ * loginPrompt.ts
+ *
+ * Interactive first-login flow. Only called when there is no valid
+ * session yet in .manybot/sessions — if one already exists, the driver
+ * skips this entirely and connects directly.
+ *
+ * Uses @clack/prompts: pure ANSI, no GUI/display, so it works the same
+ * over SSH, tmux, containers, etc — it just needs a normal TTY.
+ */
+import * as clack from "@clack/prompts";
+import { CONFIG, persistConfigValue } from "#config";
+import { t } from "#i18n";
+function cancelAndExit() {
+    clack.cancel(t("onboarding.cancelled"));
+    process.exit(1);
+}
+/**
+ * Asks which login method to use and saves the choice to manybot.toml
+ * (LOGIN_METHOD), so it won't be asked again next time.
+ */
+async function promptLoginMethod() {
+    const choice = await clack.select({
+        message: t("onboarding.methodPrompt"),
+        options: [
+            { value: "phone", label: t("onboarding.methodPhone"), hint: t("onboarding.methodPhoneHint") },
+            { value: "qr", label: t("onboarding.methodQr"), hint: t("onboarding.methodQrHint") },
+        ],
+    });
+    if (clack.isCancel(choice))
+        cancelAndExit();
+    await persistConfigValue("LOGIN_METHOD", choice);
+    return choice;
+}
+/**
+ * Asks for the phone number (with country code) and saves it to
+ * manybot.toml (PHONE_NUMBER).
+ */
+async function promptPhoneNumber() {
+    const phone = await clack.text({
+        message: t("onboarding.phonePrompt"),
+        placeholder: "5511999999999",
+        validate(value) {
+            if (!/^\d{8,15}$/.test(value.trim())) {
+                return t("onboarding.phoneValidation");
+            }
+        },
+    });
+    if (clack.isCancel(phone))
+        cancelAndExit();
+    const clean = phone.trim();
+    await persistConfigValue("PHONE_NUMBER", clean);
+    return clean;
+}
+/**
+ * Resolves the login method for this run:
+ * - LOGIN_METHOD already configured → use it directly, no prompts.
+ * - Not configured → show the menu, save the choice.
+ * - Method is "phone" but no PHONE_NUMBER saved → ask for it and save it.
+ *
+ * Should only be called when there is NO valid session yet — a valid
+ * session skips this module entirely (see baileysSock.ts).
+ */
+export async function resolveLoginMethod() {
+    let method = CONFIG.LOGIN_METHOD;
+    let phone = CONFIG.PHONE_NUMBER;
+    const needsMethod = method !== "phone" && method !== "qr";
+    const needsPhone = !needsMethod && method === "phone" && !phone;
+    if (!needsMethod && !needsPhone) {
+        return { method: method, phone: method === "phone" ? phone : null };
+    }
+    clack.intro(t("onboarding.intro"));
+    if (needsMethod) {
+        method = await promptLoginMethod();
+    }
+    if (method === "phone" && !phone) {
+        phone = await promptPhoneNumber();
+    }
+    clack.outro(method === "qr" ? t("onboarding.outroQr") : t("onboarding.outroPhone"));
+    return { method: method, phone: method === "phone" ? phone : null };
+}

package/dist/drivers/whatsapp/messageHandler.js

@@ -0,0 +1,111 @@
+/**
+ * drivers/whatsapp/messageHandler.ts
+ *
+ * WhatsApp message pipeline.
+ * Moved from kernel/messageHandler.ts to keep all WhatsApp logic together.
+ *
+ * Order:
+ *   1. Filter allowed chats (CHATS from config)
+ *   2. Per-chat incoming debounce (prevents command spam)
+ *   3. Pass context to all active plugins
+ *
+ * Each plugin decides whether to act or ignore.
+ */
+import { CHATS, TEST_CHAT } from "#config";
+import { buildApi, buildChatFromMsg } from "./api/index.js";
+import { pluginRegistry } from "#kernel/pluginLoader.js";
+import { runPlugin } from "#kernel/pluginGuard.js";
+import { normalizeJid, toPresenceCapable } from "./sdk/baileysSock.js";
+const INCOMING_DEBOUNCE_MS = 0;
+const lastProcessedAt = new Map();
+// ── Dedup of already-processed messages ────────────────────────────────────
+// WhatsApp resends messages without a delivery/read confirmation (the
+// protocol's own retry, usually up to 3 times) when the socket reconnects.
+// Without this, the same msg.key.id would arrive again as "notify" and be
+// reprocessed.
+const SEEN_TTL_MS = 10 * 60 * 1000; // 10 min is enough for WA's retries
+const seenMessageIds = new Map();
+function alreadyProcessed(id) {
+    if (!id)
+        return false;
+    const now = Date.now();
+    // lazy cleanup of expired entries
+    for (const [key, ts] of seenMessageIds) {
+        if (now - ts > SEEN_TTL_MS)
+            seenMessageIds.delete(key);
+    }
+    if (seenMessageIds.has(id))
+        return true;
+    seenMessageIds.set(id, now);
+    return false;
+}
+/**
+ * @param {WAProtoMsg} msg   - raw Baileys message
+ * @param {WASocket}   sock
+ * @param {WAStore}    store
+ */
+export async function handleMessage(msg, sock, store) {
+    const msgTimestamp = Number(msg.messageTimestamp);
+    if (msgTimestamp) {
+        const nowInSeconds = Math.floor(Date.now() / 1000);
+        const messageAge = nowInSeconds - msgTimestamp;
+        if (messageAge > 60) {
+            return;
+        }
+    }
+    const rawJid = msg.key.remoteJid ?? "";
+    const jid = normalizeJid(rawJid);
+    if (CHATS.length > 0 && !CHATS.includes(jid)) {
+        return;
+    }
+    const isTestChat = !!TEST_CHAT && jid === normalizeJid(TEST_CHAT);
+    if (msg.key.fromMe && !isTestChat) {
+        return;
+    }
+    if (alreadyProcessed(msg.key.id)) {
+        return;
+    }
+    // Mark as read/delivered to reduce the chance WhatsApp resends it
+    sock.readMessages?.([msg.key]).catch(() => { });
+    // Debounce rapid bursts per chat
+    if (INCOMING_DEBOUNCE_MS > 0) {
+        const now = Date.now();
+        const last = lastProcessedAt.get(jid) ?? 0;
+        const gap = now - last;
+        if (gap < INCOMING_DEBOUNCE_MS) {
+            const wait = INCOMING_DEBOUNCE_MS - gap;
+            await new Promise(r => setTimeout(r, wait));
+        }
+        lastProcessedAt.set(jid, Date.now());
+    }
+    // Build a WAChat adapter from the message metadata
+    const chat = await buildChatFromMsg(msg, store, sock);
+    for (const plugin of pluginRegistry.values()) {
+        const ctx = buildApi({
+            msg,
+            chat,
+            sock,
+            store,
+            pluginRegistry,
+            pluginName: plugin.name,
+            guardOptions: plugin.guardOptions,
+        });
+        const useTyping = plugin.guardOptions?.typing !== false;
+        let typingInterval;
+        if (useTyping) {
+            // Refresh presence every 4s so WhatsApp doesn't auto-clear it
+            typingInterval = setInterval(() => {
+                toPresenceCapable(sock).setPresence(rawJid, "composing").catch(() => { });
+            }, 4000);
+        }
+        try {
+            await runPlugin(plugin, ctx);
+        }
+        finally {
+            if (useTyping) {
+                clearInterval(typingInterval);
+                toPresenceCapable(sock).setPresence(rawJid, "paused").catch(() => { });
+            }
+        }
+    }
+}

package/dist/drivers/whatsapp/sdk/baileysSock.js

@@ -0,0 +1,124 @@
+/**
+ * baileysSock.ts
+ *
+ * Creates and returns a Baileys WASocket.
+ * Handles auth state persistence, QR/pairing-code display, and reconnection.
+ */
+import makeWASocket, { useMultiFileAuthState, fetchLatestBaileysVersion, Browsers, } from "@whiskeysockets/baileys";
+import path from "path";
+import qrcode from "qrcode-terminal";
+import { CONFIG_DIR, CLIENT_ID } from "#config";
+import { resolveLoginMethod } from "../loginPrompt.js";
+import { logger } from "#logger";
+import { t } from "#i18n";
+import { createStore } from "#client/store.js";
+import { CapabilitySet } from "#core/capabilities.js";
+import pino from "pino";
+// ── Auth path ─────────────────────────────────────────────────────────────────
+export const AUTH_DIR = path.join(CONFIG_DIR, "sessions", CLIENT_ID);
+// ── Shared store (survives socket reconnects) ─────────────────────────────────
+export const store = createStore();
+/**
+ * Create a new Baileys socket with persistent auth and store binding.
+ * Reconnection is the caller's responsibility — call createSocket() again
+ * on `connection.close`.
+ */
+export async function createSocket() {
+    const { state, saveCreds } = await useMultiFileAuthState(AUTH_DIR);
+    const { version } = await fetchLatestBaileysVersion();
+    // Already-valid session (creds registered in .manybot/sessions) → skips
+    // LOGIN_METHOD/PHONE_NUMBER and the interactive login flow entirely, and
+    // connects directly. This also avoids reopening QR/pairing on normal
+    // reconnects (network drop, etc), since only the FIRST run ever gets
+    // here without `registered`.
+    const alreadyRegistered = !!state.creds.registered;
+    const { method, phone } = alreadyRegistered
+        ? { method: null, phone: null }
+        : await resolveLoginMethod();
+    const sock = makeWASocket({
+        version,
+        auth: state,
+        printQRInTerminal: false,
+        // Recognized browser signature. A custom name (e.g. "ManyBot") works
+        // fine for QR, but WhatsApp rejects phone-number pairing when the
+        // browser doesn't match one of the known signatures — resulting in
+        // "Couldn't link device" on the phone even with the correct code.
+        browser: Browsers.ubuntu("Chrome"),
+        logger: pino({ level: "silent" }),
+        generateHighQualityLinkPreview: false,
+        syncFullHistory: false,
+        // Required for Baileys to decrypt incoming poll votes (and to retry
+        // sends) — it looks up the original message by key internally.
+        // Without this, pollUpdates never resolve even though the vote event
+        // arrives: ctx.poll.results()/onVote() silently stay at zero.
+        getMessage: async (key) => {
+            const stored = store.messages.get(key.remoteJid ?? "")?.get(key.id ?? "");
+            return stored?.message ?? undefined;
+        },
+    });
+    store.bind(sock.ev);
+    sock.ev.on("creds.update", saveCreds);
+    // QR code — only if the chosen method was "qr" (intentionally ignores
+    // PHONE_NUMBER even if one was saved from a previous choice).
+    let qrDisplayed = false;
+    sock.ev.on("connection.update", (update) => {
+        const { qr, connection } = update;
+        if (qr && method === "qr") {
+            qrDisplayed = true;
+            logger.info(t("system.qrScan"));
+            qrcode.generate(qr, { small: true });
+        }
+        if (connection === "open" && qrDisplayed) {
+            console.clear();
+            qrDisplayed = false;
+        }
+    });
+    // Number pairing — only if the chosen method was "phone".
+    if (method === "phone" && phone) {
+        if (!/^\d{8,15}$/.test(phone)) {
+            logger.error(t("system.phoneNumberInvalid", { number: phone }));
+            return { sock, store };
+        }
+        // Allow the socket to handshake before requesting the pairing code
+        setTimeout(async () => {
+            try {
+                const code = await sock.requestPairingCode(phone);
+                logger.info(t("system.pairingCodeTitle"));
+                logger.info(t("system.pairingCodeValue", { code }));
+                logger.info(t("system.pairingCodeInstructions"));
+            }
+            catch (e) {
+                logger.error(`[baileysSock] Pairing code request failed: ${e.message}`);
+            }
+        }, 3000);
+    }
+    return { sock, store };
+}
+/**
+ * Normalize a Baileys JID to the @c.us format used in ManyBot configs.
+ * Groups (@g.us) and broadcasts are passed through unchanged.
+ *
+ * @param {string} jid
+ * @returns {string}
+ */
+export function normalizeJid(jid) {
+    if (!jid)
+        return jid;
+    return jid
+        .replace(/@s\.whatsapp\.net$/, "@c.us")
+        .replace(/:\d+@/, "@");
+}
+/**
+ * Minimal PresenceCapable view over a raw socket. Transitional shim used
+ * by kernel code that still works with a raw sock instead of a full
+ * PlatformAdapter — goes away once that code is migrated.
+ *
+ * @param {WASocket} sock
+ * @returns {PresenceCapable}
+ */
+export function toPresenceCapable(sock) {
+    return {
+        capabilities: new CapabilitySet(["presence"]),
+        setPresence: (chatId, state) => sock.sendPresenceUpdate(state, chatId),
+    };
+}

package/dist/i18n/index.js

@@ -0,0 +1,202 @@
+/**
+ * i18n/index.ts
+ *
+ * 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) ?? null;
+    }
+    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 (e) {
+        console.error(`[i18n] Failed to load locale ${lang}:`, e.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.ts";
+ *   const { t } = createPluginT(import.meta.url);
+ *
+ * Folder structure:
+ *   myPlugin/
+ *     index.ts
+ *     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/dist/kernel/pluginApi.js

@@ -0,0 +1,11 @@
+/**
+ * kernel/pluginApi.ts (DEPRECATED)
+ *
+ * This file is now a re-export from the WhatsApp driver.
+ * Plugins should continue to work without any changes.
+ *
+ * All logic is now in: drivers/whatsapp/api/
+ * This file exists for backward compatibility.
+ */
+// Re-export everything from the WhatsApp driver's plugin API
+export * from "#drivers/whatsapp/api/index.js";