@manybot/manybot 5.2.6 → 5.3.1

package/README.md

@@ -16,7 +16,7 @@ Open-source framework for message automation, extensible via community plugins.
 
 ## Requirements
 
-- Node.js >= 24.17.0
+- Node.js >= 24
 - npm
 
 ## Getting started

package/dist/client/cache.js

@@ -0,0 +1,60 @@
+/**
+ * client/cache.ts
+ *
+ * Persists the store's chats/contacts/lidMap snapshot to disk.
+ *
+ * Why: an already-linked WhatsApp session doesn't get a full history
+ * resync on reconnect — only a partial, non-deterministic slice of it
+ * (see drivers/whatsapp/index.ts). Each fresh process starts with an
+ * empty in-memory store, so without a cache, chats seen in a previous
+ * run can silently disappear from the current one.
+ *
+ * Consumers must always merge (store.hydrate), never replace: a stale
+ * cache is still strictly better than an empty store.
+ */
+import fs from "fs/promises";
+import path from "path";
+import { CONFIG_DIR, CLIENT_ID } from "#config";
+import { logger } from "#logger";
+export const DEFAULT_MAX_CACHE_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+function cacheFilePath(clientId = CLIENT_ID) {
+    return path.join(CONFIG_DIR, "cache", `${clientId}.chats.json`);
+}
+async function readCacheFile(clientId) {
+    try {
+        const raw = await fs.readFile(cacheFilePath(clientId), "utf-8");
+        return JSON.parse(raw);
+    }
+    catch (e) {
+        if (e.code !== "ENOENT") {
+            logger.warn(`[cache] Failed to read chat cache: ${e.message}`);
+        }
+        return null;
+    }
+}
+/** Loads the last saved snapshot, or null if none exists / it's corrupt. */
+export async function loadChatCache(clientId = CLIENT_ID) {
+    const file = await readCacheFile(clientId);
+    return file?.snapshot ?? null;
+}
+/** Whether the cache on disk was saved within `maxAgeMs`. Informational only — never gates hydration. */
+export async function isCacheFresh(clientId = CLIENT_ID, maxAgeMs = DEFAULT_MAX_CACHE_AGE_MS) {
+    const file = await readCacheFile(clientId);
+    if (!file)
+        return false;
+    return Date.now() - file.savedAt < maxAgeMs;
+}
+/** Writes the store's current snapshot to disk (atomic write via tmp + rename). */
+export async function saveChatCache(store, clientId = CLIENT_ID) {
+    const target = cacheFilePath(clientId);
+    const tmp = `${target}.tmp`;
+    const file = { savedAt: Date.now(), snapshot: store.toJSON() };
+    try {
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        await fs.writeFile(tmp, JSON.stringify(file), "utf-8");
+        await fs.rename(tmp, target);
+    }
+    catch (e) {
+        logger.warn(`[cache] Failed to save chat cache: ${e.message}`);
+    }
+}

package/dist/client/store.js

@@ -30,6 +30,9 @@ export function createStore() {
             return jid;
         return lidMap.get(jid) ?? jid;
     }
+    function forgetLid(lid) {
+        lidMap.delete(lid);
+    }
     // Max messages kept per chat (prevents unbounded memory growth)
     const MAX_MSGS_PER_CHAT = 200;
     function upsertChat(chat) {
@@ -37,11 +40,16 @@ export function createStore() {
         chatsMap.set(chat.id, { id: chat.id, name });
     }
     function upsertContact(contact) {
+        // Don't let a later, poorer sync round (e.g. a bare history-sync stub)
+        // blank out a name/notify/verifiedName we already learned from an
+        // earlier, richer one (e.g. a live message's pushName) — only accept
+        // a field when this contact object actually carries it.
+        const existing = contacts[contact.id];
         contacts[contact.id] = {
             id: contact.id,
-            name: contact.name,
-            notify: contact.notify,
-            verifiedName: contact.verifiedName,
+            name: contact.name ?? existing?.name,
+            notify: contact.notify ?? existing?.notify,
+            verifiedName: contact.verifiedName ?? existing?.verifiedName,
         };
         // Baileys' Contact carries both the traditional JID (id) and the LID
         // (lid) once known — learn the mapping either direction.
@@ -66,6 +74,12 @@ export function createStore() {
         }
     }
     function bind(ev) {
+        ev.on("messaging-history.set", ({ chats, contacts }) => {
+            for (const chat of chats)
+                upsertChat(chat);
+            for (const contact of contacts)
+                upsertContact(contact);
+        });
         ev.on("chats.upsert", (newChats) => {
             for (const chat of newChats)
                 upsertChat(chat);
@@ -100,6 +114,18 @@ export function createStore() {
                 const key = msg.key;
                 learnLid(key.participantAlt, key.participant);
                 learnLid(key.remoteJidAlt, key.remoteJid);
+                // pushName only ever arrives on a live message — contact/history
+                // sync alone won't give us a name for someone who never messaged
+                // and isn't a saved contact. Worth capturing here, since it's the
+                // one extra source we have (feeds the on-disk cache too).
+                const pushName = msg.pushName;
+                const senderId = key.participant ?? msg.key.remoteJid;
+                if (pushName && senderId && !msg.key.fromMe && !senderId.endsWith("@g.us")) {
+                    const existing = contacts[senderId];
+                    if (existing?.notify !== pushName) {
+                        contacts[senderId] = { ...existing, id: senderId, notify: pushName };
+                    }
+                }
             }
         });
         ev.on("messages.update", (updates) => {
@@ -122,6 +148,22 @@ export function createStore() {
             }
         });
     }
+    function toJSON() {
+        return {
+            chats: [...chatsMap.values()],
+            contacts: { ...contacts },
+            lidMap: [...lidMap.entries()],
+        };
+    }
+    function hydrate(snapshot) {
+        for (const chat of snapshot.chats ?? [])
+            chatsMap.set(chat.id, chat);
+        for (const [id, contact] of Object.entries(snapshot.contacts ?? {})) {
+            contacts[id] = { ...contacts[id], ...contact };
+        }
+        for (const [lid, pn] of snapshot.lidMap ?? [])
+            learnLid(lid, pn);
+    }
     return {
         chats: {
             get: (id) => chatsMap.get(id) ?? null,
@@ -130,6 +172,10 @@ export function createStore() {
         contacts,
         messages,
         resolveJid,
+        learnLid,
+        forgetLid,
         bind,
+        toJSON,
+        hydrate,
     };
 }

package/dist/drivers/whatsapp/api/index.js

@@ -21,10 +21,17 @@ import { readFileSync } from "fs";
 import path from "path";
 import { waitForSendSlot, simulateState, typingDuration, mediaDuration } from "#sendguard";
 import { buildSettingsApi } from "#settingsdb";
-import { downloadMediaMessage, getAggregateVotesInPollMessage, decryptPollVote, jidNormalizedUser } from "@whiskeysockets/baileys";
+import { downloadMediaMessage, getAggregateVotesInPollMessage, decryptPollVote, jidNormalizedUser, normalizeMessageContent } from "@whiskeysockets/baileys";
 // ── Message body / type helpers ───────────────────────────────────────────────
+// WhatsApp wraps media in ephemeralMessage/viewOnceMessage/etc when sent as
+// disappearing or view-once — the actual imageMessage/videoMessage/... sits
+// one level deeper. Reading msg.message directly misses all of that (this
+// was the cause of hasMedia silently returning false for such messages).
+function unwrap(msg) {
+    return normalizeMessageContent(msg.message) ?? undefined;
+}
 function getMsgBody(msg) {
-    const m = msg.message;
+    const m = unwrap(msg);
     if (!m)
         return "";
     return (m.conversation ??
@@ -37,7 +44,7 @@ function getMsgBody(msg) {
         "");
 }
 function getMsgType(msg) {
-    const m = msg.message;
+    const m = unwrap(msg);
     if (!m)
         return "unknown";
     if (m.conversation || m.extendedTextMessage)
@@ -69,11 +76,11 @@ function getMsgType(msg) {
     return "unknown";
 }
 function msgHasMedia(msg) {
-    const m = msg.message;
+    const m = unwrap(msg);
     return !!(m?.imageMessage || m?.videoMessage || m?.audioMessage || m?.documentMessage || m?.stickerMessage);
 }
 function msgIsGif(msg) {
-    return !!(msg.message?.videoMessage?.gifPlayback);
+    return !!(unwrap(msg)?.videoMessage?.gifPlayback);
 }
 /** Sender JID — group participant or DM remote JID, normalized. */
 function getMsgSender(msg, store) {
@@ -81,7 +88,7 @@ function getMsgSender(msg, store) {
     return normalizeJid(store.resolveJid(raw));
 }
 function getContextInfo(msg) {
-    const m = msg.message;
+    const m = unwrap(msg);
     return (m?.extendedTextMessage?.contextInfo ??
         m?.imageMessage?.contextInfo ??
         m?.videoMessage?.contextInfo ??
@@ -90,7 +97,7 @@ function getContextInfo(msg) {
         null);
 }
 function getMsgMimetype(msg) {
-    const m = msg.message;
+    const m = unwrap(msg);
     return (m?.imageMessage?.mimetype ??
         m?.videoMessage?.mimetype ??
         m?.audioMessage?.mimetype ??
@@ -382,17 +389,92 @@ function buildContactsApi(sock, store, botJid) {
         /**
          * Get a normalized contact object by JID.
          * @param {string} contactId
+         * @param {{groupId?: string}} [opts] — when `contactId` is a raw `@lid`, this
+         *   always cross-checks it against Baileys' own protocol-level
+         *   `sock.signalRepository.lidMapping` first (populated from real Signal
+         *   session/identity resolution — not a heuristic, and doesn't need a
+         *   group). If `opts.groupId` is also given and that didn't resolve it,
+         *   falls back to a live `groupMetadata()` call for that group as a
+         *   second attempt (NOTE: on Baileys 6.7.x, `groupMetadata()` is known to
+         *   still return a bare `@lid` with no `phoneNumber` for some
+         *   participants — see WhiskeySockets/Baileys#1505 — so this second
+         *   attempt is best-effort and won't always help). Either source, once
+         *   it yields a phone-based JID, corrects the store's own `lidMap` too,
+         *   which is only ever learned from past messages/contact syncs and can
+         *   go stale or, rarely, end up mapped to the wrong person (e.g. after a
+         *   `@lid` gets reassigned). Every cross-check is best-effort: on any
+         *   failure this silently falls back to whatever the store already has
+         *   — never throws because of the cross-check itself.
          * @returns {Promise<object|null>}
          */
-        async get(contactId) {
-            const resolved = normalizeJid(store.resolveJid(normalizeJid(contactId)));
+        async get(contactId, opts) {
+            if (contactId.endsWith("@lid")) {
+                let freshPn;
+                // 1) Baileys' own protocol-level LID↔PN store — populated as part of
+                // real Signal session/identity handling, so it's authoritative when
+                // it has an answer (unlike our own heuristic lidMap). Not part of
+                // the public v6.7 TS surface, hence the cast; guarded with a
+                // typeof check since older/patched Baileys builds may not have it.
+                try {
+                    const lidMapping = sock.signalRepository?.lidMapping;
+                    if (typeof lidMapping?.getPNForLID === "function") {
+                        freshPn = await lidMapping.getPNForLID(contactId);
+                    }
+                }
+                catch (err) {
+                    logger.warn(`[contacts.get] signalRepository.lidMapping cross-check failed for "${contactId}" — ${err.message}`);
+                }
+                // 2) Fall back to live groupMetadata() when we know the group and
+                // the signal repository didn't have an answer. Best-effort — see
+                // the Baileys 6.7.x caveat in the doc comment above.
+                if (!freshPn && opts?.groupId) {
+                    try {
+                        const meta = await sock.groupMetadata(opts.groupId);
+                        const participant = meta.participants.find((p) => normalizeJid(p.id) === normalizeJid(contactId));
+                        freshPn = participant?.phoneNumber;
+                    }
+                    catch (err) {
+                        logger.warn(`[contacts.get] live groupMetadata cross-check failed for "${contactId}" in "${opts.groupId}" — ${err.message}`);
+                    }
+                }
+                if (freshPn)
+                    store.learnLid(contactId, normalizeJid(freshPn));
+            }
+            const normalizedContactId = normalizeJid(contactId);
+            let resolved = normalizeJid(store.resolveJid(normalizedContactId));
+            // Sanity guard: a @lid resolving to the bot's own JID is only ever
+            // legitimate when we were actually looking up the bot itself. Any
+            // other case means the stored lidMap entry is stale/wrong — e.g. a
+            // @lid that got reassigned to a different WhatsApp account since we
+            // learned it (see the best-effort cross-check above, which doesn't
+            // always catch this — WhiskeySockets/Baileys#1505). Serving it
+            // anyway would silently hand the bot owner's own identity out as
+            // some other member's. Discard the bad mapping so it can be
+            // relearned correctly, and treat this lookup as unresolved instead.
+            if (botJid &&
+                normalizedContactId.endsWith("@lid") &&
+                resolved === normalizeJid(botJid) &&
+                normalizedContactId !== normalizeJid(botJid)) {
+                logger.warn(`[contacts.get] "${contactId}" resolved to the bot's own JID — discarding stale lidMap entry, treating as unresolved.`);
+                store.forgetLid(normalizedContactId);
+                resolved = normalizedContactId;
+            }
             // The same person's data can be split across the raw (e.g. @lid) and
             // store-resolved (PN) keys — one may have `notify` and the other
-            // `verifiedName`/`name`. Merge instead of taking whichever key
-            // happens to exist first, or we silently drop real fields.
+            // `verifiedName`/`name`. Merge field-by-field instead of spreading
+            // whole objects: upsertContact() always writes all three fields, so
+            // a plain `{ ...raw, ...resolvedInfo }` lets resolvedInfo's explicit
+            // `undefined` silently clobber a real value already present in raw
+            // (or vice versa) — which is how a contact could resolve correctly
+            // by id yet still come back with a null pushname/name.
             const raw = store.contacts[contactId];
             const resolvedInfo = store.contacts[resolved];
-            const info = (raw || resolvedInfo) ? { ...raw, ...resolvedInfo } : undefined;
+            const info = (raw || resolvedInfo) ? {
+                id: resolved,
+                name: resolvedInfo?.name ?? raw?.name,
+                notify: resolvedInfo?.notify ?? raw?.notify,
+                verifiedName: resolvedInfo?.verifiedName ?? raw?.verifiedName,
+            } : undefined;
             return normalizeContact(resolved, info, botJid, sock);
         },
         /**
@@ -548,7 +630,7 @@ export function buildMessageContext(msg, sock, store, guardOptions = {}) {
         async getContact() {
             const info = store.contacts[sender]
                 ?? store.contacts[store.resolveJid(msg.key.participant ?? "")];
-            const botJid = sock.user?.id ? normalizeJid(sock.user.id) : null;
+            const botJid = sock.user?.id ? jidNormalizedUser(sock.user.id) : null;
             return normalizeContact(sender, info, botJid, sock);
         },
     };
@@ -843,6 +925,28 @@ function buildAdminApi(sock, chatJid) {
             throw new Error(`Group not found: ${jid}`);
         return meta;
     }
+    /**
+     * Baileys' `groupParticipantsUpdate()` resolves normally even when
+     * WhatsApp rejected some (or all) of the requested participants — it
+     * returns an array with a per-participant `status` code (`'200'` =
+     * success; anything else is a rejection — e.g. `'403'`/`'401'` not
+     * authorized, often because the target's privacy settings block being
+     * added by a non-contact; `'409'` already a participant; `'408'`
+     * partial/timeout). A caller that only awaits the promise sees a
+     * "successful" resolution even when nobody was actually
+     * added/removed/promoted/demoted — silently reporting failure as
+     * success. Throw here so `ctx.admin.add/kick/promote/demote` produce a
+     * real rejection callers can catch, instead of a false positive.
+     */
+    function assertParticipantsUpdateOk(action, results) {
+        if (!Array.isArray(results))
+            return; // unexpected shape — nothing to validate
+        const failed = results.filter((r) => r?.status && r.status !== "200");
+        if (failed.length > 0) {
+            const detail = failed.map((r) => `${r.jid ?? "?"}=${r.status}`).join(", ");
+            throw new Error(`groupParticipantsUpdate("${action}") rejeitado para: ${detail}`);
+        }
+    }
     function createTargetableAction(action, memberIds) {
         const users = norm(memberIds);
         const executeCurrent = async () => { requireChat(); return action(chatJid, users); };
@@ -862,22 +966,32 @@ function buildAdminApi(sock, chatJid) {
     return {
         /** @param {string|string[]} memberIds */
         add(memberIds) {
-            return createTargetableAction((jid, users) => sock.groupParticipantsUpdate(jid, users, "add"), memberIds);
+            return createTargetableAction(async (jid, users) => {
+                const results = await sock.groupParticipantsUpdate(jid, users, "add");
+                assertParticipantsUpdateOk("add", results);
+                return results;
+            }, memberIds);
         },
         /** @param {string|string[]} memberIds */
         async kick(memberIds) {
             requireChat();
-            return sock.groupParticipantsUpdate(chatJid, norm(memberIds), "remove");
+            const results = await sock.groupParticipantsUpdate(chatJid, norm(memberIds), "remove");
+            assertParticipantsUpdateOk("remove", results);
+            return results;
         },
         /** @param {string|string[]} memberIds */
         async promote(memberIds) {
             requireChat();
-            return sock.groupParticipantsUpdate(chatJid, norm(memberIds), "promote");
+            const results = await sock.groupParticipantsUpdate(chatJid, norm(memberIds), "promote");
+            assertParticipantsUpdateOk("promote", results);
+            return results;
         },
         /** @param {string|string[]} memberIds */
         async demote(memberIds) {
             requireChat();
-            return sock.groupParticipantsUpdate(chatJid, norm(memberIds), "demote");
+            const results = await sock.groupParticipantsUpdate(chatJid, norm(memberIds), "demote");
+            assertParticipantsUpdateOk("demote", results);
+            return results;
         },
         /** @param {string} name */
         async setSubject(name) {
@@ -895,9 +1009,11 @@ function buildAdminApi(sock, chatJid) {
             const buffer = Buffer.isBuffer(source) ? source : readFileSync(source);
             return sock.updateProfilePicture(chatJid, buffer);
         },
-        async getInviteLink() {
-            requireChat();
-            const code = await sock.groupInviteCode(chatJid);
+        async getInviteLink(groupId) {
+            const jid = groupId ?? chatJid;
+            if (!jid)
+                throw new Error("This admin operation requires a runtime group context.");
+            const code = await sock.groupInviteCode(jid);
             return `https://chat.whatsapp.com/${code}`;
         },
         async revokeInvite() {
@@ -928,7 +1044,11 @@ function buildMeApi(sock) {
 }
 // ── Poll API ──────────────────────────────────────────────────────────────────
 const pollRegistry = new Map();
-const pollListeners = new Set();
+// Rebinding must happen per socket instance — a plugin name alone doesn't
+// tell us whether the listener is bound to the CURRENT (post-reconnect)
+// sock.ev or a dead one from before. WeakMap keyed by sock lets old
+// entries fall off automatically once that socket is garbage collected.
+const pollListenersBySocket = new WeakMap();
 /**
  * Tracks votes for an active poll.
  * Obtained via ctx.poll.create().
@@ -1004,8 +1124,13 @@ function buildPollApi(sock, store, rawJid, guardOptions, pluginName) {
     // with no dedup — so we must keep only the latest entry per voter ourselves,
     // or retracted/changed votes keep counting alongside the new one.
     const pollVotesByCreationId = new Map();
-    if (!pollListeners.has(pluginName)) {
-        pollListeners.add(pluginName);
+    let boundPlugins = pollListenersBySocket.get(sock);
+    if (!boundPlugins) {
+        boundPlugins = new Set();
+        pollListenersBySocket.set(sock, boundPlugins);
+    }
+    if (!boundPlugins.has(pluginName)) {
+        boundPlugins.add(pluginName);
         const meId = sock.user?.id ? jidNormalizedUser(sock.user.id) : "me";
         // WhatsApp doesn't consistently use the same JID shape (LID vs PN) for
         // pollCreatorJid/voterJid when deriving the poll-vote decryption key —
@@ -1143,7 +1268,7 @@ function buildPollApi(sock, store, rawJid, guardOptions, pluginName) {
 }
 // ── Base API (shared between setup and runtime) ───────────────────────────────
 function buildBaseApi(sock, store, pluginRegistry, pluginName) {
-    const botJid = sock.user?.id ? normalizeJid(sock.user.id) : null;
+    const botJid = sock.user?.id ? jidNormalizedUser(sock.user.id) : null;
     if (!botJid)
         logger.warn("[pluginApi] botId is null — socket may not be ready yet.");
     return {

package/dist/drivers/whatsapp/index.js

@@ -10,33 +10,110 @@
  * - Plugin context building (via buildApi)
  * - Event handling and plugin execution
  */
-import { createSocket, normalizeJid, AUTH_DIR } from "./sdk/baileysSock.js";
+import { createSocket, normalizeJid, sessionDir, AUTH_DIR, store as sharedStore } 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 { loadChatCache, saveChatCache, isCacheFresh } from "#client/cache.js";
+import { DisconnectReason, normalizeMessageContent } from "@whiskeysockets/baileys";
 import fs from "fs/promises";
+import * as clack from "@clack/prompts";
+import { copyToClipboard } from "#utils/clipboard.js";
 let state = "BOOT";
 let shuttingDown = false;
 let currentSock = null;
 let currentStore = null;
+let reconnectTimer = null;
+let connecting = false;
+let reconnectAttempts = 0;
+let cacheHydrated = false;
+let cacheSaveTimer = null;
+const RECONNECT_BASE_MS = 1000;
+const RECONNECT_MAX_MS = 60000;
+const CACHE_SAVE_INTERVAL_MS = 5 * 60 * 1000; // 5min
+/**
+ * Loads the on-disk cache and merges it into `store` (union, never
+ * overwrite — see client/cache.ts). Runs once per process: the shared
+ * store singleton already accumulates across reconnects, so re-hydrating
+ * later would just redo a no-op merge.
+ */
+async function hydrateFromCache(store) {
+    if (cacheHydrated)
+        return;
+    cacheHydrated = true;
+    const snapshot = await loadChatCache();
+    if (!snapshot)
+        return;
+    store.hydrate(snapshot);
+    const fresh = await isCacheFresh();
+    const count = snapshot.chats.length;
+    const key = fresh ? "system.cacheLoaded" : "system.cacheLoadedStale";
+    logger.info(`[cache] ${t(key, { count })}`);
+}
+function startCacheAutosave(store) {
+    if (cacheSaveTimer)
+        return;
+    cacheSaveTimer = setInterval(() => { saveChatCache(store); }, CACHE_SAVE_INTERVAL_MS);
+}
+function stopCacheAutosave() {
+    if (!cacheSaveTimer)
+        return;
+    clearInterval(cacheSaveTimer);
+    cacheSaveTimer = null;
+}
+function nextBackoffMs() {
+    const delay = RECONNECT_BASE_MS * 2 ** reconnectAttempts;
+    reconnectAttempts++;
+    return Math.min(delay, RECONNECT_MAX_MS);
+}
+function teardownSock(sock) {
+    if (!sock)
+        return;
+    try {
+        sock.ev.removeAllListeners();
+    }
+    catch { }
+    try {
+        sock.end(undefined);
+    }
+    catch { }
+}
+function scheduleReconnect(delayMs) {
+    if (shuttingDown)
+        return;
+    if (reconnectTimer)
+        clearTimeout(reconnectTimer);
+    reconnectTimer = setTimeout(() => {
+        reconnectTimer = null;
+        startBot();
+    }, delayMs);
+}
 async function startBot() {
+    if (connecting)
+        return;
+    connecting = true;
+    await hydrateFromCache(sharedStore);
+    const previousSock = currentSock;
     const { sock, store } = await createSocket();
+    teardownSock(previousSock);
     currentSock = sock;
     currentStore = store;
+    connecting = false;
     // ── Normal bot mode ─────────────────────────────────────────────────────────
     sock.ev.on("connection.update", async (update) => {
         const { connection, lastDisconnect } = update;
         if (connection === "open") {
             state = "READY_INIT";
+            reconnectAttempts = 0;
             logger.success(t("system.connected"));
             logger.info(t("system.clientId", { id: CLIENT_ID }));
             printBanner();
             await loadPlugins(PLUGINS);
             await setupPlugins(sock, store);
+            startCacheAutosave(store);
             // buffer anti-replay / sync ghost messages
             setTimeout(() => { state = "READY"; }, 2000);
         }
@@ -53,12 +130,12 @@ async function startBot() {
                 catch (e) {
                     logger.error(`[whatsapp] Failed to remove session dir: ${e.message}`);
                 }
-                if (!shuttingDown)
-                    setTimeout(() => startBot(), 1000);
+                scheduleReconnect(1000);
             }
             else if (!shuttingDown) {
-                logger.info(t("system.reconnecting", { secs: 5 }));
-                setTimeout(() => startBot(), 5000);
+                const delay = nextBackoffMs();
+                logger.info(t("system.reconnecting", { secs: Math.round(delay / 1000) }));
+                scheduleReconnect(delay);
             }
         }
     });
@@ -87,7 +164,7 @@ async function startBot() {
 }
 /** Quick body extraction to avoid importing helpers here. */
 function getBodyQuick(msg) {
-    const m = msg.message;
+    const m = normalizeMessageContent(msg.message);
     if (!m)
         return "";
     return (m.conversation ??
@@ -97,7 +174,7 @@ function getBodyQuick(msg) {
         "");
 }
 function msgHasMediaQuick(msg) {
-    const m = msg.message;
+    const m = normalizeMessageContent(msg.message);
     return !!(m?.imageMessage || m?.videoMessage || m?.audioMessage || m?.documentMessage || m?.stickerMessage);
 }
 export const whatsappDriver = {
@@ -107,62 +184,165 @@ export const whatsappDriver = {
     },
     async disconnect() {
         shuttingDown = true;
-        if (currentSock) {
-            try {
-                currentSock.ev?.removeAllListeners();
-            }
-            catch { }
-            try {
-                currentSock.end(undefined);
-            }
-            catch { }
-            currentSock = null;
-            currentStore = null;
+        reconnectAttempts = 0;
+        if (reconnectTimer) {
+            clearTimeout(reconnectTimer);
+            reconnectTimer = null;
         }
+        stopCacheAutosave();
+        if (currentStore)
+            await saveChatCache(currentStore);
+        teardownSock(currentSock);
+        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/dedup filters of
-     * handleMessage: the only goal here is to discover the JID so you can
-     * configure CHATS afterward, so there's no reason to filter
-     * anything out yet.
+     * Diagnostic mode: connects on its own session (separate from the
+     * running bot's, so it doesn't compete for the same WhatsApp Web
+     * slot), waits for the initial chat sync, then shows an interactive
+     * list — arrow keys to navigate, Enter to pick. The selected chat's
+     * id is normalized, resolved from `@lid` to the real phone-based JID
+     * when known, copied to the clipboard, and printed.
      */
     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.");
+        logger.info(`[getid] ${t("getid.connecting")}`);
+        await hydrateFromCache(sharedStore);
+        const CONNECT_TIMEOUT_MS = 25000;
+        const MAX_ATTEMPTS = 3;
+        const MAX_ROUNDS = 2;
+        const getidAuthDir = `${CLIENT_ID}-getid`;
+        let sock = null;
+        let store = null;
+        for (let round = 1; round <= MAX_ROUNDS && !sock; round++) {
+            for (let attempt = 1; attempt <= MAX_ATTEMPTS && !sock; attempt++) {
+                const created = await createSocket(getidAuthDir);
+                // Not a spinner here on purpose: if this session isn't paired yet,
+                // Baileys prints the QR/pairing code through the normal logger
+                // right after this — a spinner redrawing the line would bury it,
+                // so the person never gets a chance to approve it on their phone
+                // and the connection hangs forever waiting for "open".
+                const opened = await new Promise((resolve) => {
+                    let settled = false;
+                    const timer = setTimeout(() => {
+                        if (!settled) {
+                            settled = true;
+                            resolve(false);
+                        }
+                    }, CONNECT_TIMEOUT_MS);
+                    created.sock.ev.on("connection.update", (update) => {
+                        if (settled)
+                            return;
+                        if (update.connection === "open") {
+                            settled = true;
+                            clearTimeout(timer);
+                            resolve(true);
+                        }
+                        else if (update.connection === "close") {
+                            const code = update.lastDisconnect?.error?.output?.statusCode;
+                            settled = true;
+                            clearTimeout(timer);
+                            logger.warn(`[getid] ${t("getid.connectFailed", { reason: String(code ?? "?") })}`);
+                            resolve(false);
+                        }
+                    });
+                });
+                if (opened) {
+                    sock = created.sock;
+                    store = created.store;
+                    break;
                 }
-            });
-            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 in manybot.toml.");
-                resolve();
-            });
-        });
+                try {
+                    created.sock.ev?.removeAllListeners();
+                    created.sock.end(undefined);
+                }
+                catch { }
+                if (attempt < MAX_ATTEMPTS) {
+                    logger.info(`[getid] ${t("getid.retrying", { attempt: attempt + 1, max: MAX_ATTEMPTS })}`);
+                    await new Promise((r) => setTimeout(r, 2000));
+                }
+            }
+            // Exhausted every attempt this round without ever reaching "open" —
+            // likely a corrupted/stuck -getid session (not the normal first-pairing
+            // 515, which already succeeds within a round). Wipe it and re-pair
+            // from scratch instead of forcing the person to rerun the command.
+            if (!sock && round < MAX_ROUNDS) {
+                logger.warn(`[getid] ${t("getid.sessionWiped", { round: round + 1, max: MAX_ROUNDS })}`);
+                try {
+                    await fs.rm(sessionDir(getidAuthDir), { recursive: true, force: true });
+                }
+                catch (e) {
+                    logger.error(`[getid] Failed to remove session dir: ${e.message}`);
+                }
+                await new Promise((r) => setTimeout(r, 1000));
+            }
+        }
+        if (!sock || !store) {
+            logger.error(`[getid] ${t("getid.connectGaveUp")}`);
+            return;
+        }
+        const s = clack.spinner();
+        s.start(t("getid.syncingChats"));
+        // History sync arrives as several independent streams (chats,
+        // contacts, push-names...), each firing its own `isLatest: true` when
+        // THAT stream ends — not when everything is done. Stopping on the
+        // first one cuts the others short (fewer chats, missing names).
+        // Instead, wait for a quiet period with no sync activity at all.
+        let lastActivityAt = null;
+        const markActivity = () => { lastActivityAt = Date.now(); };
+        sock.ev.on("messaging-history.set", markActivity);
+        sock.ev.on("chats.upsert", markActivity);
+        sock.ev.on("contacts.upsert", markActivity);
+        sock.ev.on("contacts.update", markActivity);
+        const QUIET_MS = 2000;
+        const deadline = Date.now() + 20000;
+        while (Date.now() < deadline) {
+            if (lastActivityAt !== null && Date.now() - lastActivityAt >= QUIET_MS)
+                break;
+            await new Promise((r) => setTimeout(r, 200));
+        }
+        const chats = store.chats.all();
+        s.stop(t("getid.chatsFound", { count: chats.length }));
+        await saveChatCache(store);
         try {
             sock.ev?.removeAllListeners();
             sock.end(undefined);
         }
         catch { }
+        if (chats.length === 0) {
+            logger.warn(`[getid] ${t("getid.noChatsSynced")}`);
+            return;
+        }
+        const options = chats
+            .map((chat) => {
+            const isGroup = chat.id.endsWith("@g.us");
+            const resolved = normalizeJid(store.resolveJid(chat.id));
+            const contact = store.contacts[chat.id] ?? store.contacts[resolved];
+            const hasChatName = chat.name && chat.name !== chat.id.split("@")[0];
+            const displayName = hasChatName ? chat.name : contact?.name ?? contact?.notify ?? resolved;
+            return {
+                value: resolved,
+                label: `${isGroup ? "👥" : "👤"} ${displayName}`,
+                hint: resolved,
+            };
+        })
+            .sort((a, b) => a.label.localeCompare(b.label));
+        const picked = await clack.multiselect({
+            message: t("getid.pickPrompt"),
+            options,
+            required: true,
+        });
+        if (clack.isCancel(picked)) {
+            clack.cancel(t("getid.cancelled"));
+            return;
+        }
+        const ids = picked;
+        const joined = ids.join("\n");
+        const copied = await copyToClipboard(joined);
+        if (copied) {
+            logger.success(`[getid] ${t("getid.copied", { count: ids.length, ids: joined })}`);
+        }
+        else {
+            logger.warn(`[getid] ${t("getid.copyFailed", { count: ids.length, ids: joined })}`);
+        }
     },
 };

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

@@ -4,7 +4,7 @@
  * 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 makeWASocket, { useMultiFileAuthState, fetchLatestBaileysVersion, Browsers, proto, } from "@whiskeysockets/baileys";
 import path from "path";
 import qrcode from "qrcode-terminal";
 import { CONFIG_DIR, CLIENT_ID } from "#config";
@@ -23,8 +23,12 @@ export const store = createStore();
  * Reconnection is the caller's responsibility — call createSocket() again
  * on `connection.close`.
  */
-export async function createSocket() {
-    const { state, saveCreds } = await useMultiFileAuthState(AUTH_DIR);
+export function sessionDir(authDirName) {
+    return path.join(CONFIG_DIR, "sessions", authDirName);
+}
+export async function createSocket(authDirName = CLIENT_ID) {
+    const authDir = sessionDir(authDirName);
+    const { state, saveCreds } = await useMultiFileAuthState(authDir);
     const { version } = await fetchLatestBaileysVersion();
     // Already-valid session (creds registered in .manybot/sessions) → skips
     // LOGIN_METHOD/PHONE_NUMBER and the interactive login flow entirely, and
@@ -47,6 +51,13 @@ export async function createSocket() {
         logger: pino({ level: "silent" }),
         generateHighQualityLinkPreview: false,
         syncFullHistory: false,
+        // Without this, Baileys' default for syncFullHistory:false is
+        // `() => false`, which disables ALL history sync — not just full
+        // messages, but the chat list, contacts, and LID mappings too (see
+        // https://github.com/WhiskeySockets/Baileys — SocketConfig docs).
+        // This keeps the initial/recent sync (needed for store.chats and
+        // LID→phone resolution) while still skipping the full download.
+        shouldSyncHistoryMessage: ({ syncType }) => syncType !== proto.HistorySync.HistorySyncType.FULL,
         // 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
@@ -57,6 +68,14 @@ export async function createSocket() {
         },
     });
     store.bind(sock.ev);
+    // Each plugin's setup() can attach its own listeners via api.events (see
+    // buildEventsApi in api/index.ts), on top of the driver's own and the
+    // store's. That easily exceeds Node's default cap of 10 with a handful
+    // of plugins — it's expected, not a leak. Reconnects don't add to this:
+    // createSocket() always returns a fresh emitter and the caller tears
+    // down the previous one.
+    const evAsEmitter = sock.ev;
+    evAsEmitter.setMaxListeners?.(50);
     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).

package/dist/kernel/pluginLoader.js

@@ -20,6 +20,36 @@ export const pluginRegistry = new Map();
 let globalSock = null;
 let globalStore = null;
 const pluginWatchers = new Map();
+// fs.watch's `recursive: true` emulates recursion on Linux by opening one
+// inotify watch per subdirectory — a plugin shipping its own node_modules
+// can blow past the OS's fs.inotify.max_user_watches (ENOSPC). Walk the
+// tree ourselves and skip directories that don't need watching.
+const IGNORED_WATCH_DIRS = new Set(["node_modules", ".git", "dist", "build", ".cache"]);
+function watchDirRecursive(rootDir, onChange) {
+    const watchers = [];
+    function walk(dir) {
+        try {
+            watchers.push(fs.watch(dir, onChange));
+        }
+        catch {
+            return;
+        }
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory() && !IGNORED_WATCH_DIRS.has(entry.name)) {
+                walk(path.join(dir, entry.name));
+            }
+        }
+    }
+    walk(rootDir);
+    return watchers;
+}
 let configWatcher = null;
 /**
  * Load all active plugins listed in `activePlugins`.
@@ -248,7 +278,7 @@ export function watchPluginDirectory(name) {
         return;
     try {
         let watchTimeout = null;
-        const watcher = fs.watch(dir, { recursive: true }, (eventType, filename) => {
+        const watchers = watchDirRecursive(dir, (eventType, filename) => {
             if (watchTimeout)
                 clearTimeout(watchTimeout);
             watchTimeout = setTimeout(async () => {
@@ -256,7 +286,7 @@ export function watchPluginDirectory(name) {
                 await reloadPlugin(name);
             }, 500);
         });
-        pluginWatchers.set(name, watcher);
+        pluginWatchers.set(name, watchers);
     }
     catch (e) {
         const err = e instanceof Error ? e : new Error(String(e));
@@ -267,9 +297,10 @@ export function watchPluginDirectory(name) {
  * Stop watching a plugin's directory.
  */
 export function unwatchPlugin(name) {
-    const watcher = pluginWatchers.get(name);
-    if (watcher) {
-        watcher.close();
+    const watchers = pluginWatchers.get(name);
+    if (watchers) {
+        for (const w of watchers)
+            w.close();
         pluginWatchers.delete(name);
     }
 }
@@ -302,8 +333,9 @@ export async function cleanupPlugins() {
         configWatcher.close();
         configWatcher = null;
     }
-    for (const [name, watcher] of pluginWatchers.entries()) {
-        watcher.close();
+    for (const watchers of pluginWatchers.values()) {
+        for (const w of watchers)
+            w.close();
     }
     pluginWatchers.clear();
     for (const plugin of pluginRegistry.values()) {

package/dist/locales/en.json

@@ -31,7 +31,9 @@
     "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..."
+    "sessionExpired": "Session expired or logged out — removing local session and restarting...",
+    "cacheLoaded": "{{count}} chat(s) loaded from cache.",
+    "cacheLoadedStale": "{{count}} chat(s) loaded from cache (stale)."
   },
   "errors": {
     "stack": "Stack",
@@ -50,5 +52,19 @@
     "outroQr": "Scan the QR code that will appear next.",
     "outroPhone": "Wait for the pairing code that will appear next.",
     "cancelled": "Login cancelled."
+  },
+  "getid": {
+    "connecting": "Connecting (own session, won't disturb the running bot)...",
+    "syncingChats": "Syncing chats...",
+    "chatsFound": "{{count}} chat(s) found.",
+    "noChatsSynced": "No chats synced yet. Make sure this WhatsApp account already has some conversation history and try again.",
+    "pickPrompt": "Pick one or more chats (↑↓ + Space to select, Enter to confirm).",
+    "cancelled": "Cancelled.",
+    "copied": "{{count}} id(s) copied to the clipboard:\n{{ids}}",
+    "copyFailed": "Couldn't access the clipboard — copy manually:\n{{ids}}",
+    "connectFailed": "Connection attempt failed — reason: {{reason}}",
+    "retrying": "Retrying ({{attempt}}/{{max}})...",
+    "sessionWiped": "Session discarded, pairing again ({{round}}/{{max}})...",
+    "connectGaveUp": "Couldn't connect after several attempts. Check your network and try again."
   }
 }

package/dist/locales/es.json

@@ -31,7 +31,9 @@
     "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..."
+    "sessionExpired": "Sesión expirada o cerrada — eliminando sesión local y reiniciando...",
+    "cacheLoaded": "{{count}} chat(s) cargado(s) desde la caché.",
+    "cacheLoadedStale": "{{count}} chat(s) cargado(s) desde la caché (desactualizada)."
   },
   "errors": {
     "stack": "Stack",
@@ -50,5 +52,19 @@
     "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."
+  },
+  "getid": {
+    "connecting": "Conectando (sesión propia, no afecta al bot en ejecución)...",
+    "syncingChats": "Sincronizando chats...",
+    "chatsFound": "{{count}} chat(s) encontrado(s).",
+    "noChatsSynced": "Aún no hay chats sincronizados. Asegúrate de que esta cuenta ya tenga historial de conversaciones e intenta de nuevo.",
+    "pickPrompt": "Elige uno o más chats (↑↓ + Espacio para marcar, Enter para confirmar).",
+    "cancelled": "Cancelado.",
+    "copied": "{{count}} ID(s) copiado(s) al portapapeles:\n{{ids}}",
+    "copyFailed": "No se pudo acceder al portapapeles — cópialo manualmente:\n{{ids}}",
+    "connectFailed": "El intento de conexión falló — motivo: {{reason}}",
+    "retrying": "Reintentando ({{attempt}}/{{max}})...",
+    "sessionWiped": "Sesión descartada, emparejando de nuevo ({{round}}/{{max}})...",
+    "connectGaveUp": "No se pudo conectar tras varios intentos. Revisa tu conexión e intenta de nuevo."
   }
 }

package/dist/locales/pt.json

@@ -31,7 +31,9 @@
     "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..."
+    "sessionExpired": "Sessão expirada ou desconectada — removendo sessão local e reiniciando...",
+    "cacheLoaded": "{{count}} conversa(s) carregada(s) do cache.",
+    "cacheLoadedStale": "{{count}} conversa(s) carregada(s) do cache (desatualizado)."
   },
   "errors": {
     "stack": "Stack",
@@ -50,5 +52,19 @@
     "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."
+  },
+  "getid": {
+    "connecting": "Conectando (sessão própria, não afeta o bot em execução)...",
+    "syncingChats": "Sincronizando conversas...",
+    "chatsFound": "{{count}} conversa(s) encontrada(s).",
+    "noChatsSynced": "Nenhuma conversa sincronizada ainda. Certifique-se de que essa conta já tem histórico de conversas e tente novamente.",
+    "pickPrompt": "Escolha uma ou mais conversas (↑↓ + Espaço para marcar, Enter para confirmar).",
+    "cancelled": "Cancelado.",
+    "copied": "{{count}} ID(s) copiado(s) para a área de transferência:\n{{ids}}",
+    "copyFailed": "Não foi possível acessar a área de transferência — copie manualmente:\n{{ids}}",
+    "connectFailed": "Tentativa de conexão falhou — motivo: {{reason}}",
+    "retrying": "Tentando novamente ({{attempt}}/{{max}})...",
+    "sessionWiped": "Sessão descartada, tentando parear novamente ({{round}}/{{max}})...",
+    "connectGaveUp": "Não foi possível conectar após várias tentativas. Verifique sua conexão e tente de novo."
   }
 }

package/dist/utils/clipboard.js

@@ -0,0 +1,44 @@
+/**
+ * clipboard.ts
+ *
+ * Writes text to the system clipboard using whatever OS-native tool is
+ * available. No npm dependency — just spawns pbcopy/clip/xclip/xsel/wl-copy.
+ */
+import { spawn } from "child_process";
+function tryCommand(cmd, args, text) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn(cmd, args, { stdio: ["pipe", "ignore", "ignore"] });
+        }
+        catch {
+            resolve(false);
+            return;
+        }
+        child.on("error", () => resolve(false));
+        child.on("close", (code) => resolve(code === 0));
+        child.stdin.on("error", () => { });
+        child.stdin.write(text);
+        child.stdin.end();
+    });
+}
+/**
+ * Copies `text` to the system clipboard.
+ * Returns false (never throws) if no supported clipboard tool is found.
+ */
+export async function copyToClipboard(text) {
+    const candidates = process.platform === "darwin"
+        ? [["pbcopy", []]]
+        : process.platform === "win32"
+            ? [["clip", []]]
+            : [
+                ["xclip", ["-selection", "clipboard"]],
+                ["xsel", ["--clipboard", "--input"]],
+                ["wl-copy", []],
+            ];
+    for (const [cmd, args] of candidates) {
+        if (await tryCommand(cmd, args, text))
+            return true;
+    }
+    return false;
+}

package/package.json

@@ -5,11 +5,11 @@
     "name": "SyntaxError!",
     "email": "me@stxerr.dev"
   },
-  "version": "5.2.6",
+  "version": "5.3.1",
   "license": "GPL-3.0-only",
   "private": false,
   "engines": {
-    "node": ">=24.17.0"
+    "node": ">=24.0.0"
   },
   "repository": {
     "type": "git",
@@ -25,7 +25,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsc && node -e \"fs.mkdirSync('dist/locales', { recursive: true }); fs.cpSync('src/locales', 'dist/locales', { recursive: true });\"",
+    "build": "npm i && tsc && node -e \"fs.mkdirSync('dist/locales', { recursive: true }); fs.cpSync('src/locales', 'dist/locales', { recursive: true });\"",
     "start": "node dist/main.js",
     "typecheck": "tsc --noEmit"
   },
@@ -59,5 +59,10 @@
     "#config": "./dist/config.js",
     "#main": "./dist/main.js",
     "#types": "./dist/types.js"
+  },
+  "allowScripts": {
+    "@whiskeysockets/baileys@6.7.23": true,
+    "esbuild@0.28.1": true,
+    "protobufjs@7.6.4": true
   }
 }