@manybot/manybot 5.7.0 → 5.9.0

package/README.md

@@ -18,8 +18,6 @@ Open-source framework for message automation, extensible via community plugins.
 
 - Node.js >= 24
 - npm >= 9
-- Go >= 1.23 (for whatsmeow driver)
-- protoc (for protobuf codegen)
 
 ## Getting started
 
@@ -39,7 +37,6 @@ On first run, a configuration file is created at `~/.manybot/manybot.toml`. Edit
 git clone <repo-url>
 cd dev
 npm install
-go build -o whatsmeow-service/bin/whatsmeow-service ./whatsmeow-service
 npm start
 ```
 
@@ -55,6 +52,34 @@ manyplug install <plugin-name>
 
 Browse available plugins at **[manybot.org/plugins](https://manybot.org/plugins/)**.
 
+## Testing
+
+ManyBot includes both local unit/contract tests and opt-in real WhatsApp integration tests:
+
+```bash
+# Run unit and mock contract test suite (fast, offline)
+npm test
+
+# Run all verification gates (typecheck + lint + unit tests)
+npm run check
+
+# Run real WhatsApp integration tests against a live account.
+# Requires: TEST_CHAT, MANYBOT_RUN_WHATSAPP_TESTS=1, and a saved
+# WhatsApp session in your CONFIG_DIR. The bare variant below
+# always skips every test (no live socket). Use `:local` to boot
+# the bot first — it preloads src/main.ts so the driver connects
+# before the test runner kicks in.
+TEST_CHAT="5516999999999" MANYBOT_RUN_WHATSAPP_TESTS=1 npm run test:integration:local
+
+# Manual smoke probe: connects, runs a few marker round-trips, and
+# prints the IContact shape (id / number / numberRaw / numberPretty /
+# country / countryCallingCode) returned by contacts.get(...) — useful
+# for verifying the LID-aware contact API against your real account
+# without the full test runner overhead.
+TEST_CHAT="5516999999999" MANYBOT_RUN_WHATSAPP_TESTS=1 \
+  node --import ./src/main.ts scripts/probe-contacts.mjs
+```
+
 ## Contributing
 
 All kinds of contributions are welcome:

package/dist/client/banner.js

@@ -10,10 +10,20 @@ const C = {
 import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
 import path from "path";
+import { getLogLevel } from "#logger";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const v = JSON.parse(readFileSync(path.join(__dirname, "../../package.json"), "utf8")).version;
+/**
+ * Startup ASCII banner. Optional — respects `LOG_LEVEL` (Phase 9): shown
+ * only at `"normal"`, silent at `"clean"`/`"minimal"` for users who prefer
+ * quiet logs. Caller is responsible for only invoking this once per process
+ * (see `drivers/baileys/index.ts`'s `bannerShown` guard) — reconnects
+ * shouldn't reprint it.
+ */
 export function printBanner() {
+    if (getLogLevel() !== "normal")
+        return;
     const banner = [
         `                             _           _  `,
         `                            | |         | | `,

package/dist/client/banner.test.js

@@ -0,0 +1,31 @@
+import test, { describe, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { printBanner } from "./banner.js";
+import { setLogLevel } from "#logger";
+describe("printBanner LOG_LEVEL gating", () => {
+    const originalLog = console.log;
+    let lines;
+    beforeEach(() => {
+        lines = [];
+        console.log = (...a) => { lines.push(a.join(" ")); };
+    });
+    afterEach(() => {
+        console.log = originalLog;
+        setLogLevel("normal");
+    });
+    test("prints at normal", () => {
+        setLogLevel("normal");
+        printBanner();
+        assert.ok(lines.length > 0);
+    });
+    test("stays silent at clean", () => {
+        setLogLevel("clean");
+        printBanner();
+        assert.equal(lines.length, 0);
+    });
+    test("stays silent at minimal", () => {
+        setLogLevel("minimal");
+        printBanner();
+        assert.equal(lines.length, 0);
+    });
+});

package/dist/client/store.js

@@ -18,6 +18,7 @@
  * @whiskeysockets/baileys import line never leaks past the driver
  * boundary.
  */
+import { normalizeJid } from "#drivers/jid.js";
 // ── Factory ───────────────────────────────────────────────────────────────────
 /**
  * Create a new BotStore instance.
@@ -30,9 +31,23 @@ export function createStore() {
     // @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();
+    // traditional @s.whatsapp.net JID → @lid JID, reverse mapping for lookups.
+    const pnMap = new Map();
     function learnLid(lid, pn) {
-        if (lid && pn && lid.endsWith("@lid") && !pn.endsWith("@lid"))
+        if (lid && pn && lid.endsWith("@lid") && !pn.endsWith("@lid")) {
+            // lidMap keeps the wire-format value as given — resolveJid()
+            // consumers (e.g. adapter.ts building self/participant candidates
+            // via jidNormalizedUser) expect the raw "@s.whatsapp.net" shape.
             lidMap.set(lid, pn);
+            // pnMap's key is canonicalized to ManyBot's internal "@c.us" form
+            // so a lookup matches regardless of which format the caller has on
+            // hand — callers deep in the driver (adapter.ts) query it with raw
+            // wire JIDs, while callers in the plugin-facing API (index.ts) query
+            // it with already-normalized JIDs. Without this, pn entries learned
+            // in one format silently never matched a resolvePn() call made in
+            // the other.
+            pnMap.set(normalizeJid(pn), lid);
+        }
     }
     function resolveJid(jid) {
         if (!jid || !jid.endsWith("@lid"))
@@ -40,15 +55,54 @@ export function createStore() {
         return lidMap.get(jid) ?? jid;
     }
     function forgetLid(lid) {
+        const pn = lidMap.get(lid);
+        if (pn)
+            pnMap.delete(normalizeJid(pn));
         lidMap.delete(lid);
     }
+    function resolvePn(pn) {
+        if (!pn)
+            return null;
+        return pnMap.get(normalizeJid(pn)) ?? null;
+    }
+    // Coerce the various shapes Baileys delivers `ephemeralExpiration` in
+    // (string-numbered from the wire, `null` when the timer was cleared,
+    // or absent entirely) into a plain finite number. Anything we can't
+    // parse becomes 0 — the wire convention for "no disappearing timer".
+    function normalizeExpiration(raw) {
+        if (raw === null || raw === undefined)
+            return 0;
+        const n = Number(raw);
+        return Number.isFinite(n) && n >= 0 ? n : 0;
+    }
+    function setChatEphemeralExpiration(jid, seconds) {
+        if (!jid)
+            return;
+        const existing = chatsMap.get(jid);
+        const next = normalizeExpiration(seconds);
+        if (existing) {
+            existing.ephemeralExpiration = next;
+        }
+        else {
+            chatsMap.set(jid, { id: jid, name: jid.split("@")[0], ephemeralExpiration: next });
+        }
+    }
     // Max messages kept per chat (prevents unbounded memory growth)
     const MAX_MSGS_PER_CHAT = 200;
     function upsertChat(chat) {
         if (!chat.id)
             return;
         const name = chat.name ?? chat.id.split("@")[0];
-        chatsMap.set(chat.id, { id: chat.id, name });
+        const rawExp = chat.ephemeralExpiration;
+        const existing = chatsMap.get(chat.id);
+        chatsMap.set(chat.id, {
+            id: chat.id,
+            name,
+            // Preserve a previously-learned timer if this upsert doesn't carry
+            // one (chats.upsert often ships without ephemeralExpiration — the
+            // value arrives later via chats.update or an ephemeralMessage).
+            ephemeralExpiration: rawExp !== undefined ? normalizeExpiration(rawExp) : (existing?.ephemeralExpiration ?? 0),
+        });
     }
     function upsertContact(contact) {
         // Don't let a later, poorer sync round (e.g. a bare history-sync stub)
@@ -124,9 +178,17 @@ export function createStore() {
                 if (!update.id)
                     continue;
                 const existing = chatsMap.get(update.id);
-                const name = update.name;
-                if (existing && name)
-                    existing.name = name;
+                if (!existing)
+                    continue;
+                const u = update;
+                if (u.name)
+                    existing.name = u.name;
+                // Baileys sends `ephemeralExpiration: null` to signal the timer
+                // was cleared — store 0 in that case so a later `chats.update`
+                // carrying a positive value can take over again.
+                if ("ephemeralExpiration" in u) {
+                    existing.ephemeralExpiration = normalizeExpiration(u.ephemeralExpiration);
+                }
             }
         });
         ev.on("contacts.upsert", (newContacts) => {
@@ -144,8 +206,19 @@ export function createStore() {
             }
         });
         ev.on("messages.upsert", ({ messages: msgs }) => {
-            for (const msg of msgs)
+            for (const msg of msgs) {
                 storeMessage(msg);
+                // Disappearing-message timer: when a message arrives wrapped in
+                // an `ephemeralMessage`, the inner contextInfo carries the
+                // per-message timer WhatsApp negotiated for the chat. Promote
+                // it to the chat-level entry so subsequent sends can pick it up
+                // without re-scanning every message.
+                const m = msg.message;
+                const expiration = m?.ephemeralMessage?.message?.extendedTextMessage?.contextInfo?.expiration;
+                if (expiration !== undefined && msg.key.remoteJid) {
+                    setChatEphemeralExpiration(msg.key.remoteJid, normalizeExpiration(expiration));
+                }
+            }
             capturePushNames(msgs);
         });
         ev.on("messages.update", (updates) => {
@@ -173,6 +246,7 @@ export function createStore() {
             chats: [...chatsMap.values()],
             contacts: { ...contacts },
             lidMap: [...lidMap.entries()],
+            pnMap: [...pnMap.entries()],
         };
     }
     function hydrate(snapshot) {
@@ -181,6 +255,15 @@ export function createStore() {
         for (const [id, contact] of Object.entries(snapshot.contacts ?? {})) {
             contacts[id] = { ...contacts[id], ...contact };
         }
+        // learnLid() always mirrors into both lidMap and pnMap, so replaying
+        // snapshot.lidMap alone fully reconstructs pnMap too — every pnMap
+        // entry has a corresponding lidMap entry, they're never written
+        // independently. snapshot.pnMap itself is redundant to replay here:
+        // it exists only so `toJSON()`'s output is self-describing/inspectable,
+        // and re-learning from it a second time would re-derive pnMap's key
+        // (already-canonicalized "@c.us" form) as if it were lidMap's raw
+        // wire-format value, corrupting the wire-format invariant lidMap's
+        // consumers (e.g. adapter.ts) depend on.
         for (const [lid, pn] of snapshot.lidMap ?? [])
             learnLid(lid, pn);
     }
@@ -194,6 +277,8 @@ export function createStore() {
         resolveJid,
         learnLid,
         forgetLid,
+        resolvePn,
+        setChatEphemeralExpiration,
         bind,
         toJSON,
         hydrate,

package/dist/client/store.test.js

@@ -0,0 +1,170 @@
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import test from "node:test";
+import { createStore } from "#client/store.js";
+test("store tracks disappearing-message timers from chats and message context", () => {
+    const store = createStore();
+    const ev = new EventEmitter();
+    store.bind(ev);
+    ev.emit("chats.upsert", [{ id: "chat@s.whatsapp.net", name: "Chat", ephemeralExpiration: "86400" }]);
+    assert.equal(store.chats.get("chat@s.whatsapp.net")?.ephemeralExpiration, 86400);
+    ev.emit("chats.update", [{ id: "chat@s.whatsapp.net", ephemeralExpiration: null }]);
+    assert.equal(store.chats.get("chat@s.whatsapp.net")?.ephemeralExpiration, 0);
+    ev.emit("messages.upsert", {
+        messages: [{
+                key: { id: "message", remoteJid: "chat@s.whatsapp.net" },
+                message: {
+                    ephemeralMessage: {
+                        message: { extendedTextMessage: { contextInfo: { expiration: "604800" } } },
+                    },
+                },
+            }],
+    });
+    assert.equal(store.chats.get("chat@s.whatsapp.net")?.ephemeralExpiration, 604800);
+});
+test("store keeps timers in snapshots and accepts a timer learned by metadata", () => {
+    const store = createStore();
+    store.setChatEphemeralExpiration("group@g.us", 7776000);
+    const snapshot = store.toJSON();
+    assert.equal(snapshot.chats[0]?.ephemeralExpiration, 7776000);
+    const hydrated = createStore();
+    hydrated.hydrate(snapshot);
+    assert.equal(hydrated.chats.get("group@g.us")?.ephemeralExpiration, 7776000);
+});
+test("store learns, resolves, and forgets LID to PN mappings", () => {
+    const store = createStore();
+    // Invalid or identity mappings are ignored
+    store.learnLid("invalid_jid", "551199999999@s.whatsapp.net");
+    store.learnLid("123@lid", "456@lid");
+    assert.equal(store.resolveJid("invalid_jid"), "invalid_jid");
+    assert.equal(store.resolveJid("123@lid"), "123@lid");
+    // Valid mapping is learned and resolved
+    store.learnLid("123456789@lid", "551199999999@s.whatsapp.net");
+    assert.equal(store.resolveJid("123456789@lid"), "551199999999@s.whatsapp.net");
+    // Non-LID JIDs are returned untouched
+    assert.equal(store.resolveJid("551188888888@s.whatsapp.net"), "551188888888@s.whatsapp.net");
+    // Forget LID removes mapping
+    store.forgetLid("123456789@lid");
+    assert.equal(store.resolveJid("123456789@lid"), "123456789@lid");
+});
+test("store preserves rich contact fields during updates", () => {
+    const store = createStore();
+    const ev = new EventEmitter();
+    store.bind(ev);
+    // Initial contact with full details
+    ev.emit("contacts.upsert", [
+        { id: "user1@s.whatsapp.net", name: "Alice", notify: "Alice N", verifiedName: "Alice Verified" }
+    ]);
+    let contact = store.contacts["user1@s.whatsapp.net"];
+    assert.equal(contact?.name, "Alice");
+    assert.equal(contact?.notify, "Alice N");
+    assert.equal(contact?.verifiedName, "Alice Verified");
+    // Poorer update (e.g., from a stub) should not wipe out previous fields
+    ev.emit("contacts.upsert", [
+        { id: "user1@s.whatsapp.net" }
+    ]);
+    contact = store.contacts["user1@s.whatsapp.net"];
+    assert.equal(contact?.name, "Alice");
+    assert.equal(contact?.notify, "Alice N");
+    assert.equal(contact?.verifiedName, "Alice Verified");
+});
+test("store captures pushName from messages and respects guards", () => {
+    const store = createStore();
+    const ev = new EventEmitter();
+    store.bind(ev);
+    ev.emit("messages.upsert", {
+        messages: [
+            // DM message from other person -> should capture
+            {
+                key: { id: "m1", remoteJid: "user2@s.whatsapp.net", fromMe: false },
+                pushName: "Bob",
+            },
+            // Message fromMe -> should NOT capture
+            {
+                key: { id: "m2", remoteJid: "user3@s.whatsapp.net", fromMe: true },
+                pushName: "SelfBot",
+            },
+            // Message in group -> captures participant
+            {
+                key: { id: "m3", remoteJid: "group1@g.us", participant: "user4@s.whatsapp.net", fromMe: false },
+                pushName: "Charlie",
+            },
+        ],
+    });
+    assert.equal(store.contacts["user2@s.whatsapp.net"]?.notify, "Bob");
+    assert.equal(store.contacts["user3@s.whatsapp.net"], undefined);
+    assert.equal(store.contacts["user4@s.whatsapp.net"]?.notify, "Charlie");
+});
+test("store evicts oldest messages when exceeding MAX_MSGS_PER_CHAT (200)", () => {
+    const store = createStore();
+    const ev = new EventEmitter();
+    store.bind(ev);
+    const jid = "chat-flood@s.whatsapp.net";
+    const messages = [];
+    for (let i = 1; i <= 205; i++) {
+        messages.push({
+            key: { id: `msg-${i}`, remoteJid: jid },
+            message: { conversation: `text ${i}` },
+        });
+    }
+    ev.emit("messages.upsert", { messages });
+    const chatMap = store.messages.get(jid);
+    assert.ok(chatMap);
+    assert.equal(chatMap?.size, 200);
+    assert.equal(chatMap?.has("msg-1"), false); // evicted
+    assert.equal(chatMap?.has("msg-5"), false); // evicted
+    assert.equal(chatMap?.has("msg-6"), true); // kept
+    assert.equal(chatMap?.has("msg-205"), true); // kept
+});
+test("store accumulates poll updates on messages.update", () => {
+    const store = createStore();
+    const ev = new EventEmitter();
+    store.bind(ev);
+    const jid = "poll-chat@s.whatsapp.net";
+    const msgId = "poll-1";
+    // Initial poll message
+    ev.emit("messages.upsert", {
+        messages: [
+            {
+                key: { id: msgId, remoteJid: jid },
+                message: { pollCreationMessage: { name: "Question?" } },
+            }
+        ]
+    });
+    // First vote update
+    ev.emit("messages.update", [
+        {
+            key: { id: msgId, remoteJid: jid },
+            update: { pollUpdates: [{ voter: "user1" }] },
+        }
+    ]);
+    // Second vote update
+    ev.emit("messages.update", [
+        {
+            key: { id: msgId, remoteJid: jid },
+            update: { pollUpdates: [{ voter: "user2" }] },
+        }
+    ]);
+    const stored = store.messages.get(jid)?.get(msgId);
+    assert.ok(stored);
+    assert.equal(stored.pollUpdates?.length, 2);
+    assert.deepEqual(stored.pollUpdates, [{ voter: "user1" }, { voter: "user2" }]);
+});
+test("store processes messaging-history.set backfill", () => {
+    const store = createStore();
+    const ev = new EventEmitter();
+    store.bind(ev);
+    ev.emit("messaging-history.set", {
+        chats: [{ id: "hist-chat@s.whatsapp.net", name: "History Chat" }],
+        contacts: [{ id: "hist-user@s.whatsapp.net", name: "Dave" }],
+        messages: [
+            {
+                key: { id: "m-hist", remoteJid: "hist-chat@s.whatsapp.net", fromMe: false },
+                pushName: "Dave Push",
+            }
+        ],
+    });
+    assert.equal(store.chats.get("hist-chat@s.whatsapp.net")?.name, "History Chat");
+    assert.equal(store.contacts["hist-user@s.whatsapp.net"]?.name, "Dave");
+    assert.equal(store.contacts["hist-chat@s.whatsapp.net"]?.notify, "Dave Push");
+});

package/dist/config.js

@@ -25,7 +25,7 @@ import { t } from "#i18n";
 // ---------------------------------------------------------------------------
 // Paths
 // ---------------------------------------------------------------------------
-export const CONFIG_DIR = path.join(os.homedir(), ".manybot");
+export const CONFIG_DIR = process.env.MANYBOT_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. */
@@ -210,6 +210,11 @@ PHONE_NUMBER  = ""
 # but reduce the risk of WhatsApp flagging the account.
 SECURITY_LEVEL = "medium"
 
+# Startup log verbosity: "normal" (everything), "clean" (hides routine
+# chatter, keeps success/warnings/errors), or "minimal" (warnings/errors
+# only — silent on the happy path).
+LOG_LEVEL = "normal"
+
 # ── Local alerts (critical warnings, update notices) ──────────────────────
 # Phone number (or full JID) that receives WhatsApp alerts when the bot
 # itself is up — e.g. "5511999999999" or "5511999999999@s.whatsapp.net".
@@ -248,18 +253,6 @@ LOGIN_METHOD = ""
 STATUS_ENABLED = true
 STATUS_PORT    = 8080
 
-# ── Driver selection (advanced) ────────────────────────────────────────────
-# ManyBot can fall back from a primary driver to a secondary one when the
-# primary fails to confirm a send. Today only Baileys is wired in; leave
-# driver_whatsmeow_enabled = false to disable the fallback entirely (no
-# extra processes are spawned, no sockets are opened).
-driver_primary = "baileys"
-driver_fallback_cooldown_ms = 60000
-driver_verify_window_ms = [500, 1000, 1500, 2500, 5000]
-driver_baileys_enabled = true
-driver_whatsmeow_enabled = false
-driver_whatsmeow_grpc_address = "localhost:50051"
-driver_whatsmeow_binary_path = ""
 `;
 const DEFAULT_TOML_PT = `# Arquivo de configuração do ManyBot
 # Veja https://manybot.org/docs/config para saber mais
@@ -276,6 +269,11 @@ PHONE_NUMBER  = ""
 # maiores), mas reduzem o risco do WhatsApp sinalizar a conta.
 SECURITY_LEVEL = "medium"
 
+# Verbosidade dos logs de inicialização: "normal" (tudo), "clean" (esconde
+# ruído de rotina, mantém sucesso/avisos/erros), ou "minimal" (só avisos
+# e erros — silencioso quando está tudo bem).
+LOG_LEVEL = "normal"
+
 # ── Avisos locais (alertas críticos, aviso de update) ──────────────────────
 # Número de telefone (ou JID completo) que recebe alertas via WhatsApp
 # quando o bot está de pé — ex. "5511999999999" ou
@@ -316,18 +314,6 @@ LOGIN_METHOD = ""
 STATUS_ENABLED = true
 STATUS_PORT    = 8080
 
-# ── Seleção de driver (avançado) ───────────────────────────────────────────
-# ManyBot pode cair de um driver primário pra um secundário quando o
-# primário não confirma um envio. Hoje só Baileys está ligado; deixe
-# driver_whatsmeow_enabled = false pra desligar o fallback por completo
-# (nenhum processo extra é spawnado, nenhum socket é aberto).
-driver_primary = "baileys"
-driver_fallback_cooldown_ms = 60000
-driver_verify_window_ms = [500, 1000, 1500, 2500, 5000]
-driver_baileys_enabled = true
-driver_whatsmeow_enabled = false
-driver_whatsmeow_grpc_address = "localhost:50051"
-driver_whatsmeow_binary_path = ""
 `;
 const DEFAULT_TOML = detectSystemLang() === "pt" ? DEFAULT_TOML_PT : DEFAULT_TOML_EN;
 await fs.mkdir(CONFIG_DIR, { recursive: true });
@@ -368,9 +354,11 @@ const DEFAULTS = {
     CHATS: [],
     EXCLUDE_CHATS: [],
     SECURITY_LEVEL: "medium",
+    LOG_LEVEL: "normal",
     PLUGINS: [],
     LANGUAGE: "en",
     PHONE_NUMBER: null,
+    OWNER_NUMBER: null,
     LOGIN_METHOD: null,
     ADMIN_JID: "",
     SMTP_HOST: "",
@@ -390,7 +378,6 @@ const DEFAULTS = {
         fallbackCooldownMs: 60000,
         verifyWindowMs: [500, 1000, 1500, 2500, 5000],
         baileys: { enabled: true },
-        whatsmeow: { enabled: false, grpcAddress: "localhost:50051", binaryPath: "" },
     },
 };
 function normalize(cfg) {
@@ -398,6 +385,13 @@ function normalize(cfg) {
     // can always do a simple truthiness check regardless of config source.
     if (cfg.PHONE_NUMBER === "")
         cfg.PHONE_NUMBER = null;
+    const rawOwner = cfg.owner_number ?? cfg.OWNER_NUMBER;
+    if (typeof rawOwner === "string" && rawOwner.trim().length > 0) {
+        cfg.OWNER_NUMBER = rawOwner.trim();
+    }
+    else {
+        cfg.OWNER_NUMBER = 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.
@@ -407,6 +401,9 @@ function normalize(cfg) {
     if (!["low", "medium", "high"].includes(cfg.SECURITY_LEVEL)) {
         cfg.SECURITY_LEVEL = "medium";
     }
+    if (!["normal", "clean", "minimal"].includes(cfg.LOG_LEVEL)) {
+        cfg.LOG_LEVEL = "normal";
+    }
     // Legacy .conf values arrive as strings; TOML gives real types already —
     // Number()/coercion here is a no-op for the TOML path.
     cfg.SMTP_PORT = Number(cfg.SMTP_PORT) || 587;
@@ -423,8 +420,8 @@ function normalize(cfg) {
     cfg.STATUS_PORT = Number(cfg.STATUS_PORT) || 8080;
     // drivers.* — the fallback guard and DriverManager read these at every
     // send. The TOML surface is flat lowercase keys (driver_primary,
-    // driver_baileys_enabled, driver_whatsmeow_*, …) so it matches the
-    // rest of the file; the nested `cfg.drivers` object is rebuilt here
+    // driver_baileys_enabled, …) — same style as the
+    // rest of this file. `normalize()` rebuilds the nested object below
     // from those flat keys so callers (main.ts, sendFallbackGuard.ts,
     // supervisor.ts, client.ts) keep using `CONFIG.drivers.*`.
     // Coerce strings (legacy .conf arrives as strings) and reject anything
@@ -443,15 +440,11 @@ function normalize(cfg) {
     // Allow either the new flat keys or (for backward compatibility) the
     // old nested `[drivers]` block. Flat keys take precedence.
     const nestedDrv = (cfg.drivers ?? {});
-    const flatPrimary = cfg.driver_primary ?? nestedDrv.primary;
     const flatCooldown = cfg.driver_fallback_cooldown_ms ?? nestedDrv.fallbackCooldownMs;
     const flatVerify = cfg.driver_verify_window_ms ?? nestedDrv.verifyWindowMs;
     const flatBaileysEnabled = cfg.driver_baileys_enabled ?? nestedDrv.baileys?.enabled;
-    const flatWhatsmeowEnabled = cfg.driver_whatsmeow_enabled ?? nestedDrv.whatsmeow?.enabled;
-    const flatWhatsmeowGrpc = cfg.driver_whatsmeow_grpc_address ?? nestedDrv.whatsmeow?.grpcAddress;
-    const flatWhatsmeowBinary = cfg.driver_whatsmeow_binary_path ?? nestedDrv.whatsmeow?.binaryPath;
     cfg.drivers = {
-        primary: flatPrimary === "whatsmeow" ? "whatsmeow" : "baileys",
+        primary: "baileys",
         fallbackCooldownMs: Number(flatCooldown) || 60000,
         verifyWindowMs: Array.isArray(flatVerify) && flatVerify.length
             ? flatVerify.map((n) => Number(n)).filter((n) => Number.isFinite(n) && n > 0)
@@ -459,17 +452,6 @@ function normalize(cfg) {
         baileys: {
             enabled: coerceEnabled(flatBaileysEnabled, true),
         },
-        whatsmeow: {
-            // MANYBOT_SMOKE=1 force-enables whatsmeow regardless of the TOML
-            // value — used by scripts/smoke-whatsmeow-supervisor.mjs so the
-            // smoke test doesn't depend on the local manybot.toml already
-            // having driver_whatsmeow_enabled = true. Not a documented
-            // user-facing setting; TOML remains the source of truth outside
-            // smoke runs.
-            enabled: process.env.MANYBOT_SMOKE === "1" ? true : isTruthy(flatWhatsmeowEnabled),
-            grpcAddress: typeof flatWhatsmeowGrpc === "string" ? flatWhatsmeowGrpc : "localhost:50051",
-            binaryPath: typeof flatWhatsmeowBinary === "string" ? flatWhatsmeowBinary : "",
-        },
     };
     // Drop the flat keys from the merged object so they don't leak as
     // loose top-level Config keys (the `Config` interface exposes only
@@ -515,9 +497,11 @@ export const CMD_PREFIX = CONFIG.CMD_PREFIX;
 export const CHATS = CONFIG.CHATS;
 export const EXCLUDE_CHATS = CONFIG.EXCLUDE_CHATS;
 export const SECURITY_LEVEL = CONFIG.SECURITY_LEVEL;
+export const LOG_LEVEL = CONFIG.LOG_LEVEL;
 export const PLUGINS = CONFIG.PLUGINS;
 export const LANGUAGE = CONFIG.LANGUAGE;
 export const PHONE_NUMBER = CONFIG.PHONE_NUMBER;
+export const OWNER_NUMBER = CONFIG.OWNER_NUMBER;
 export const LOGIN_METHOD = CONFIG.LOGIN_METHOD;
 export const ADMIN_JID = CONFIG.ADMIN_JID;
 export const SMTP_HOST = CONFIG.SMTP_HOST;

package/dist/config.test.js

@@ -0,0 +1,26 @@
+import test, { describe } from "node:test";
+import assert from "node:assert/strict";
+import path from "path";
+import os from "os";
+import { CONFIG_DIR, CONFIG } from "#config";
+describe("config", () => {
+    test("CONFIG_DIR defaults to ~/.manybot or respects env override", () => {
+        if (process.env.MANYBOT_CONFIG_DIR) {
+            assert.equal(CONFIG_DIR, process.env.MANYBOT_CONFIG_DIR);
+        }
+        else {
+            assert.equal(CONFIG_DIR, path.join(os.homedir(), ".manybot"));
+        }
+    });
+    test("CONFIG has required structure and default fallback values", () => {
+        assert.ok(typeof CONFIG.CMD_PREFIX === "string");
+        assert.ok(typeof CONFIG.CLIENT_ID === "string");
+        assert.ok(Array.isArray(CONFIG.CHATS));
+        assert.ok(Array.isArray(CONFIG.EXCLUDE_CHATS));
+        assert.ok(["low", "medium", "high"].includes(CONFIG.SECURITY_LEVEL));
+        assert.ok(["normal", "clean", "minimal"].includes(CONFIG.LOG_LEVEL));
+        assert.ok(CONFIG.drivers);
+        assert.ok(CONFIG.drivers.primary === "baileys");
+        assert.ok(typeof CONFIG.drivers.baileys.enabled === "boolean");
+    });
+});

package/dist/download/queue.js

@@ -10,6 +10,9 @@
  * Usage:
  *   import { enqueue } from "#download";
  *   enqueue(async () => { ... all plugin logic ... }, onError);
+ *
+ * `errorFn` is optional — if omitted, a failure is still logged via
+ * `logger.warn` so it's never silently swallowed.
  */
 import { logger } from "#logger";
 import { t } from "#i18n";
@@ -18,7 +21,8 @@ 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.
+ * @param errorFn Called with the thrown error if workFn rejects. If omitted,
+ *                 the error is logged via `logger.warn` instead.
  */
 export function enqueue(workFn, errorFn) {
     queue.push({ workFn, errorFn });
@@ -41,9 +45,14 @@ async function processJob({ workFn, errorFn }) {
     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)));
+        if (errorFn) {
+            try {
+                await errorFn(err);
+            }
+            catch { }
+        }
+        else {
+            logger.warn(t("system.downloadJobNoErrorFn"));
         }
-        catch { }
     }
 }