@manybot/manybot 5.6.0 → 5.6.1

package/dist/drivers/baileys/adapter.js

@@ -25,12 +25,111 @@
 import { normalizeMessageContent, downloadMediaMessage, jidNormalizedUser, } from "@whiskeysockets/baileys";
 import { createHash } from "node:crypto";
 import { logger } from "#logger";
+/**
+ * Classify a Baileys message-content payload (`WAMessageContent`) into
+ * the neutral `(type, body, mimetype)` triple used by `BotMessage`. Pure
+ * function — no side effects, no closures — so it's safe to call for
+ * both real incoming messages and the embedded `quotedMessage` content
+ * carried in `contextInfo` (which can be an `ephemeralMessage`/
+ * `viewOnceMessage` wrapper, hence the `normalizeMessageContent` call).
+ *
+ * Exported so `api/index.ts` can decode the quoted payload when
+ * synthesizing the `BotMessage` returned by `getReply()`.
+ */
+export function decodeContent(content) {
+    const m = normalizeMessageContent(content) ?? undefined;
+    let type = "other";
+    let body = "";
+    let mimetype;
+    if (m?.conversation) {
+        type = "text";
+        body = m.conversation;
+    }
+    else if (m?.extendedTextMessage?.text) {
+        type = "text";
+        body = m.extendedTextMessage.text ?? "";
+    }
+    else if (m?.imageMessage) {
+        type = "image";
+        body = m.imageMessage.caption ?? "";
+        mimetype = m.imageMessage.mimetype ?? undefined;
+    }
+    else if (m?.videoMessage) {
+        type = "video";
+        body = m.videoMessage.caption ?? "";
+        mimetype = m.videoMessage.mimetype ?? undefined;
+    }
+    else if (m?.audioMessage) {
+        type = "audio";
+        mimetype = m.audioMessage.mimetype ?? undefined;
+    }
+    else if (m?.documentMessage) {
+        type = "document";
+        body = m.documentMessage.caption ?? "";
+        mimetype = m.documentMessage.mimetype ?? undefined;
+    }
+    else if (m?.stickerMessage) {
+        type = "sticker";
+        mimetype = m.stickerMessage.mimetype ?? undefined;
+    }
+    return { type, body, mimetype };
+}
 export function createBaileysAdapter(initial) {
     // mutable so rebind() can swap it; closure-scoped so the contract below
     // always sees the latest sock.
     let sock = initial.sock;
     const store = initial.store;
     // ── Adapter-local helpers ────────────────────────────────────────────────
+    /**
+     * Build the `quoted` option for `sock.sendMessage(jid, content, opts)`.
+     *
+     * Baileys expects the `quoted` field to be a full message-shaped object —
+     * `{ key: {...}, message: {...} }` — so it can extract both the attribution
+     * (stanzaId/participant/fromMe from `key`) and the preview content (from
+     * `message`) when generating contextInfo. Passing only `key` makes
+     * `generateWAMessageFromContent` call `normalizeMessageContent(undefined)`
+     * → `getContentType(undefined)` → `undefined`, then index it with `[]`
+     * and throw `Cannot read properties of undefined (reading 'undefined')`.
+     *
+     * We resolve the full envelope from the in-memory store, indexed by the
+     * (remoteJid, id) pair carried in the neutral `BotQuotedRef`. If the
+     * envelope is no longer present (evicted past MAX_MSGS_PER_CHAT, lost on
+     * restart, etc.) we return `undefined` rather than emit a half-formed
+     * `quoted` — degrading to a plain unquoted reply is safer than crashing
+     * the calling plugin.
+     */
+    function buildQuotedOpts(quoted) {
+        if (!quoted?.id || !quoted?.remoteJid)
+            return undefined;
+        const raw = store.messages.get(quoted.remoteJid)?.get(quoted.id);
+        const inner = raw?.message;
+        if (!inner)
+            return undefined; // safe fallback: no quoted at all
+        // `quoted` (used by sendMessage for reply-citation) is a
+        // message-shaped object: `{ key: {...}, message: {...} }`. Baileys
+        // reads `quoted.key.*` to populate contextInfo (stanzaId, participant,
+        // fromMe) — passing the fields flat used to misattribute the reply to
+        // the bot itself. `quoted.message` is also required: Baileys' internal
+        // `generateWAMessageFromContent` calls `normalizeMessageContent(
+        // quoted.message)` and indexes the result with `getContentType(...)`,
+        // which throws if `.message` is missing.
+        return { quoted: { key: toFlatKey(quoted), message: inner } };
+    }
+    /**
+     * Translate a neutral `BotQuotedRef` into the FLAT key shape Baileys
+     * expects for `react`/`delete`/`edit`/`readMessages` (proto.IMessageKey
+     * — `{ id, remoteJid, fromMe, participant }` directly, NOT nested under
+     * a `.key` field). The nested `{key, message}` form is reserved for the
+     * `quoted` field on sendMessage — see `buildQuotedOpts` above.
+     */
+    function toFlatKey(ref) {
+        return {
+            id: ref.id ?? null,
+            remoteJid: ref.remoteJid ?? "",
+            fromMe: !!ref.fromMe,
+            participant: ref.participant ?? undefined,
+        };
+    }
     /** Compute sha1-hex of a normalized buffer or string. */
     function sha1(input) {
         const hash = createHash("sha1");
@@ -45,40 +144,7 @@ export function createBaileysAdapter(initial) {
     /** Translate a Baileys WAMessage into the neutral BotMessage envelope. */
     function toBotMessage(msg) {
         const m = normalizeMessageContent(msg.message) ?? undefined;
-        let type = "other";
-        let body = "";
-        let mimetype;
-        if (m?.conversation) {
-            type = "text";
-            body = m.conversation;
-        }
-        else if (m?.extendedTextMessage?.text) {
-            type = "text";
-            body = m.extendedTextMessage.text ?? "";
-        }
-        else if (m?.imageMessage) {
-            type = "image";
-            body = m.imageMessage.caption ?? "";
-            mimetype = m.imageMessage.mimetype ?? undefined;
-        }
-        else if (m?.videoMessage) {
-            type = "video";
-            body = m.videoMessage.caption ?? "";
-            mimetype = m.videoMessage.mimetype ?? undefined;
-        }
-        else if (m?.audioMessage) {
-            type = "audio";
-            mimetype = m.audioMessage.mimetype ?? undefined;
-        }
-        else if (m?.documentMessage) {
-            type = "document";
-            body = m.documentMessage.caption ?? "";
-            mimetype = m.documentMessage.mimetype ?? undefined;
-        }
-        else if (m?.stickerMessage) {
-            type = "sticker";
-            mimetype = m.stickerMessage.mimetype ?? undefined;
-        }
+        const { type, body, mimetype } = decodeContent(msg.message);
         const key = msg.key;
         const contextInfo = m?.extendedTextMessage?.contextInfo ??
             m?.imageMessage?.contextInfo ??
@@ -86,6 +152,7 @@ export function createBaileysAdapter(initial) {
             m?.audioMessage?.contextInfo ??
             m?.documentMessage?.contextInfo ??
             undefined;
+        const ciTyped = contextInfo;
         return {
             id: msg.key.id ?? "",
             chatId: msg.key.remoteJid ?? "",
@@ -96,20 +163,27 @@ export function createBaileysAdapter(initial) {
             body,
             mimetype: mimetype ?? undefined,
             pushName: msg.pushName,
-            mentionedJid: contextInfo?.mentionedJid ?? undefined,
-            quotedKey: contextInfo?.stanzaId ? {
-                id: contextInfo.stanzaId,
+            mentionedJid: ciTyped?.mentionedJid ?? undefined,
+            quotedKey: ciTyped?.stanzaId ? {
+                id: ciTyped.stanzaId,
                 remoteJid: msg.key.remoteJid ?? undefined,
                 fromMe: false,
-                participant: contextInfo.participant ?? undefined,
+                participant: ciTyped.participant ?? undefined,
             } : undefined,
             fromLid: key.participantAlt,
             fromPn: key.participant,
             participantAlt: key.participantAlt,
             remoteJidAlt: key.remoteJidAlt,
-            // Poll-decryption key lives here for poll vote decryption downstream.
+            // Driver-specific escape hatches:
+            //   - pollEncKeyRaw: poll-decryption key for vote decryption
+            //   - contextInfo:   full IContextInfo (incl. embedded quotedMessage)
+            //                    so quoted-message consumers (api/index.ts
+            //                    buildMessageContext / downloadMedia fallback)
+            //                    can decode the quoted payload without going
+            //                    back through the store.
             _raw: {
                 pollEncKeyRaw: m?.messageContextInfo?.messageSecret ?? undefined,
+                contextInfo: ciTyped ?? undefined,
             },
         };
     }
@@ -237,17 +311,17 @@ export function createBaileysAdapter(initial) {
             return toSentRef(ref, jid);
         },
         async react(jid, target, emoji) {
-            const key = toBaileysKey(target);
+            const key = toFlatKey(target);
             await sock.sendMessage(jid, { react: { text: emoji, key } });
         },
         async deleteMessage(jid, target, forEveryone) {
             if (!forEveryone)
                 return;
-            const key = toBaileysKey(target);
+            const key = toFlatKey(target);
             await sock.sendMessage(jid, { delete: key });
         },
         async editMessage(jid, target, text) {
-            const key = toBaileysKey(target);
+            const key = toFlatKey(target);
             await sock.sendMessage(jid, { text, edit: key });
         },
         // ── presence + read ───────────────────────────────────────────────────
@@ -258,7 +332,7 @@ export function createBaileysAdapter(initial) {
             await sock.sendPresenceUpdate(baileyState, jid);
         },
         async readMessages(keys) {
-            const baileyKeys = keys.map(toBaileysKey);
+            const baileyKeys = keys.map((k) => toFlatKey(k));
             await sock.readMessages(baileyKeys);
         },
         // ── contacts ──────────────────────────────────────────────────────────
@@ -385,10 +459,30 @@ export function createBaileysAdapter(initial) {
         },
         // ── media (download) ───────────────────────────────────────────────────
         async downloadMedia(msg, opts) {
-            // The poll-decryption raw envelope left only what's needed for that,
-            // so to downloadMediaMessage we still need the original WAMessage.
-            // Get it back from the store by id.
-            const raw = store.messages.get(msg.chatId)?.get(msg.id);
+            // Resolve the Baileys message envelope needed by `downloadMediaMessage`.
+            // Preferred path: if the caller already carries the embedded message
+            // payload (synthetic `BotMessage` for a quoted message, whose
+            // `_raw.contextInfo.quotedMessage` is the full WAMessageContent),
+            // build the envelope directly from that. This avoids the silent
+            // failure mode where the quoted message's original envelope has
+            // aged out of the store's per-chat ring buffer.
+            //
+            // Fallback: the regular case (downloading media for the incoming
+            // message itself, or any other BotMessage that has a real envelope
+            // in the store) — look it up by (chatId, id).
+            const embedded = msg._raw;
+            const embeddedContent = embedded?.contextInfo?.quotedMessage;
+            const raw = embeddedContent
+                ? {
+                    key: {
+                        id: embedded.contextInfo?.stanzaId ?? msg.id,
+                        remoteJid: msg.chatId,
+                        fromMe: false,
+                        participant: embedded.contextInfo?.participant ?? undefined,
+                    },
+                    message: embeddedContent,
+                }
+                : store.messages.get(msg.chatId)?.get(msg.id);
             if (!raw)
                 return null;
             try {
@@ -508,31 +602,10 @@ export function createBaileysAdapter(initial) {
     };
 }
 // ── Helpers used inside the adapter above ────────────────────────────────────
-function buildQuotedOpts(quoted) {
-    if (!quoted)
-        return undefined;
-    return { quoted: toBaileysKey(quoted) };
-}
-function toBaileysKey(ref) {
-    // Baileys expects `quoted` to be a message-shaped object with these
-    // fields nested under `.key` (quoted.key.id / .remoteJid / .fromMe /
-    // .participant) — it reads quoted.key.* to build contextInfo
-    // (stanzaId, participant, fromMe). Passing them flat (as this used to)
-    // means quoted.key is undefined inside Baileys, so participant/fromMe
-    // resolve to undefined and the quoted reply gets misattributed to the
-    // bot itself instead of the original sender. The quoted text still
-    // rendered before this fix because WhatsApp's client resolves the
-    // preview content locally via stanzaId — only the author attribution
-    // was broken.
-    return {
-        key: {
-            id: ref.id ?? null,
-            remoteJid: ref.remoteJid ?? "",
-            fromMe: !!ref.fromMe,
-            participant: ref.participant ?? undefined,
-        },
-    };
-}
+//
+// `buildQuotedOpts` and `toFlatKey` are defined inside the
+// `createBaileysAdapter` closure (so they can see the `store`) — only
+// `toSentRef` and `silentBaileysLogger` remain module-scoped helpers.
 function toSentRef(raw, fallbackChatId) {
     const r = raw;
     return {

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

@@ -9,6 +9,7 @@
  * The ctx surface area is preserved so existing plugins stay compatible.
  */
 import { toBotMessage } from "#drivers/baileys/index.js";
+import { decodeContent } from "#drivers/baileys/adapter.js";
 import { logger } from "#logger";
 import { t, createPluginT, reloadTranslations, getCurrentLang } from "#i18n";
 import { CONFIG, CONFIG_DIR } from "#config";
@@ -731,22 +732,53 @@ export function buildMessageContext(msg, contract, store, guardOptions = {}) {
     const jitter = guardOptions.jitter ?? true;
     const contextInfo = getContextInfo(msg);
     // Build a synthetic quoted BotMessage when the original envelope carries
-    // a quotedMessage (the adapter pre-decoded it into msg.quotedKey).
-    const quotedRaw = msg.quotedKey
-        ? {
-            id: msg.quotedKey.id ?? "",
-            chatId: msg.chatId,
-            fromMe: false,
-            type: "other",
-            contentHash: "",
-            timestamp: 0,
-            _raw: msg._raw ? {
-                quotedMessage: msg._raw.quotedMessage,
-                stanzaId: msg._raw.stanzaId,
-                participant: msg._raw.participant,
-            } : undefined,
-        }
-        : null;
+    // a quotedMessage (the adapter pre-decodes the full IContextInfo into
+    // msg._raw.contextInfo). The synthetic uses the same decodeContent
+    // helper as toBotMessage so type/body/mimetype reflect what's actually
+    // in the quoted payload — without this, msgHasMedia()/downloadMedia()
+    // on the result of getReply() always reported type=other / no media,
+    // even when the quoted message was an image/video/document/etc.
+    //
+    // We carry the same _raw.contextInfo on the synthetic so a recursive
+    // getReply().getReply() keeps working (the inner call re-reads
+    // getContextInfo off _raw.contextInfo).
+    const quotedRaw = contextInfo?.quotedMessage
+        ? (() => {
+            const decoded = decodeContent(contextInfo.quotedMessage);
+            return {
+                id: contextInfo.stanzaId ?? "",
+                chatId: msg.chatId,
+                fromMe: false,
+                type: decoded.type,
+                contentHash: "",
+                timestamp: 0,
+                body: decoded.body,
+                mimetype: decoded.mimetype,
+                _raw: {
+                    contextInfo: {
+                        stanzaId: contextInfo.stanzaId,
+                        participant: contextInfo.participant,
+                        mentionedJid: contextInfo.mentionedJid,
+                        quotedMessage: contextInfo.quotedMessage,
+                    },
+                },
+            };
+        })()
+        : msg.quotedKey
+            // No embedded quotedMessage (older envelopes, evicted from store, or
+            // the quoted message pre-dates contextInfo-quoting). Fall back to a
+            // key-only synthetic so hasReply()/getReply() still work, but
+            // hasMedia/downloadMedia on the result will degrade gracefully
+            // (type=other, mimetype=undefined).
+            ? {
+                id: msg.quotedKey.id ?? "",
+                chatId: msg.chatId,
+                fromMe: false,
+                type: "other",
+                contentHash: "",
+                timestamp: 0,
+            }
+            : null;
     return {
         id: msg.id,
         timestamp: msg.timestamp || 0,
@@ -1831,25 +1863,6 @@ export function buildApi({ msg, chat, contract, store, pluginRegistry, pluginNam
     const cooldown = (guardOptions.cooldown ?? true);
     const jitter = (guardOptions.jitter ?? true);
     bindGroupMetaInvalidation(contract);
-    // Sender for quoted messages — synthesize a neutral BotQuotedRef off
-    // the adapter's pre-extracted contextInfo fields. No raw Baileys
-    // envelope access needed here.
-    const contextInfo = getContextInfo(msg);
-    const quotedRaw = contextInfo?.quotedMessage
-        ? {
-            id: contextInfo.stanzaId ?? "",
-            chatId: msg.chatId,
-            fromMe: false,
-            type: "other",
-            contentHash: "",
-            timestamp: 0,
-            _raw: {
-                quotedMessage: contextInfo.quotedMessage,
-                stanzaId: contextInfo.stanzaId,
-                participant: contextInfo.participant,
-            },
-        }
-        : null;
     // Group participant JIDs come back in whatever addressing mode the group
     // uses (@lid or @s.whatsapp.net/@c.us) — same issue as poll vote decryption.
     // "sender" and the bot's own JID are usually PN-normalized, so a straight

package/dist/drivers/baileys/index.js

@@ -27,6 +27,7 @@ import { normalizeJid } from "#drivers/jid.js";
 import { loadPlugins, setupPlugins } from "#kernel/pluginLoader.js";
 import { runContactRefreshSweep } from "#kernel/contactAutoSave.js";
 import { registerAlertSockProvider, sendAlert } from "#kernel/alerts.js";
+import { getDriverManager } from "#kernel/driverManager.js";
 import { startUpdateCheckSchedule, stopUpdateCheckSchedule } from "#kernel/updateCheck.js";
 import { setStatus } from "#kernel/statusServer.js";
 import { logger } from "#logger";
@@ -93,6 +94,12 @@ const RECONNECT_MAX_MS = 60000;
 // silently retrying past this point can make a restriction last longer.
 const MAX_RECONNECT_ATTEMPTS = 6;
 const CACHE_SAVE_INTERVAL_MS = 5 * 60 * 1000; // 5min
+// Track consecutive restartRequired (515) — same counter space as
+// reconnectAttempts but with a lower threshold for degradation since
+// repeated 515 signals a protocol drift the current session can't
+// recover from on its own.
+const MAX_RESTART_REQUIRED = 3;
+let restartRequiredCount = 0;
 /**
  * Loads the on-disk cache and merges it into `store` (union, never
  * overwrite — see client/cache.ts). Runs once per process: the shared
@@ -193,6 +200,7 @@ async function startBot() {
         if (connection === "open") {
             state = "READY_INIT";
             reconnectAttempts = 0;
+            restartRequiredCount = 0;
             setStatus(true);
             logger.success(t("system.connected"));
             logger.info(t("system.clientId", { id: CLIENT_ID }));
@@ -211,11 +219,19 @@ async function startBot() {
         if (connection === "close") {
             const code = lastDisconnect?.error?.output?.statusCode;
             const loggedOut = code === DisconnectReason.loggedOut;
+            const badSession = code === DisconnectReason.badSession;
+            const restartReq = code === DisconnectReason.restartRequired;
             state = "BOOT";
             setStatus(false, String(code));
             logger.warn(t("system.disconnected", { reason: String(code) }));
-            if (loggedOut) {
-                logger.warn(t("system.sessionExpired"));
+            if (loggedOut || badSession) {
+                if (badSession) {
+                    logger.warn("Session data corrupted (badSession=500). Clearing session dir.");
+                    getDriverManager().markDegraded("baileys", 300_000);
+                }
+                else {
+                    logger.warn(t("system.sessionExpired"));
+                }
                 try {
                     await fs.rm(AUTH_DIR, { recursive: true, force: true });
                 }
@@ -224,9 +240,27 @@ async function startBot() {
                 }
                 scheduleReconnect(1000);
             }
+            else if (restartReq) {
+                restartRequiredCount++;
+                if (restartRequiredCount >= MAX_RESTART_REQUIRED) {
+                    halted = true;
+                    logger.error(`restartRequired (515) recurring — protocol drift suspected. Halting.`);
+                    getDriverManager().markDegraded("baileys", 600_000);
+                    sendAlert({
+                        level: "critical",
+                        title: "manybot — restartRequired recurring",
+                        message: `Protocol drift suspected after ${restartRequiredCount}x restartRequired. Bot halted on Baileys. Run connect() manually.`,
+                    }).catch(() => { });
+                    return;
+                }
+                const delay = Math.min(500, RECONNECT_BASE_MS);
+                logger.info(t("system.reconnecting", { secs: Math.round(delay / 1000) }));
+                scheduleReconnect(delay);
+            }
             else if (!shuttingDown) {
                 if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
                     halted = true;
+                    getDriverManager().markDegraded("baileys", 600_000);
                     logger.error(t("system.reconnectHalted", { attempts: reconnectAttempts }));
                     sendAlert({
                         level: "critical",

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

@@ -19,7 +19,7 @@ import pino from "pino";
 // setMaxListeners (see the comment in createSocket() below) — raised
 // globally instead, before makeWASocket() ever constructs one.
 EventEmitter.defaultMaxListeners = 50;
-export const AUTH_DIR = path.join(CONFIG_DIR, "sessions", CLIENT_ID);
+export const AUTH_DIR = path.join(CONFIG_DIR, "sessions", CLIENT_ID, "baileys");
 // ── Shared store (survives socket reconnects) ─────────────────────────────────
 export const store = createStore();
 /**

package/dist/drivers/whatsmeow/client.js

@@ -1,9 +1,11 @@
 import { logger } from "#logger";
 import { CONFIG } from "#config";
+import { t } from "#i18n";
 import * as grpc from "@grpc/grpc-js";
 import * as protoLoader from "@grpc/proto-loader";
 import path from "path";
 import { fileURLToPath } from "node:url";
+import qrcode from "qrcode-terminal";
 /**
  * Whatsmeow gRPC client implementing the WaContract interface.
  *
@@ -50,7 +52,7 @@ class WhatsmeowClient {
         const address = CONFIG.drivers.whatsmeow.grpcAddress ?? "localhost:50051";
         const Service = this.loadProto();
         this.client = new Service(address, grpc.credentials.createInsecure());
-        // Perform a health check to confirm service is ready
+        // 1. Health check — confirm the gRPC server is up
         await new Promise((resolve, reject) => {
             this.client.HealthCheck({}, (err, resp) => {
                 if (err)
@@ -62,12 +64,43 @@ class WhatsmeowClient {
                     reject(new Error("Whatsmeow service not ready"));
             });
         });
-        logger.info("[whatsmeow] connected via gRPC");
-        // Open the server-streaming event subscription. Each WaEvent that
-        // arrives is fanned out to the local on() subscribers in the
-        // neutral envelope shape.
+        logger.info("[whatsmeow] gRPC service ready");
+        // 2. Call Connect RPC — initiates WhatsApp auth (QR or reuse existing session)
+        const connectResp = await new Promise((resolve, reject) => {
+            this.client.Connect({}, (err, resp) => {
+                if (err)
+                    return reject(err);
+                resolve(resp);
+            });
+        });
+        const needsAuth = !connectResp.ok;
+        if (needsAuth && connectResp.qrCode) {
+            logger.info(t("system.qrScan"));
+            qrcode.generate(connectResp.qrCode, { small: true });
+        }
+        // 3. Set up auth deferred BEFORE SubscribeEvents to avoid race
+        let authDeferred = null;
+        let authDone = false;
+        const authPromise = needsAuth
+            ? new Promise((resolve, reject) => {
+                authDeferred = { resolve, reject };
+                setTimeout(() => {
+                    if (!authDone) {
+                        authDone = true;
+                        reject(new Error("Whatsmeow auth timeout (2 min)"));
+                    }
+                }, 120_000);
+            })
+            : Promise.resolve();
+        // 4. Open the server-streaming event subscription
         const stream = this.client.SubscribeEvents({});
         stream.on("data", (raw) => {
+            // Resolve auth promise when connection opens (QR scanned / session reused)
+            if (!authDone && authDeferred && raw.connState?.state === "open") {
+                authDone = true;
+                authDeferred.resolve();
+                authDeferred = null;
+            }
             try {
                 if (raw.connState) {
                     const state = raw.connState.state ?? "connecting";
@@ -87,13 +120,29 @@ class WhatsmeowClient {
             }
         });
         stream.on("error", (err) => {
+            if (!authDone) {
+                authDone = true;
+                authDeferred?.reject(err);
+                authDeferred = null;
+            }
             logger.warn(`[whatsmeow] event stream error: ${err.message}`);
             this.ready = false;
         });
         stream.on("end", () => {
+            if (!authDone) {
+                authDone = true;
+                authDeferred?.reject(new Error("Event stream ended before auth completed"));
+                authDeferred = null;
+            }
             logger.warn(`[whatsmeow] event stream ended`);
             this.ready = false;
         });
+        // 5. If not authenticated, wait for connState === "open" from the event stream
+        await authPromise;
+        if (needsAuth) {
+            logger.info("[whatsmeow] authenticated");
+        }
+        this.ready = true;
     }
     async disconnect() {
         if (this.client) {

package/dist/drivers/whatsmeow/installer.js

@@ -1,7 +1,7 @@
-import { mkdirSync, writeFileSync, chmodSync } from "node:fs";
+import { mkdirSync, writeFileSync, chmodSync, existsSync } from "node:fs";
 import path from "node:path";
 import * as clack from "@clack/prompts";
-import { persistConfigValue } from "#config";
+import { persistConfigValue, CONFIG_DIR } from "#config";
 import { t } from "#i18n";
 const SUPPORTED = [
     { os: "linux", arch: "x64", name: "whatsmeow-service-linux-x64" },
@@ -22,7 +22,7 @@ async function fetchLatestTag() {
     return data.tag_name ?? "v5.6.1";
 }
 function binaryDir() {
-    return path.resolve(process.cwd(), "whatsmeow-service", "bin");
+    return path.resolve(CONFIG_DIR, "whatsmeow-service", "bin");
 }
 export async function promptWhatsmeowInstall() {
     const target = detectTarget();
@@ -30,6 +30,16 @@ export async function promptWhatsmeowInstall() {
         clack.log.warn(str(t("whatsmeow.unsupportedArch", { os: process.platform, arch: process.arch })));
         return;
     }
+    const outPath = path.join(binaryDir(), "whatsmeow-service");
+    // Binary already on disk → skip the prompt and the download, but
+    // make sure the config flag is set so the supervisor boots on the
+    // next run. The earlier "no, declined install" flow only writes the
+    // TOML on success, so users who later build the binary by hand also
+    // hit this branch on their next first-login.
+    if (existsSync(outPath)) {
+        await persistConfigValue("driver_whatsmeow_enabled", "true");
+        return;
+    }
     const choice = await clack.confirm({
         message: str(t("whatsmeow.installPrompt")),
         initialValue: false,
@@ -61,10 +71,16 @@ export async function promptWhatsmeowInstall() {
     const buffer = Buffer.from(await res.arrayBuffer());
     const dir = binaryDir();
     mkdirSync(dir, { recursive: true });
-    const outPath = path.join(dir, "whatsmeow-service");
     writeFileSync(outPath, buffer);
     chmodSync(outPath, 0o755);
     await persistConfigValue("driver_whatsmeow_enabled", "true");
     spin.stop(str(t("whatsmeow.installed", { path: outPath })));
     clack.note(str(t("whatsmeow.restartNotice")), str(t("whatsmeow.installTitle")));
+    // The bot is still in its very first run (no Baileys session yet, no
+    // supervisor spawned) — the config has just been updated on disk but
+    // the in-memory `CONFIG` object and the supervisor lifecycle were
+    // initialized at startup with `whatsmeow.enabled = false`. Restarting
+    // is required for the new value to take effect. Exit cleanly so the
+    // user just re-runs the bot.
+    setTimeout(() => process.exit(0), 100);
 }

package/dist/drivers/whatsmeow/supervisor.js

@@ -30,12 +30,13 @@
  * See the lifecycle contract this implements.
  */
 import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, mkdirSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { CONFIG } from "#config";
+import { CONFIG, CONFIG_DIR, CLIENT_ID } from "#config";
 import { logger } from "#logger";
 import { fireAlert } from "#kernel/alerts.js";
+import { getDriverManager } from "#kernel/driverManager.js";
 // ── Tunables (mirror drivers/baileys/index.ts:98-106) ──────────────────────
 const RECONNECT_BASE_MS = 1000;
 const RECONNECT_MAX_MS = 60_000;
@@ -49,7 +50,8 @@ const SHUTDOWN_GRACE_MS = 5_000;
  * first match that exists and is a regular file. Order:
  *   1. CONFIG.drivers.whatsmeow.binaryPath (explicit user choice)
  *   2. env WM_BINARY_PATH (escape hatch for exotic installs)
- *   3. dev layout (<cwd>/whatsmeow-service/bin/whatsmeow-service)
+ *   3. stable config dir (~/.manybot/whatsmeow-service/bin/whatsmeow-service)
+ *   4. dev layout (<cwd>/whatsmeow-service/bin/whatsmeow-service)
  *   4. npm-global layout (sibling of the node binary, /usr/local style)
  */
 function resolveBinaryPath() {
@@ -60,6 +62,8 @@ function resolveBinaryPath() {
     const fromEnv = process.env.WM_BINARY_PATH;
     if (fromEnv)
         candidates.push(path.resolve(fromEnv));
+    // Stable config dir: ~/.manybot/whatsmeow-service/bin/whatsmeow-service
+    candidates.push(path.resolve(CONFIG_DIR, "whatsmeow-service", "bin", "whatsmeow-service"));
     // Dev: `<repo>/whatsmeow-service/bin/whatsmeow-service`
     candidates.push(path.resolve(process.cwd(), "whatsmeow-service", "bin", "whatsmeow-service"));
     // Global npm install: `<prefix>/bin/../share/manybot/bin/whatsmeow-service`
@@ -148,8 +152,12 @@ export async function startWhatsmeowSupervisor() {
             "whatsmeow-service/bin/whatsmeow-service relative to cwd. Bot will run on Baileys only.");
         return null;
     }
+    logger.info(`[supervisor] using binary: ${binary}`);
     const grpcAddress = CONFIG.drivers.whatsmeow.grpcAddress || "localhost:50051";
-    const sessionDir = path.resolve(process.cwd(), "whatsmeow-session.db");
+    const sessionDir = path.resolve(CONFIG_DIR, "sessions", CLIENT_ID, "whatsmeow", "session.db");
+    // Ensure the parent directory exists before the Go subprocess tries to
+    // create/open the SQLite file.
+    mkdirSync(path.dirname(sessionDir), { recursive: true });
     const state = {
         proc: null,
         pid: null,
@@ -196,6 +204,7 @@ export async function startWhatsmeowSupervisor() {
         state.halted = true;
         state.ready = false;
         state.readyDeferred?.reject(new Error(reason));
+        getDriverManager().markDegraded("whatsmeow", 600_000);
         fireAlert("whatsmeow_subprocess_halted", { reason });
     }
     function scheduleRestart() {
@@ -220,7 +229,17 @@ export async function startWhatsmeowSupervisor() {
         let proc;
         try {
             proc = spawn(state.binary, ["--grpc-addr", state.addr, "--session-dir", state.sessionDir], {
-                stdio: "ignore",
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            // Forward Go service stdout/stderr to the bot log so we can see
+            // crashes, missing dependencies, port-in-use, etc. Without this
+            // `stdio: "ignore"` would discard everything and a crashed
+            // subprocess would only surface as an exit code.
+            proc.stdout?.on("data", (chunk) => {
+                process.stdout.write(`[whatsmeow-stdout] ${chunk}`);
+            });
+            proc.stderr?.on("data", (chunk) => {
+                process.stderr.write(`[whatsmeow-stderr] ${chunk}`);
             });
         }
         catch (e) {

package/dist/kernel/sendFallbackGuard.js

@@ -81,11 +81,21 @@ export async function sendWithFallback(jid, text, opts = {}) {
     // waitForSendSlot is the same throttle the rest of the senders use
     // (fallback must respect rate-limit too).
     await waitForSendSlot(jid, { cooldown: true, jitter: true });
-    const ref = await primary.sendText(jid, text, opts);
-    if (await verifyDelivery(primary, jid, ref, drivers.verifyWindowMs)) {
-        return ref;
+    let primaryRef = null;
+    let primarySendFailed = false;
+    try {
+        primaryRef = await primary.sendText(jid, text, opts);
+    }
+    catch (err) {
+        primarySendFailed = true;
+        logger.warn({ driver: primaryKey, jid, error: String(err) }, "send threw on primary");
+    }
+    if (!primarySendFailed) {
+        if (await verifyDelivery(primary, jid, primaryRef, drivers.verifyWindowMs)) {
+            return primaryRef;
+        }
+        logger.warn({ driver: primaryKey, jid, messageId: primaryRef.id }, "send not confirmed by primary");
     }
-    logger.warn({ driver: primaryKey, jid, messageId: ref.id }, "send not confirmed by primary");
     dm.markDegraded(primaryKey, drivers.fallbackCooldownMs);
     const secondary = pickSecondary(dm, primaryKey);
     if (!secondary || !secondary.isReady()) {
@@ -94,7 +104,7 @@ export async function sendWithFallback(jid, text, opts = {}) {
     }
     try {
         const fallbackRef = await sendVia(secondary, jid, text, opts, drivers.verifyWindowMs, /*skipGuard=*/ true);
-        logger.info({ driver: secondary.name, jid, messageId: fallbackRef.id, reason: "primary verification failed" }, "message sent via fallback");
+        logger.info({ driver: secondary.name, jid, messageId: fallbackRef.id, reason: primarySendFailed ? "send threw" : "primary verification failed" }, "message sent via fallback");
         return fallbackRef;
     }
     catch (err) {

package/dist/locales/en.json

@@ -71,7 +71,7 @@
     "connectGaveUp": "Couldn't connect after several attempts. Check your network and try again."
   },
   "whatsmeow": {
-    "installPrompt": "Install whatsmeow driver for better fallback support?",
+    "installPrompt": "Install whatsmeow driver for fallback support? (EXPERIMENTAL — only text send & history work; other methods throw)",
     "unsupportedArch": "whatsmeow driver not available for {{os}}-{{arch}}. The bot will use Baileys only.",
     "fetchingTag": "Fetching latest whatsmeow release...",
     "fetchFailed": "Could not reach Codeberg. Skipping whatsmeow install.",
@@ -79,6 +79,7 @@
     "downloadFailed": "Download failed: {{reason}}",
     "installTitle": "whatsmeow driver",
     "installed": "whatsmeow driver installed at {{path}}",
-    "restartNotice": "Restart the bot for the whatsmeow driver to take effect."
+    "restartNotice": "Restart the bot for the whatsmeow driver to take effect.",
+    "experimentalNotice": "whatsmeow is EXPERIMENTAL: only sendText and getHistory are implemented. sendImage, sendPoll, groupMetadata, and other methods throw."
   }
 }

package/dist/locales/es.json

@@ -71,7 +71,7 @@
     "connectGaveUp": "No se pudo conectar tras varios intentos. Revisa tu conexión e intenta de nuevo."
   },
   "whatsmeow": {
-    "installPrompt": "¿Instalar el driver whatsmeow para mejor soporte de fallback?",
+    "installPrompt": "¿Instalar el driver whatsmeow para soporte de fallback? (EXPERIMENTAL — solo sendText e historial funcionan; otros métodos lanzan error)",
     "unsupportedArch": "Driver whatsmeow no disponible para {{os}}-{{arch}}. El bot usará solo Baileys.",
     "fetchingTag": "Obteniendo última versión de whatsmeow...",
     "fetchFailed": "No se pudo contactar a Codeberg. Instalación de whatsmeow omitida.",
@@ -79,6 +79,7 @@
     "downloadFailed": "Descarga fallida: {{reason}}",
     "installTitle": "Driver whatsmeow",
     "installed": "Driver whatsmeow instalado en {{path}}",
-    "restartNotice": "Reinicia el bot para que el driver whatsmeow surta efecto."
+    "restartNotice": "Reinicia el bot para que el driver whatsmeow surta efecto.",
+    "experimentalNotice": "whatsmeow es EXPERIMENTAL: solo sendText y getHistory están implementados. sendImage, sendPoll, groupMetadata y otros métodos lanzan error."
   }
 }

package/dist/locales/pt.json

@@ -71,7 +71,7 @@
     "connectGaveUp": "Não foi possível conectar após várias tentativas. Verifique sua conexão e tente de novo."
   },
   "whatsmeow": {
-    "installPrompt": "Instalar driver whatsmeow para melhor suporte a fallback?",
+    "installPrompt": "Instalar driver whatsmeow para suporte a fallback? (EXPERIMENTAL — apenas sendText e histórico funcionam; outros métodos lançam erro)",
     "unsupportedArch": "Driver whatsmeow não disponível para {{os}}-{{arch}}. O bot usará apenas Baileys.",
     "fetchingTag": "Buscando última versão do whatsmeow...",
     "fetchFailed": "Não foi possível acessar o Codeberg. Instalação do whatsmeow ignorada.",
@@ -79,6 +79,7 @@
     "downloadFailed": "Download falhou: {{reason}}",
     "installTitle": "Driver whatsmeow",
     "installed": "Driver whatsmeow instalado em {{path}}",
-    "restartNotice": "Reinicie o bot para que o driver whatsmeow entre em efeito."
+    "restartNotice": "Reinicie o bot para que o driver whatsmeow entre em efeito.",
+    "experimentalNotice": "whatsmeow é EXPERIMENTAL: apenas sendText e getHistory estão implementados. sendImage, sendPoll, groupMetadata e outros métodos lançam erro."
   }
 }

package/dist/main.js

@@ -11,6 +11,7 @@ process.env.NODE_PATH = path.resolve(process.cwd(), "node_modules");
 Module._initPaths();
 import { baileysContract } from "#drivers/baileys/index.js";
 import { whatsmeowContract, startWhatsmeowSupervisor, wrapWithSupervisor } from "#drivers/whatsmeow/index.js";
+import { promptWhatsmeowInstall } from "#drivers/whatsmeow/installer.js";
 import { cleanupPlugins } from "#kernel/pluginLoader.js";
 import { stopAll as stopScheduler } from "#kernel/scheduler.js";
 import { sendAlert } from "#kernel/alerts.js";
@@ -35,12 +36,20 @@ driverManager.register(baileysContract, { isPrimary: CONFIG.drivers.primary ===
 // running on Baileys alone, no fallback.
 let supervisor = null;
 if (CONFIG.drivers.whatsmeow.enabled) {
+    logger.info("[driverManager] whatsmeow enabled — spawning supervisor");
     supervisor = await startWhatsmeowSupervisor();
     if (supervisor) {
         const wrapped = wrapWithSupervisor(whatsmeowContract, supervisor);
         driverManager.register(wrapped, { isPrimary: CONFIG.drivers.primary === "whatsmeow" });
+        logger.info(`[driverManager] whatsmeow registered (primary=${CONFIG.drivers.primary === "whatsmeow"})`);
+    }
+    else {
+        logger.warn("[driverManager] whatsmeow supervisor failed to start — fallback disabled");
     }
 }
+else {
+    logger.info("[driverManager] whatsmeow disabled by config — no fallback");
+}
 const activeDriver = driverManager.active();
 const secondaryName = (activeDriver.name === "baileys" ? "whatsmeow" : "baileys");
 const secondaryDriver = driverManager.get(secondaryName);
@@ -125,6 +134,16 @@ if (process.argv.includes("--getid")) {
         process.exit(1);
     });
 }
+else if (process.argv.includes("--install-whatsmeow")) {
+    // Re-run the whatsmeow installer outside the normal setup flow.
+    // Useful when the initial install failed or the binary was moved.
+    promptWhatsmeowInstall()
+        .then(() => process.exit(0))
+        .catch((err) => {
+        logger.error(`--install-whatsmeow failed: ${err.message}`);
+        process.exit(1);
+    });
+}
 else {
     // Start bot
     logger.info(t("bot.initialized"));
@@ -143,10 +162,14 @@ else {
         // here is non-fatal: the primary keeps running, fallback just stays
         // unavailable (sendFallbackGuard's `isReady()` check covers that).
         if (secondaryDriver) {
+            logger.info(`[driverManager] connecting secondary "${secondaryName}" in background…`);
             secondaryDriver.connect()
                 .then(() => logger.info(`[driverManager] secondary "${secondaryName}" connected — fallback available`))
                 .catch((err) => logger.warn(`[driverManager] secondary "${secondaryName}" connect failed: ${err.message} — fallback unavailable`));
         }
+        else {
+            logger.info(`[driverManager] no secondary driver registered — running on ${activeDriver.name} only`);
+        }
     })
         .catch((err) => {
         shutdown(`Failed to connect driver: ${err.message}`, true);

package/package.json

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