@manybot/manybot 5.1.0 → 5.2.1

package/README.md

@@ -6,7 +6,7 @@
 ![npm 9+](https://img.shields.io/badge/npm-9+-CB3837?logo=npm&logoColor=white)
 ![GPL v3](https://img.shields.io/badge/License-GPL--v3-blue.svg)
 ![Linux](https://img.shields.io/badge/Linux%20%7C%20Windows-lightgrey)
-![whatsapp-web.js](https://img.shields.io/badge/WhatsApp-25D366?logo=whatsapp&logoColor=white)
+![Baileys](https://img.shields.io/badge/WhatsApp-25D366?logo=whatsapp&logoColor=white)
 
 </div>
 
@@ -27,9 +27,9 @@ npm install -g @manybot/manyplug
 manybot
 ```
 
-On first run, a configuration file is created at `~/.manybot/manybot.conf`. Edit it to set up your preferences and list the plugins you want to load.
+On first run, a configuration file is created at `~/.manybot/manybot.toml`. Edit it to set up your preferences.
 
-For detailed setup instructions, see the **[documentation](https://manybot.stxerr.dev/docs/)**.
+For detailed setup instructions, see the **[documentation](https://manybot.org/docs/)**.
 
 ## Plugins
 
@@ -39,16 +39,14 @@ ManyBot's functionality comes from plugins. Install them with ManyPlug:
 manyplug install <plugin-name>
 ```
 
-Browse available plugins at **[manybot.stxerr.dev/plugins](https://manybot.stxerr.dev/plugins/)**.
-
-Want to build your own? The plugin API lets you add commands and features without touching the bot's core - *documentation coming soon*.
+Browse available plugins at **[manybot.org/plugins](https://manybot.org/plugins/)**.
 
 ## Contributing
 
 All kinds of contributions are welcome:
 
 - **Bug reports and feature requests**: open an issue on GitHub or Codeberg
-- **Code**: pull requests are welcome on [GitHub](https://github.com/many-bot/manybot) or [Codeberg](https://codeberg.org/many-bot/manybot); patches by email (`devel+manybot@stxerr.dev`) are also accepted - subscribe to the mailing list [here](https://list.stxerr.dev).
+- **Code**: pull requests are welcome on [GitHub](https://github.com/many-bot/manybot) or [Codeberg](https://codeberg.org/many-bot/manybot); patches by email (`devel+manybot.org`) are also accepted - subscribe to the mailing list [here](https://list.stxerr.dev).
 - **Plugins**: submit your plugin to [manyplug-repo](https://github.com/many-bot/manyplug-repo), which has instructions on how to do it
 - **Anything else**: suggestions, translations, documentation fixes - reach out by email or open an issue
 

package/dist/client/banner.js

@@ -0,0 +1,35 @@
+const C = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    blue: "\x1b[94m",
+    magenta: "\x1b[95m",
+    cyan: "\x1b[96m",
+    gray: "\x1b[90m",
+    yellow: "\x1b[93m",
+};
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import path from "path";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const v = JSON.parse(readFileSync(path.join(__dirname, "../../package.json"), "utf8")).version;
+export function printBanner() {
+    const banner = [
+        `                             _           _  `,
+        `                            | |         | | `,
+        ` _ __ ___   __ _ _ __  _   _| |__   ___ | |_`,
+        `| '_ \` _ \\ / _\` | '_ \\| | | | '_ \\ / _ \\| __`,
+        `| | | | | | (_| | | | | |_| | |_) | (_) | |_`,
+        `|_| |_| |_|\\__,_|_| |_|\\__, |_.__/ \\___/ \\__`,
+        `                        __/ |               `,
+        ` ${v}                 |___/                `
+    ];
+    console.log(`${C.bold}${C.blue}`);
+    console.log(banner.join("\n"));
+    console.log(C.reset);
+    console.log(`  made with ${C.magenta}<3${C.reset} by ${C.bold}${C.cyan}SyntaxError!${C.reset} ${C.gray}<me@stxerr.dev>${C.reset}`);
+    console.log();
+    console.log(`  ${C.gray}website${C.reset} : ${C.yellow}https://manybot.org${C.reset}`);
+    console.log(`  ${C.gray}github ${C.reset} : ${C.yellow}https://github.com/many-bot${C.reset}`);
+    console.log();
+}

package/dist/client/store.js

@@ -0,0 +1,135 @@
+/**
+ * store.ts
+ *
+ * Minimal in-memory store for chats, contacts, and messages.
+ * Replaces the removed makeInMemoryStore from Baileys 6.7+.
+ *
+ * Only tracks what the ManyBot kernel actually needs:
+ *   - chat names (for display and for building WAChat adapters)
+ *   - contact names / notify (pushname) (for ctx.contacts)
+ *   - messages by JID + ID (for poll vote decryption)
+ */
+// ── Factory ───────────────────────────────────────────────────────────────────
+/**
+ * Create a new BotStore instance.
+ * One store is shared across reconnects — bind it to each new socket.
+ */
+export function createStore() {
+    const chatsMap = new Map();
+    const contacts = {};
+    const messages = new Map();
+    // @lid JID → traditional @s.whatsapp.net JID, learned from contact and
+    // message-key pairs (Baileys exposes both forms during the LID rollout).
+    const lidMap = new Map();
+    function learnLid(lid, pn) {
+        if (lid && pn && lid.endsWith("@lid") && !pn.endsWith("@lid"))
+            lidMap.set(lid, pn);
+    }
+    function resolveJid(jid) {
+        if (!jid || !jid.endsWith("@lid"))
+            return jid;
+        return lidMap.get(jid) ?? jid;
+    }
+    // Max messages kept per chat (prevents unbounded memory growth)
+    const MAX_MSGS_PER_CHAT = 200;
+    function upsertChat(chat) {
+        const name = chat.name ?? chat.id.split("@")[0];
+        chatsMap.set(chat.id, { id: chat.id, name });
+    }
+    function upsertContact(contact) {
+        contacts[contact.id] = {
+            id: contact.id,
+            name: contact.name,
+            notify: contact.notify,
+            verifiedName: contact.verifiedName,
+        };
+        // Baileys' Contact carries both the traditional JID (id) and the LID
+        // (lid) once known — learn the mapping either direction.
+        const lidField = contact.lid;
+        learnLid(lidField, contact.id);
+        learnLid(contact.id, lidField);
+    }
+    function storeMessage(msg) {
+        const jid = msg.key.remoteJid;
+        const id = msg.key.id;
+        if (!jid || !id)
+            return;
+        if (!messages.has(jid))
+            messages.set(jid, new Map());
+        const chatMsgs = messages.get(jid);
+        chatMsgs.set(id, msg);
+        // Evict oldest entries if over limit
+        if (chatMsgs.size > MAX_MSGS_PER_CHAT) {
+            const oldest = chatMsgs.keys().next().value;
+            if (typeof oldest === "string")
+                chatMsgs.delete(oldest);
+        }
+    }
+    function bind(ev) {
+        ev.on("chats.upsert", (newChats) => {
+            for (const chat of newChats)
+                upsertChat(chat);
+        });
+        ev.on("chats.update", (updates) => {
+            for (const update of updates) {
+                if (!update.id)
+                    continue;
+                const existing = chatsMap.get(update.id);
+                const name = update.name;
+                if (existing && name)
+                    existing.name = name;
+            }
+        });
+        ev.on("contacts.upsert", (newContacts) => {
+            for (const contact of newContacts)
+                upsertContact(contact);
+        });
+        ev.on("contacts.update", (updates) => {
+            for (const update of updates) {
+                if (!update.id)
+                    continue;
+                contacts[update.id] = { ...contacts[update.id], ...update };
+                const lidField = update.lid;
+                learnLid(lidField, update.id);
+                learnLid(update.id, lidField);
+            }
+        });
+        ev.on("messages.upsert", ({ messages: msgs }) => {
+            for (const msg of msgs) {
+                storeMessage(msg);
+                const key = msg.key;
+                learnLid(key.participantAlt, key.participant);
+                learnLid(key.remoteJidAlt, key.remoteJid);
+            }
+        });
+        ev.on("messages.update", (updates) => {
+            for (const { key, update } of updates) {
+                if (!key.remoteJid || !key.id)
+                    continue;
+                const existing = messages.get(key.remoteJid)?.get(key.id);
+                if (!existing)
+                    continue;
+                // Poll votes: pollUpdates on this event are only the NEW entries,
+                // not the full history — must be accumulated, never overwritten,
+                // or getAggregateVotesInPollMessage() only ever sees the latest vote.
+                const incoming = update.pollUpdates;
+                const merged = { ...existing, ...update };
+                if (incoming?.length) {
+                    const prior = existing.pollUpdates ?? [];
+                    merged.pollUpdates = [...prior, ...incoming];
+                }
+                messages.get(key.remoteJid).set(key.id, merged);
+            }
+        });
+    }
+    return {
+        chats: {
+            get: (id) => chatsMap.get(id) ?? null,
+            all: () => [...chatsMap.values()],
+        },
+        contacts,
+        messages,
+        resolveJid,
+        bind,
+    };
+}

package/dist/config.js

@@ -0,0 +1,363 @@
+/**
+ * config.ts
+ *
+ * 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
+ *
+ * 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";
+// ---------------------------------------------------------------------------
+// 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)
+// ---------------------------------------------------------------------------
+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;
+    return value;
+}
+function stripInlineComment(line) {
+    let result = "";
+    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 (ch === "#" && !quote)
+            break;
+        result += ch;
+    }
+    return result.trim();
+}
+function parseConf(raw) {
+    const lines = raw.split(/\r?\n/);
+    const mergedLines = [];
+    let insideList = false;
+    let buffer = "";
+    for (let line of lines) {
+        line = stripInlineComment(line);
+        if (!line)
+            continue;
+        if (!insideList) {
+            if (/=\s*\[$/.test(line)) {
+                insideList = true;
+                buffer = line;
+            }
+            else {
+                mergedLines.push(line);
+            }
+        }
+        else {
+            buffer += " " + line;
+            if (line.includes("]")) {
+                mergedLines.push(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 (value.startsWith("[") && value.endsWith("]")) {
+            config[key] = value
+                .slice(1, -1)
+                .split(",")
+                .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((v) => JSON.stringify(v)).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 (e) {
+        if (e.code !== "ENOENT")
+            logger.warn(`Error reading ${file}: ${e.message}`);
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Bootstrap: ensure at least one config file exists
+// ---------------------------------------------------------------------------
+/**
+ * Detects the OS locale without depending on a single env var, since LANG
+ * isn't reliably set on macOS GUI sessions or Windows. Only used to pick
+ * the language of the bootstrap config file — after that, LANGUAGE in
+ * manybot.toml is the single source of truth.
+ */
+function detectSystemLang() {
+    try {
+        const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+        if (locale)
+            return locale.split("-")[0].toLowerCase();
+    }
+    catch {
+        // Intl unavailable — fall through to env vars
+    }
+    const envLocale = process.env.LC_ALL || process.env.LC_MESSAGES || process.env.LANG || process.env.LANGUAGE;
+    if (envLocale)
+        return envLocale.split(/[_.]/)[0].toLowerCase();
+    return "en";
+}
+const DEFAULT_TOML_EN = `# ManyBot configuration file
+# See https://manybot.org/docs/config to learn more
+
+CLIENT_ID    = "manybot"
+CMD_PREFIX   = "!"
+CHATS        = []
+LANGUAGE     = "en"
+PHONE_NUMBER = ""
+
+# How to connect the first time: "qr" (scan with WhatsApp on your phone)
+# or "phone" (receive a pairing code on the number set in PHONE_NUMBER).
+# Leave blank to choose interactively on first run — the choice is then
+# saved here automatically.
+LOGIN_METHOD = ""
+
+# JID of a single chat where the bot is allowed to respond to messages
+# sent by yourself (fromMe) — useful for testing commands without
+# affecting other conversations. In every other chat, fromMe messages
+# are always ignored.
+# Example: TEST_CHAT = "5511999999999@c.us"
+TEST_CHAT    = ""
+`;
+const DEFAULT_TOML_PT = `# Arquivo de configuração do ManyBot
+# Veja https://manybot.org/docs/config para saber mais
+
+CLIENT_ID    = "manybot"
+CMD_PREFIX   = "!"
+CHATS        = []
+LANGUAGE     = "pt"
+PHONE_NUMBER = ""
+
+# Como conectar pela primeira vez: "qr" (escaneie com o WhatsApp no celular)
+# ou "phone" (recebe um código de pareamento no número definido em
+# PHONE_NUMBER). Deixe em branco para escolher interativamente na primeira
+# execução — a escolha é salva aqui automaticamente.
+LOGIN_METHOD = ""
+
+# JID de um único chat onde o bot pode responder a mensagens enviadas por
+# você mesmo (fromMe) — útil para testar comandos sem afetar outras
+# conversas. Em qualquer outro chat, mensagens fromMe são sempre ignoradas.
+# Exemplo: TEST_CHAT = "5511999999999@c.us"
+TEST_CHAT    = ""
+`;
+const DEFAULT_TOML = detectSystemLang() === "pt" ? DEFAULT_TOML_PT : DEFAULT_TOML_EN;
+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 — legacy .conf
+// ---------------------------------------------------------------------------
+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 (e) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        logger.warn(`Error parsing ${label}: ${err.message}`);
+        return {};
+    }
+}
+tomlLayer = {
+    ...await loadToml(TOML_CONFIG_FILE, "manybot.toml"),
+    ...await loadToml(TOML_PLUGIN_FILE, "manyplug.toml"),
+};
+const DEFAULTS = {
+    CMD_PREFIX: "!",
+    CLIENT_ID: "manybot",
+    CHATS: [],
+    PLUGINS: [],
+    LANGUAGE: "en",
+    PHONE_NUMBER: null,
+    PLATFORM: "whatsapp",
+    TEST_CHAT: null,
+    LOGIN_METHOD: null,
+};
+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;
+    if (cfg.TEST_CHAT === "")
+        cfg.TEST_CHAT = null;
+    // Anything other than "phone"/"qr" is treated as "not configured yet",
+    // so a typo or leftover garbage value falls back to the interactive
+    // prompt instead of silently misbehaving.
+    if (cfg.LOGIN_METHOD !== "phone" && cfg.LOGIN_METHOD !== "qr") {
+        cfg.LOGIN_METHOD = null;
+    }
+    return cfg;
+}
+export const CONFIG = normalize({
+    ...DEFAULTS,
+    ...legacyLayer, // legacy .conf overrides defaults
+    ...tomlLayer, // TOML overrides legacy .conf
+});
+export async function reloadConfig() {
+    const newTomlLayer = {
+        ...await loadToml(TOML_CONFIG_FILE, "manybot.toml"),
+        ...await loadToml(TOML_PLUGIN_FILE, "manyplug.toml"),
+    };
+    const newConfig = normalize({
+        ...DEFAULTS,
+        ...legacyLayer,
+        ...newTomlLayer,
+    });
+    Object.assign(CONFIG, newConfig);
+    // Mutate array exports to propagate changes
+    PLUGINS.length = 0;
+    PLUGINS.push(...(CONFIG.PLUGINS || []));
+    CHATS.length = 0;
+    CHATS.push(...(CONFIG.CHATS || []));
+}
+// ---------------------------------------------------------------------------
+// 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;
+export const PLUGINS = CONFIG.PLUGINS;
+export const LANGUAGE = CONFIG.LANGUAGE;
+export const PHONE_NUMBER = CONFIG.PHONE_NUMBER;
+export const PLATFORM = CONFIG.PLATFORM;
+export const TEST_CHAT = CONFIG.TEST_CHAT;
+export const LOGIN_METHOD = CONFIG.LOGIN_METHOD;
+/**
+ * Writes a single value back to manybot.toml without rewriting the whole
+ * file (preserves comments and the rest of the content). If the key
+ * already exists, its line is replaced; otherwise the line is appended
+ * at the end. Also updates the in-memory `CONFIG`, so the change is
+ * reflected within the same run (needed by the interactive login flow,
+ * which runs before any reload).
+ *
+ * Known limitation: since CLIENT_ID, PHONE_NUMBER, etc. above are const
+ * primitives captured at module load time, they only reflect the new
+ * value after the process restarts — the same limitation already
+ * applied to the rest of this file. Code that needs the updated value
+ * within the same run (like the login flow itself) should read from
+ * `CONFIG.<KEY>` directly.
+ */
+export async function persistConfigValue(key, value) {
+    const raw = (await readFileSafe(TOML_CONFIG_FILE)) ?? "";
+    const newLine = `${key} = "${escapeTomlString(value)}"`;
+    const lineRe = new RegExp(`^${key}\\s*=.*$`, "m");
+    const updated = lineRe.test(raw)
+        ? raw.replace(lineRe, newLine)
+        : `${raw.trimEnd()}\n${newLine}\n`;
+    await fs.writeFile(TOML_CONFIG_FILE, updated, "utf8");
+    CONFIG[key] = value;
+}
+export const PATHS = {
+    HOME: CONFIG_DIR,
+    CONFIG_FILE,
+    PLUGIN_FILE,
+    TOML_CONFIG_FILE,
+    TOML_PLUGIN_FILE,
+};

package/dist/core/adapter.js

@@ -0,0 +1,12 @@
+/**
+ * core/adapter.ts
+ *
+ * Contract every messaging driver (whatsapp, discord, telegram, ...)
+ * must implement. The kernel talks only to this interface, never to a
+ * driver's native client.
+ *
+ * Required methods must work on every driver. Optional methods are gated
+ * by `capabilities.has(...)` before being called - a driver that doesn't
+ * support a capability simply omits the method.
+ */
+export {};

package/dist/core/capabilities.js

@@ -0,0 +1,16 @@
+/**
+ * core/capabilities.ts
+ *
+ * Optional features a driver may or may not support. The kernel checks
+ * `adapter.capabilities.has(...)` before calling an optional method,
+ * instead of assuming every platform behaves like WhatsApp.
+ */
+export class CapabilitySet {
+    set;
+    constructor(capabilities) {
+        this.set = new Set(capabilities);
+    }
+    has(capability) {
+        return this.set.has(capability);
+    }
+}

package/dist/core/types.js

@@ -0,0 +1,6 @@
+/**
+ * core/types.ts
+ *
+ * Common domain models shared across core, drivers, and plugin boundaries.
+ */
+export {};

package/dist/download/queue.js

@@ -0,0 +1,49 @@
+/**
+ * src/download/queue.ts
+ *
+ * Sequential execution queue for heavy jobs (downloads, conversions).
+ * Ensures only one job runs at a time — without overloading yt-dlp or ffmpeg.
+ *
+ * Plugin passes a `workFn` that does everything: download, convert, send.
+ * Queue only handles sequence and error handling.
+ *
+ * Usage:
+ *   import { enqueue } from "#download";
+ *   enqueue(async () => { ... all plugin logic ... }, onError);
+ */
+import { logger } from "#logger";
+import { t } from "#i18n";
+let queue = [];
+let processing = false;
+/**
+ * Add a job to the queue and start processing if idle.
+ * @param workFn  All plugin logic — runs exclusively until resolved.
+ * @param errorFn Called with the thrown error if workFn rejects.
+ */
+export function enqueue(workFn, errorFn) {
+    queue.push({ workFn, errorFn });
+    if (!processing)
+        processQueue();
+}
+async function processQueue() {
+    processing = true;
+    while (queue.length) {
+        const job = queue.shift();
+        if (job)
+            await processJob(job);
+    }
+    processing = false;
+}
+async function processJob({ workFn, errorFn }) {
+    try {
+        await workFn();
+    }
+    catch (e) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        logger.error(t("system.downloadJobFailed", { message: err.message }));
+        try {
+            await errorFn(err instanceof Error ? err : new Error(String(err)));
+        }
+        catch { }
+    }
+}

package/dist/drivers/index.js

@@ -0,0 +1,14 @@
+import { whatsappDriver } from "./whatsapp/index.js";
+import { PLATFORM } from "#config";
+import { applyPatches } from "./patches/index.js";
+applyPatches();
+const DRIVERS = {
+    whatsapp: whatsappDriver,
+};
+export function initializeSelectedDriver() {
+    const driver = DRIVERS[PLATFORM];
+    if (!driver) {
+        throw new Error(`Unsupported platform/driver: ${PLATFORM}`);
+    }
+    return driver;
+}

package/dist/drivers/patches/index.js

@@ -0,0 +1,9 @@
+import libsignal from "./libsignal.js";
+const patches = [
+    libsignal
+];
+export function applyPatches() {
+    for (const patch of patches) {
+        patch.apply();
+    }
+}