@manybot/manybot 5.5.3 → 5.6.0

package/dist/drivers/baileys/index.js

@@ -0,0 +1,560 @@
+/**
+ * drivers/baileys/index.ts
+ *
+ * Main WhatsApp driver entry point (Baileys implementation).
+ *
+ * Owns the socket state machine (connect / disconnect / reconnect /
+ * circuit breaker) and exposes the live `WaContract` adapter to the
+ * rest of the kernel. Plugins, sendFallbackGuard, messageHandler,
+ * pluginLoader, contactAutoSave and sendGuard all consume the
+ * `WaContract` returned here — they never touch the raw Baileys socket.
+ *
+ * The contract's per-call methods (sendText, react, presence, etc.)
+ * come from `./adapter.ts` (createBaileysAdapter). The lifecycle
+ * methods (connect / disconnect / isReady) live HERE because they
+ * also drive the chat-cache persistence, plugin reload, alert
+ * registration, and the reconnect circuit breaker — none of which
+ * the adapter should know about.
+ *
+ * For the verification-required path (sendFallbackGuard), the contract
+ * also exposes `getHistory?` — which the adapter populates from the
+ * Baileys store.messages map on demand.
+ */
+import { createSocket, AUTH_DIR, store as sharedStore } from "./sdk/baileysSock.js";
+import { createBaileysAdapter } from "./adapter.js";
+import { handleMessage } from "./messageHandler.js";
+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 { startUpdateCheckSchedule, stopUpdateCheckSchedule } from "#kernel/updateCheck.js";
+import { setStatus } from "#kernel/statusServer.js";
+import { logger } from "#logger";
+import { PLUGINS, CLIENT_ID } from "#config";
+import { t } from "#i18n";
+import { printBanner } from "#client/banner.js";
+import { loadChatCache, saveChatCache, isCacheFresh } from "#client/cache.js";
+import { DisconnectReason } from "@whiskeysockets/baileys";
+import fs from "fs/promises";
+import * as clack from "@clack/prompts";
+import { copyToClipboard } from "#utils/clipboard.js";
+import { applyPatches } from "../patches/index.js";
+applyPatches();
+let state = "BOOT";
+let shuttingDown = false;
+let currentSock = null;
+let currentStore = null;
+let currentAdapter = null;
+let reconnectTimer = null;
+let connecting = false;
+let reconnectAttempts = 0;
+let halted = false;
+let cacheHydrated = false;
+let cacheSaveTimer = null;
+let contactRefreshTimer = null;
+registerAlertSockProvider(() => currentSock);
+// ── Per-chat message queue ──────────────────────────────────────────────────
+// Messages from the same chat are processed one at a time (in order), but
+// different chats run concurrently — a slow plugin in one chat (e.g. sticker
+// generation) no longer blocks replies in every other chat.
+const chatQueues = new Map();
+function enqueueForChat(jid, task) {
+    const prev = chatQueues.get(jid) ?? Promise.resolve();
+    const settled = prev.catch(() => { }).then(task).catch((e) => {
+        const err = e instanceof Error ? e : new Error(String(e));
+        logger.error(`${err.message}\n${err.stack}`);
+    });
+    chatQueues.set(jid, settled);
+    settled.finally(() => {
+        if (chatQueues.get(jid) === settled)
+            chatQueues.delete(jid);
+    });
+}
+// Messages older than this (WhatsApp's own delivery delay — e.g. backlog
+// dumped after the bot reconnects) are skipped. Checked at arrival time,
+// so time spent waiting in chatQueues never counts against a message.
+const MAX_MESSAGE_AGE_SECONDS = 60;
+function isMessageStale(timestamp) {
+    if (!timestamp)
+        return false;
+    const nowInSeconds = Math.floor(Date.now() / 1000);
+    const age = nowInSeconds - timestamp;
+    if (age > MAX_MESSAGE_AGE_SECONDS)
+        return true;
+    return false;
+}
+const RECONNECT_BASE_MS = 1000;
+const RECONNECT_MAX_MS = 60000;
+// Circuit breaker: after this many consecutive failed reconnects, stop
+// retrying automatically instead of hammering the connection forever.
+// Rapid repeated attempts are themselves a ban signal (WhatsApp's abuse
+// detection treats connect/disconnect loops as suspicious automation and
+// each failed re-pairing attempt during a cooldown resets its timer), so
+// 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
+/**
+ * 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;
+}
+// Runs a few times a day, each time touching only a couple of stale
+// contacts (see REFRESH_SWEEP_SAMPLE) — deliberately slow and staggered,
+// same anti-detection reasoning as everything else in sendGuard.
+const CONTACT_REFRESH_INTERVAL_MS = 6 * 60 * 60 * 1000;
+function startContactRefreshSweep(contract) {
+    if (contactRefreshTimer)
+        return;
+    contactRefreshTimer = setInterval(() => {
+        runContactRefreshSweep(contract).catch(() => { });
+    }, CONTACT_REFRESH_INTERVAL_MS);
+}
+function stopContactRefreshSweep() {
+    if (!contactRefreshTimer)
+        return;
+    clearInterval(contactRefreshTimer);
+    contactRefreshTimer = 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;
+    // Build the driver-neutral WaContract adapter on top of this socket.
+    // Everything in the kernel (setupPlugins, handleMessage, sendGuard,
+    // contactAutoSave, ...) talks to the contract, never to the raw sock
+    // directly — that's how the whatsmeow driver plugs in as a second
+    // adapter without any of them knowing which one is active.
+    const adapter = createBaileysAdapter({ sock, store });
+    currentAdapter = adapter;
+    const contract = adapter.contract;
+    connecting = false;
+    let pluginsReady = false;
+    // ── Normal bot mode ─────────────────────────────────────────────────────────
+    sock.ev.on("connection.update", async (update) => {
+        const { connection, lastDisconnect } = update;
+        if (connection === "open") {
+            state = "READY_INIT";
+            reconnectAttempts = 0;
+            setStatus(true);
+            logger.success(t("system.connected"));
+            logger.info(t("system.clientId", { id: CLIENT_ID }));
+            printBanner();
+            if (!pluginsReady) {
+                pluginsReady = true;
+                await loadPlugins(PLUGINS);
+                await setupPlugins(contract, store);
+            }
+            startCacheAutosave(store);
+            startContactRefreshSweep(contract);
+            startUpdateCheckSchedule();
+            // buffer anti-replay / sync ghost messages
+            setTimeout(() => { state = "READY"; }, 2000);
+        }
+        if (connection === "close") {
+            const code = lastDisconnect?.error?.output?.statusCode;
+            const loggedOut = code === DisconnectReason.loggedOut;
+            state = "BOOT";
+            setStatus(false, String(code));
+            logger.warn(t("system.disconnected", { reason: String(code) }));
+            if (loggedOut) {
+                logger.warn(t("system.sessionExpired"));
+                try {
+                    await fs.rm(AUTH_DIR, { recursive: true, force: true });
+                }
+                catch (e) {
+                    logger.error(`[whatsapp] Failed to remove session dir: ${e.message}`);
+                }
+                scheduleReconnect(1000);
+            }
+            else if (!shuttingDown) {
+                if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+                    halted = true;
+                    logger.error(t("system.reconnectHalted", { attempts: reconnectAttempts }));
+                    sendAlert({
+                        level: "critical",
+                        title: "manybot parou de tentar reconectar",
+                        message: `Desisti após ${reconnectAttempts} tentativas — possível restrição de conta. Rode connect() manualmente pra tentar de novo.`,
+                    }).catch(() => { });
+                    return;
+                }
+                const delay = nextBackoffMs();
+                logger.info(t("system.reconnecting", { secs: Math.round(delay / 1000) }));
+                scheduleReconnect(delay);
+            }
+        }
+    });
+    // Subscribe to the contract's translated messages.upsert events so
+    // there's a single placeholder where the WAMessage → BotMessage
+    // conversion lives (the adapter). The adapter's rebind() handles
+    // re-subscribing on the fresh socket on reconnect — we registered
+    // once here, that's it.
+    contract.on("messages.upsert", ({ messages, type }) => {
+        if (state !== "READY")
+            return;
+        if (type !== "notify" && type !== "append")
+            return;
+        for (const msg of messages) {
+            const tsSec = Math.floor(msg.timestamp / 1000);
+            if (type === "append" && !msg.fromMe)
+                continue;
+            if (isMessageStale(tsSec))
+                continue;
+            const jid = normalizeJid(msg.chatId);
+            enqueueForChat(jid, () => handleMessage(msg, contract, store));
+        }
+    });
+}
+/**
+ * isReady() mirrors the "open" event from Baileys — once connect() resolves
+ * we don't yet have a session, so we wait for the connection.update === "open"
+ * path to flip the flag. isReady() requires true ONLY after both.
+ */
+function sockIsOpen() {
+    return state === "READY" || state === "READY_INIT";
+}
+// ── Public driver: WaContract ────────────────────────────────────────────────
+//
+// Drivers expose the full WaContract surface: the kernel plugs in this
+// object, and the lifecycle methods (connect / disconnect / isReady) wrap
+// the startBot state machine. Until connect() resolves, the contract's
+// per-call methods throw — plugins are only loaded after `connection.update
+// === "open"`, so they never see the pre-connect state.
+function requireReady() {
+    if (!currentAdapter) {
+        throw new Error("[baileys] driver not connected — call connect() first");
+    }
+    return currentAdapter.contract;
+}
+export const baileysContract = {
+    name: "baileys",
+    async connect() {
+        shuttingDown = false;
+        halted = false;
+        reconnectAttempts = 0;
+        await startBot();
+    },
+    async disconnect() {
+        shuttingDown = true;
+        reconnectAttempts = 0;
+        setStatus(false);
+        if (reconnectTimer) {
+            clearTimeout(reconnectTimer);
+            reconnectTimer = null;
+        }
+        stopCacheAutosave();
+        stopContactRefreshSweep();
+        stopUpdateCheckSchedule();
+        if (currentStore)
+            await saveChatCache(currentStore);
+        teardownSock(currentSock);
+        currentSock = null;
+        currentStore = null;
+        currentAdapter = null;
+    },
+    isReady() {
+        return sockIsOpen();
+    },
+    // ── event passthrough ───────────────────────────────────────────────────
+    on: (...args) => requireReady().on(...args),
+    resolveLid: (...args) => {
+        const c = requireReady();
+        return c.resolveLid ? c.resolveLid(...args) : Promise.resolve(null);
+    },
+    // ── send ────────────────────────────────────────────────────────────────
+    sendText: (...args) => requireReady().sendText(...args),
+    sendImage: (...args) => requireReady().sendImage(...args),
+    sendVideo: (...args) => requireReady().sendVideo(...args),
+    sendAudio: (...args) => requireReady().sendAudio(...args),
+    sendSticker: (...args) => requireReady().sendSticker(...args),
+    sendDocument: (...args) => requireReady().sendDocument(...args),
+    sendPoll: (...args) => requireReady().sendPoll(...args),
+    // ── react / edit / delete ───────────────────────────────────────────────
+    react: (...args) => requireReady().react(...args),
+    deleteMessage: (...args) => requireReady().deleteMessage(...args),
+    editMessage: (...args) => requireReady().editMessage(...args),
+    // ── presence + read ─────────────────────────────────────────────────────
+    sendPresenceUpdate: (...args) => requireReady().sendPresenceUpdate(...args),
+    readMessages: (...args) => requireReady().readMessages(...args),
+    // ── contacts ────────────────────────────────────────────────────────────
+    onWhatsApp: (...args) => requireReady().onWhatsApp(...args),
+    getBusinessProfile: (...args) => requireReady().getBusinessProfile(...args),
+    profilePictureUrl: (...args) => requireReady().profilePictureUrl(...args),
+    fetchStatus: (...args) => requireReady().fetchStatus(...args),
+    updateBlockStatus: (...args) => requireReady().updateBlockStatus(...args),
+    addOrEditContact: (...args) => requireReady().addOrEditContact(...args),
+    removeContact: (...args) => requireReady().removeContact(...args),
+    // ── groups ──────────────────────────────────────────────────────────────
+    groupMetadata: (...args) => requireReady().groupMetadata(...args),
+    groupParticipantsUpdate: (...args) => requireReady().groupParticipantsUpdate(...args),
+    groupUpdateSubject: (...args) => requireReady().groupUpdateSubject(...args),
+    groupUpdateDescription: (...args) => requireReady().groupUpdateDescription(...args),
+    groupInviteCode: (...args) => requireReady().groupInviteCode(...args),
+    groupRevokeInvite: (...args) => requireReady().groupRevokeInvite(...args),
+    // ── profile ────────────────────────────────────────────────────────────
+    updateProfilePicture: (...args) => requireReady().updateProfilePicture(...args),
+    updateProfileName: (...args) => requireReady().updateProfileName(...args),
+    updateProfileStatus: (...args) => requireReady().updateProfileStatus(...args),
+    // ── me ──────────────────────────────────────────────────────────────────
+    me: () => requireReady().me(),
+    // ── media (download) ────────────────────────────────────────────────────
+    downloadMedia: (...args) => requireReady().downloadMedia(...args),
+    // ── verification primitive ─────────────────────────────────────────────
+    // Delegates to the adapter, which reads from the in-memory Baileys
+    // store (store.messages). The adapter guarantees getHistory is defined
+    // (the Baileys adapter guarantees getHistory is defined), so the defensive fallback is gone.
+    getHistory: (jid, opts) => requireReady().getHistory(jid, opts),
+    /**
+     * 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() {
+        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) => {
+                    const timer = setTimeout(() => resolve(false), CONNECT_TIMEOUT_MS);
+                    created.sock.ev.on("connection.update", (u) => {
+                        if (u.connection === "open") {
+                            clearTimeout(timer);
+                            resolve(true);
+                        }
+                    });
+                });
+                if (!opened) {
+                    logger.warn(`[getid] round ${round} attempt ${attempt} timed out waiting for "open"`);
+                    teardownSock(created.sock);
+                    continue;
+                }
+                sock = created.sock;
+                store = created.store;
+            }
+        }
+        if (!sock || !store) {
+            logger.error(`[getid] failed to open a session after ${MAX_ROUNDS * MAX_ATTEMPTS} attempts`);
+            process.exit(1);
+        }
+        // Wait for the initial chat sync to land in the store.
+        await new Promise((resolve) => {
+            const timer = setTimeout(resolve, 5000);
+            sock.ev.on("messaging-history.set", () => {
+                clearTimeout(timer);
+                resolve();
+            });
+        });
+        const chats = store.chats.all();
+        if (chats.length === 0) {
+            logger.warn(`[getid] no chats synced yet — try again in a few seconds`);
+            teardownSock(sock);
+            process.exit(1);
+        }
+        const sorted = chats
+            .map((c) => ({ id: c.id, name: c.name ?? "" }))
+            .sort((a, b) => a.name.localeCompare(b.name));
+        const picked = await clack.select({
+            message: t("getid.pickChat"),
+            options: sorted.map((c) => ({ label: c.name || c.id, value: c.id })),
+        });
+        if (clack.isCancel(picked) || typeof picked !== "string") {
+            teardownSock(sock);
+            process.exit(0);
+        }
+        const resolved = await resolveLidForJid(sock, picked);
+        const finalJid = resolved ?? picked;
+        try {
+            await copyToClipboard(finalJid);
+            logger.success(`[getid] ${t("getid.copied", { id: finalJid })}`);
+        }
+        catch {
+            logger.info(`[getid] ${finalJid}`);
+        }
+        teardownSock(sock);
+    },
+};
+/**
+ * Try to resolve a `@lid` JID to its real `@s.whatsapp.net` form via the
+ * Baileys signal repository. Returns null if the adapter doesn't expose
+ * one (very old sessions) or the lookup fails.
+ */
+async function resolveLidForJid(sock, jid) {
+    try {
+        const repo = sock.signalRepository;
+        const fn = repo?.lidMapping?.getPNForLID;
+        if (typeof fn === "function") {
+            const pn = await fn(jid);
+            return pn ?? null;
+        }
+    }
+    catch { }
+    return null;
+}
+/**
+ * Backwards-compat: callers that still import `baileysDriver` get the
+ * new contract object. The old `WaDriver` surface is gone — kernel
+ * code that needs the driver only ever sees the `WaContract` now.
+ *
+ * @deprecated Use `baileysContract` directly.
+ */
+export const baileysDriver = baileysContract;
+// ── Baileys-only helpers used by the plugin-context builder ─────────────────
+// The plugin-context layer (drivers/baileys/api/index.ts) still works
+// against Baileys' raw WAMessage shape for things that don't yet have a
+// driver-neutral equivalent (poll decryption, gif detection, history
+// reconstruction from store.messages). These helpers stay here so the
+// api file can convert a raw WAMessage into a driver-neutral BotMessage
+// without re-importing the adapter's private internals.
+import { normalizeMessageContent } from "@whiskeysockets/baileys";
+import { createHash } from "node:crypto";
+/**
+ * Map a Baileys WAMessage into the driver-neutral BotMessage envelope.
+ * Mirrors the adapter's internal conversion (the two diverged once —
+ * keep them in sync if you change one).
+ */
+export function toBotMessage(msg) {
+    const m = normalizeMessageContent(msg.message);
+    let type = "other";
+    let text = "";
+    let mimetype;
+    if (m?.conversation) {
+        type = "text";
+        text = m.conversation;
+    }
+    else if (m?.extendedTextMessage?.text) {
+        type = "text";
+        text = m.extendedTextMessage.text;
+    }
+    else if (m?.imageMessage) {
+        type = "image";
+        text = m.imageMessage.caption ?? "";
+        mimetype = m.imageMessage.mimetype ?? undefined;
+    }
+    else if (m?.videoMessage) {
+        type = "video";
+        text = m.videoMessage.caption ?? "";
+        mimetype = m.videoMessage.mimetype ?? undefined;
+    }
+    else if (m?.audioMessage) {
+        type = "audio";
+        text = "";
+        mimetype = m.audioMessage.mimetype ?? undefined;
+    }
+    else if (m?.documentMessage) {
+        type = "document";
+        text = m.documentMessage.caption ?? "";
+        mimetype = m.documentMessage.mimetype ?? undefined;
+    }
+    else if (m?.stickerMessage) {
+        type = "sticker";
+        text = "";
+        mimetype = m.stickerMessage.mimetype ?? undefined;
+    }
+    const key = msg.key;
+    const contextInfo = m?.extendedTextMessage?.contextInfo ??
+        m?.imageMessage?.contextInfo ??
+        m?.videoMessage?.contextInfo ??
+        m?.audioMessage?.contextInfo ??
+        m?.documentMessage?.contextInfo ??
+        undefined;
+    return {
+        id: msg.key?.id ?? "",
+        chatId: normalizeJid(msg.key?.remoteJid ?? ""),
+        fromMe: !!msg.key?.fromMe,
+        type,
+        contentHash: hashText(text),
+        timestamp: Number(msg.messageTimestamp ?? 0) * 1000,
+        body: text || undefined,
+        mimetype,
+        pushName: msg.pushName ?? undefined,
+        mentionedJid: contextInfo?.mentionedJid ?? undefined,
+        quotedKey: contextInfo?.stanzaId ? {
+            id: contextInfo.stanzaId,
+            remoteJid: msg.key?.remoteJid ?? undefined,
+            fromMe: false,
+            participant: contextInfo.participant ?? undefined,
+        } : undefined,
+        fromLid: key.participantAlt,
+        fromPn: key.participant,
+        participantAlt: key.participantAlt,
+        remoteJidAlt: key.remoteJidAlt,
+        _raw: {
+            pollEncKeyRaw: m?.messageContextInfo?.messageSecret ?? undefined,
+        },
+    };
+}
+function hashText(text) {
+    return createHash("sha1").update(text.trim(), "utf8").digest("hex");
+}

package/dist/drivers/{whatsapp → baileys}/loginPrompt.js

@@ -11,6 +11,7 @@
 import * as clack from "@clack/prompts";
 import { CONFIG, persistConfigValue } from "#config";
 import { t } from "#i18n";
+import { promptWhatsmeowInstall } from "#drivers/whatsmeow/installer.js";
 function cancelAndExit() {
     clack.cancel(t("onboarding.cancelled"));
     process.exit(1);
@@ -72,6 +73,7 @@ export async function resolveLoginMethod() {
     clack.intro(t("onboarding.intro"));
     if (needsMethod) {
         method = await promptLoginMethod();
+        await promptWhatsmeowInstall();
     }
     if (method === "phone" && !phone) {
         phone = await promptPhoneNumber();