@manybot/manybot 5.5.4 → 5.6.1

package/dist/kernel/sendGuard.js

@@ -3,41 +3,82 @@
  *
  * Anti-detection throttle layer for all outbound sends.
  *
- * Three protections applied before every message:
- *   1. Global token bucket  — hard cap on messages/second across all chats
- *   2. Per-chat cooldown    — minimum gap between sends to the same chat
- *   3. Human jitter         — random delay to break robotic timing patterns
+ * Protections applied before every message:
+ *   1. Global token bucket   — hard cap on messages/second across all chats
+ *   2. Per-chat cooldown     — minimum gap between sends to the same chat
+ *   3. Human jitter          — random delay to break robotic timing patterns
+ *   4. Chat-concurrency gate — caps how many different chats the bot can be
+ *                              actively answering at the same time
+ *   5. Edit throttle         — jittered minimum gap + cap on edits per
+ *                              message, so things like loading animations
+ *                              don't edit on a fixed, bot-like cadence
+ *
+ * All of the above scale with SECURITY_LEVEL ("low" | "medium" | "high").
+ * Higher levels are slower and more conservative — lower risk of WhatsApp's
+ * automation detection, at the cost of response speed.
  *
  * Text sends simulate the typing/recording presence indicator before
  * the message arrives, so the chat shows "typing..." realistically.
  */
+import { CONFIG } from "#config";
 import { logger } from "#logger";
-// ── Tunables ──────────────────────────────────────────────────────────────────
-const GLOBAL_MSG_PER_SEC = 5;
-const CHAT_COOLDOWN_MS = 150;
-const JITTER_MS = { min: 50, max: 200 };
+const PROFILES = {
+    low: {
+        globalMsgPerSec: 8,
+        chatCooldownMs: 100,
+        jitterMs: { min: 30, max: 120 },
+        concurrency: Infinity,
+        editIntervalMs: { min: 800, max: 2000 },
+        maxEditsPerMessage: 20,
+        typingMaxMs: 2000,
+    },
+    medium: {
+        globalMsgPerSec: 5,
+        chatCooldownMs: 150,
+        jitterMs: { min: 50, max: 200 },
+        concurrency: 2,
+        editIntervalMs: { min: 1200, max: 3000 },
+        maxEditsPerMessage: 12,
+        typingMaxMs: 4000,
+    },
+    high: {
+        globalMsgPerSec: 2,
+        chatCooldownMs: 400,
+        jitterMs: { min: 150, max: 500 },
+        concurrency: 1,
+        editIntervalMs: { min: 2000, max: 5000 },
+        maxEditsPerMessage: 6,
+        typingMaxMs: 8000,
+    },
+};
+function currentProfile() {
+    const level = CONFIG.SECURITY_LEVEL;
+    return PROFILES[level] ?? PROFILES.medium;
+}
 const TYPING_CPS = 90;
-const TYPING_MAX_MS = 2000;
 const MEDIA_INDICATOR_MS = { min: 400, max: 1000 };
 // ── Global token bucket ───────────────────────────────────────────────────────
-const MS_PER_TOKEN = 1000 / GLOBAL_MSG_PER_SEC;
-let tokens = GLOBAL_MSG_PER_SEC;
+// Refill rate follows the active profile, re-read on every call so a
+// SECURITY_LEVEL change via reloadConfig() takes effect immediately.
+let tokens = PROFILES.medium.globalMsgPerSec;
 let lastRefill = Date.now();
 function consumeGlobalToken() {
+    const rate = currentProfile().globalMsgPerSec;
+    const msPerToken = 1000 / rate;
     const now = Date.now();
     const elapsed = now - lastRefill;
-    tokens = Math.min(GLOBAL_MSG_PER_SEC, tokens + elapsed / MS_PER_TOKEN);
+    tokens = Math.min(rate, tokens + elapsed / msPerToken);
     lastRefill = now;
     if (tokens >= 1) {
         tokens -= 1;
         return 0;
     }
-    return Math.ceil((1 - tokens) * MS_PER_TOKEN);
+    return Math.ceil((1 - tokens) * msPerToken);
 }
 // ── Per-chat cooldown ─────────────────────────────────────────────────────────
 const lastSentAt = new Map();
 function chatCooldownMs(jid) {
-    const wait = (lastSentAt.get(jid) ?? 0) + CHAT_COOLDOWN_MS - Date.now();
+    const wait = (lastSentAt.get(jid) ?? 0) + currentProfile().chatCooldownMs - Date.now();
     return wait > 0 ? wait : 0;
 }
 function recordSend(jid) {
@@ -45,26 +86,100 @@ function recordSend(jid) {
 }
 // ── Helpers ───────────────────────────────────────────────────────────────────
 const sleep = (ms) => new Promise(r => setTimeout(r, ms));
-function randomJitter() {
-    return JITTER_MS.min + Math.random() * (JITTER_MS.max - JITTER_MS.min);
+function randomBetween(range) {
+    return range.min + Math.random() * (range.max - range.min);
 }
 /**
  * How long the typing indicator should appear before sending text.
+ * Capped by the active profile's `typingMaxMs` — higher SECURITY_LEVELs
+ * tolerate a longer "typing..." for long messages instead of flatlining.
  * @param {string} text
  * @returns {number} ms
  */
 export function typingDuration(text) {
     if (typeof text !== "string" || text.length === 0)
         return 0;
-    return Math.min((text.length / TYPING_CPS) * 1000, TYPING_MAX_MS);
+    return Math.min((text.length / TYPING_CPS) * 1000, currentProfile().typingMaxMs);
 }
 /**
- * A human-feeling duration for media "processing" indicator.
+ * A human-feeling duration for media "processing" indicator. If a caption
+ * is given, adds its own typing time on top (same per-profile cap as
+ * typingDuration) so a media message with a long caption doesn't look
+ * instant.
+ * @param {string} [caption]
  * @returns {number} ms
  */
-export function mediaDuration() {
-    return MEDIA_INDICATOR_MS.min
-        + Math.random() * (MEDIA_INDICATOR_MS.max - MEDIA_INDICATOR_MS.min);
+export function mediaDuration(caption) {
+    const base = randomBetween(MEDIA_INDICATOR_MS);
+    return caption ? base + typingDuration(caption) : base;
+}
+// ── Chat-concurrency gate ─────────────────────────────────────────────────────
+// Caps how many DIFFERENT chats can be actively answered at once, globally
+// (not per-chat — messageHandler.ts already serializes a single chat's own
+// messages). high=1 effectively locks the bot to one chat at a time,
+// medium=2, low=unlimited. FIFO queue for anything past the cap.
+let activeSlots = 0;
+const slotWaiters = [];
+function releaseChatSlot() {
+    activeSlots--;
+    const next = slotWaiters.shift();
+    if (next)
+        next();
+}
+/**
+ * Acquire a global chat-concurrency slot before processing a message for
+ * `jid`. Resolves once a slot is free. Always call the returned release
+ * function (e.g. in a `finally`) or the pool leaks.
+ * @param {string} jid — kept for logging/debugging, not used for scoping
+ * @returns {Promise<() => void>} release function
+ */
+export async function acquireChatSlot(jid) {
+    const max = currentProfile().concurrency;
+    if (activeSlots < max) {
+        activeSlots++;
+        return releaseChatSlot;
+    }
+    logger.debug(`[sendGuard] chat-concurrency gate full — queuing ${jid}`);
+    return new Promise(resolve => {
+        slotWaiters.push(() => {
+            activeSlots++;
+            resolve(releaseChatSlot);
+        });
+    });
+}
+const editState = new Map();
+const EDIT_STATE_STALE_MS = 10 * 60 * 1000;
+function cleanupEditState(now) {
+    for (const [id, s] of editState) {
+        if (now - s.lastEditAt > EDIT_STATE_STALE_MS)
+            editState.delete(id);
+    }
+}
+/**
+ * Waits for a safe edit slot for `messageId`, applying a jittered minimum
+ * gap since its last edit. Returns false once the message has hit its
+ * per-level edit cap — callers should skip the edit silently in that case.
+ * @param {string} messageId
+ * @returns {Promise<boolean>} true if the edit may proceed
+ */
+export async function waitForEditSlot(messageId) {
+    const now = Date.now();
+    cleanupEditState(now);
+    const profile = currentProfile();
+    const s = editState.get(messageId) ?? { lastEditAt: 0, count: 0 };
+    if (s.count >= profile.maxEditsPerMessage) {
+        editState.set(messageId, s);
+        logger.debug(`[sendGuard] edit cap reached for ${messageId}`);
+        return false;
+    }
+    const minGap = randomBetween(profile.editIntervalMs);
+    const wait = s.lastEditAt + minGap - Date.now();
+    if (wait > 0)
+        await sleep(wait);
+    s.lastEditAt = Date.now();
+    s.count += 1;
+    editState.set(messageId, s);
+    return true;
 }
 // ── Public API ────────────────────────────────────────────────────────────────
 /**
@@ -90,30 +205,25 @@ export async function waitForSendSlot(jid, { cooldown = true, jitter = true } =
         }
     }
     if (jitter)
-        await sleep(randomJitter());
+        await sleep(randomBetween(currentProfile().jitterMs));
     recordSend(jid);
 }
 /**
  * Show a presence indicator for `ms` milliseconds, then clear it.
- * No-op on drivers without the "presence" capability. Best-effort —
- * errors are swallowed.
+ * Best-effort — errors are swallowed.
  *
- * @param {PresenceCapable|null}   adapter
+ * @param {WaContract|null}        contract
  * @param {string|null}            chatId
  * @param {number}                 ms
  * @param {"typing"|"recording"}   [state="typing"]
  */
-export async function simulateState(adapter, chatId, ms, state = "typing") {
-    if (!adapter || !chatId || ms <= 0)
-        return;
-    if (!adapter.capabilities.has("presence") || !adapter.setPresence)
+export async function simulateState(contract, chatId, ms, state = "typing") {
+    if (!contract || !chatId || ms <= 0)
         return;
     try {
-        // Adapter contract only knows "composing" — recording is a WhatsApp nuance
-        // collapsed here until a driver needs to distinguish it.
-        await adapter.setPresence(chatId, "composing");
+        await contract.sendPresenceUpdate(state === "recording" ? "recording" : "composing", chatId);
         await sleep(ms);
-        await adapter.setPresence(chatId, "paused");
+        await contract.sendPresenceUpdate("paused", chatId);
     }
     catch (e) {
         logger.debug(`[sendGuard] presence simulation failed (non-fatal): ${e.message}`);

package/dist/kernel/statusServer.js

@@ -0,0 +1,39 @@
+/**
+ * kernel/statusServer.ts
+ *
+ * Minimal HTTP endpoint exposing the bot's connection state as JSON,
+ * for an external status page (or any other consumer) to poll.
+ */
+import http from "http";
+import { logger } from "#logger";
+let status = {
+    online: false,
+    since: new Date().toISOString(),
+};
+export function setStatus(online, lastError) {
+    if (status.online === online)
+        return;
+    status = {
+        online,
+        since: new Date().toISOString(),
+        ...(lastError ? { lastError } : {}),
+    };
+}
+export function getStatus() {
+    return status;
+}
+export function startStatusServer(port) {
+    const server = http.createServer((req, res) => {
+        res.writeHead(200, {
+            "Content-Type": "application/json",
+            "Access-Control-Allow-Origin": "*",
+        });
+        res.end(JSON.stringify(getStatus()));
+    });
+    server.on("error", (err) => {
+        logger.error(`[status] Failed to start status server: ${err.message}`);
+    });
+    server.listen(port, () => {
+        logger.info(`[status] JSON endpoint em http://localhost:${port}`);
+    });
+}

package/dist/kernel/updateCheck.js

@@ -0,0 +1,88 @@
+/**
+ * updateCheck.ts
+ *
+ * Compares the locally installed manybot version against the latest
+ * published on npm, and fires an "info" alert (via alerts.ts) when a
+ * newer version is available. Runs once on startup and then on a
+ * schedule — both configurable (UPDATE_CHECK_ENABLED,
+ * UPDATE_CHECK_INTERVAL_HOURS).
+ *
+ * Never throws — a failed check (offline, npm down) is logged at debug
+ * level and silently skipped; it'll just try again next cycle.
+ */
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import path from "path";
+import { UPDATE_CHECK_ENABLED, UPDATE_CHECK_INTERVAL_HOURS } from "#config";
+import { sendAlert } from "#kernel/alerts.js";
+import { logger } from "#logger";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const pkg = JSON.parse(readFileSync(path.join(__dirname, "../../package.json"), "utf8"));
+const REGISTRY_URL = `https://registry.npmjs.org/${encodeURIComponent(pkg.name)}/latest`;
+/** Naive semver compare — good enough for x.y.z, no pre-release handling. */
+function isNewer(latest, current) {
+    const a = latest.split(".").map(Number);
+    const b = current.split(".").map(Number);
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        const x = a[i] ?? 0;
+        const y = b[i] ?? 0;
+        if (x > y)
+            return true;
+        if (x < y)
+            return false;
+    }
+    return false;
+}
+let alreadyNotifiedFor = null;
+/**
+ * Runs a single check. Safe to call anytime (startup, interval, manual
+ * trigger) — never throws.
+ */
+export async function checkForUpdate() {
+    if (!UPDATE_CHECK_ENABLED)
+        return;
+    try {
+        const res = await fetch(REGISTRY_URL);
+        if (!res.ok) {
+            logger.debug(`[updateCheck] npm registry responded ${res.status}`);
+            return;
+        }
+        const data = await res.json();
+        const latest = data.version;
+        if (!latest || !isNewer(latest, pkg.version))
+            return;
+        // Don't re-alert every cycle for the same version once already notified.
+        if (alreadyNotifiedFor === latest)
+            return;
+        alreadyNotifiedFor = latest;
+        await sendAlert({
+            level: "info",
+            title: "Nova versão do manybot disponível",
+            message: `Instalada: ${pkg.version} → disponível: ${latest}. Rode "npm install -g ${pkg.name}@${latest}" (ou equivalente) para atualizar.`,
+        });
+    }
+    catch (e) {
+        logger.debug(`[updateCheck] check failed (non-fatal): ${e.message}`);
+    }
+}
+let intervalTimer = null;
+/**
+ * Runs one check immediately, then schedules recurring checks every
+ * UPDATE_CHECK_INTERVAL_HOURS. Safe to call multiple times — a second
+ * call is a no-op while a schedule is already running.
+ */
+export function startUpdateCheckSchedule() {
+    if (!UPDATE_CHECK_ENABLED || intervalTimer)
+        return;
+    checkForUpdate().catch(() => { });
+    intervalTimer = setInterval(() => {
+        checkForUpdate().catch(() => { });
+    }, UPDATE_CHECK_INTERVAL_HOURS * 60 * 60 * 1000);
+}
+export function stopUpdateCheckSchedule() {
+    if (!intervalTimer)
+        return;
+    clearInterval(intervalTimer);
+    intervalTimer = null;
+}

package/dist/kernel/waContract.js

@@ -0,0 +1,16 @@
+/**
+ * kernel/waContract.ts
+ *
+ * Driver-neutral contract that the core (kernel + pluginApi + sendGuard +
+ * contactAutoSave + pluginLoader + messageHandler) consumes. Every WhatsApp
+ * driver — Baileys today, whatsmeow in a later phase — implements this
+ * interface. The core never imports a driver package directly.
+ *
+ * Event payloads are all driver-neutral: adapters translate incoming
+ * driver-specific event shapes (e.g. Baileys WAMessage) into the records
+ * declared here before letting the rest of the kernel see them.
+ *
+ * This file MUST NOT import from `@whiskeysockets/baileys` or any
+ * other driver package.
+ */
+export {};

package/dist/locales/en.json

@@ -31,9 +31,12 @@
     "schedulerRegistered": "Schedule registered — plugin \"{{name}}\" → \"{{expression}}\"",
     "downloadJobFailed": "Download job failed — {{message}}",
     "reconnecting": "Reconnecting in {{secs}}s...",
+    "reconnectHalted": "Gave up reconnecting after {{attempts}} attempts — call connect() manually to retry. Repeated reconnect loops can make a WhatsApp restriction last longer.",
     "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)."
+    "cacheLoadedStale": "{{count}} chat(s) loaded from cache (stale).",
+    "sendFailedNoFallback": "manybot: no fallback driver available (jid={{jid}}, primary={{driver}})",
+    "sendFailedBothDrivers": "manybot: send failed on both drivers (jid={{jid}}, tried={{primary}} then {{secondary}})"
   },
   "errors": {
     "stack": "Stack",
@@ -66,5 +69,17 @@
     "retrying": "Retrying ({{attempt}}/{{max}})...",
     "sessionWiped": "Session discarded, pairing again ({{round}}/{{max}})...",
     "connectGaveUp": "Couldn't connect after several attempts. Check your network and try again."
+  },
+  "whatsmeow": {
+    "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.",
+    "downloading": "Downloading {{url}}...",
+    "downloadFailed": "Download failed: {{reason}}",
+    "installTitle": "whatsmeow driver",
+    "installed": "whatsmeow driver installed at {{path}}",
+    "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

@@ -31,9 +31,12 @@
     "schedulerRegistered": "Programación registrada — plugin \"{{name}}\" → \"{{expression}}\"",
     "downloadJobFailed": "Error en el trabajo de descarga — {{message}}",
     "reconnecting": "Reconectando en {{secs}}s...",
+    "reconnectHalted": "Se dejó de reconectar tras {{attempts}} intentos — llama a connect() manualmente para reintentar. Los bucles de reconexión repetidos pueden prolongar una restricción de WhatsApp.",
     "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)."
+    "cacheLoadedStale": "{{count}} chat(s) cargado(s) desde la caché (desactualizada).",
+    "sendFailedNoFallback": "manybot: no hay driver de respaldo disponible (jid={{jid}}, primario={{driver}})",
+    "sendFailedBothDrivers": "manybot: envío falló en ambos drivers (jid={{jid}}, se probó {{primary}} y luego {{secondary}})"
   },
   "errors": {
     "stack": "Stack",
@@ -66,5 +69,17 @@
     "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."
+  },
+  "whatsmeow": {
+    "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.",
+    "downloading": "Descargando {{url}}...",
+    "downloadFailed": "Descarga fallida: {{reason}}",
+    "installTitle": "Driver whatsmeow",
+    "installed": "Driver whatsmeow instalado en {{path}}",
+    "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

@@ -31,9 +31,12 @@
     "schedulerRegistered": "Agendamento registrado — plugin \"{{name}}\" → \"{{expression}}\"",
     "downloadJobFailed": "Falha no job de download — {{message}}",
     "reconnecting": "Reconectando em {{secs}}s...",
+    "reconnectHalted": "Desisti de reconectar após {{attempts}} tentativas — chame connect() manualmente para tentar de novo. Loops de reconexão repetidos podem prolongar uma restrição do WhatsApp.",
     "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)."
+    "cacheLoadedStale": "{{count}} conversa(s) carregada(s) do cache (desatualizado).",
+    "sendFailedNoFallback": "manybot: nenhum driver de fallback disponível (jid={{jid}}, primário={{driver}})",
+    "sendFailedBothDrivers": "manybot: envio falhou nos dois drivers (jid={{jid}}, tentou {{primary}} depois {{secondary}})"
   },
   "errors": {
     "stack": "Stack",
@@ -66,5 +69,17 @@
     "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."
+  },
+  "whatsmeow": {
+    "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.",
+    "downloading": "Baixando {{url}}...",
+    "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.",
+    "experimentalNotice": "whatsmeow é EXPERIMENTAL: apenas sendText e getHistory estão implementados. sendImage, sendPoll, groupMetadata e outros métodos lançam erro."
   }
 }

package/dist/main.js

@@ -9,19 +9,67 @@ import Module from "module";
 import path from "path";
 process.env.NODE_PATH = path.resolve(process.cwd(), "node_modules");
 Module._initPaths();
-import { initializeSelectedDriver } from "#drivers/index.js";
+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";
+import { startStatusServer } from "#kernel/statusServer.js";
+import { getDriverManager } from "#kernel/driverManager.js";
+import { CONFIG, STATUS_ENABLED, STATUS_PORT } from "#config";
 import { logger } from "#logger";
 import { t } from "#i18n";
 let shuttingDown = false;
-const activeDriver = initializeSelectedDriver();
+// DriverManager registration: only register drivers that are enabled in
+// the config. whatsmeow.enabled = false means no gRPC
+// subprocess, no Go binary lookup, no extra work at boot — the manager
+// simply doesn't know about it and sendFallbackGuard sees a missing
+// secondary and fires send_failed_no_fallback if needed.
+const driverManager = getDriverManager();
+driverManager.register(baileysContract, { isPrimary: CONFIG.drivers.primary === "baileys" });
+// Whatsmeow supervisor: spawns the Go subprocess when enabled=true,
+// owns the restart/backoff/circuit-breaker logic, and gates the
+// driver's connect()/isReady() until HealthCheck{ready:true}. When
+// enabled=false or the binary can't be located, `supervisor` is null
+// and the whatsmeow driver is simply not registered — ManyBot keeps
+// 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);
 async function shutdown(reason, isError = false) {
     if (shuttingDown)
         return;
     shuttingDown = true;
     if (isError) {
         logger.error(`${t("bot.error.uncaught")}: ${reason}`);
+        try {
+            await sendAlert({
+                level: "critical",
+                title: "manybot crashed",
+                message: reason,
+            });
+        }
+        catch {
+            // sendAlert already swallows sink failures internally; this is only
+            // a final safety net so a crash alert never blocks shutdown itself.
+        }
     }
     else {
         logger.warn(t("bot.signal.sigterm", { signal: reason }));
@@ -34,11 +82,21 @@ async function shutdown(reason, isError = false) {
     }
     stopScheduler();
     try {
-        await activeDriver.disconnect();
+        await driverManager.shutdown();
     }
     catch (err) {
         logger.error(`Error disconnecting driver: ${err.message}`);
     }
+    // Belt-and-suspenders: driverManager.shutdown() should already have
+    // disconnected the wrapped contract, which in turn calls
+    // supervisor.shutdown(). This catches the case where the supervisor
+    // was started but the driver wasn't registered (binary missing).
+    if (supervisor) {
+        try {
+            await supervisor.shutdown();
+        }
+        catch { }
+    }
     process.exit(isError ? 1 : 0);
 }
 // Global error listeners
@@ -58,23 +116,60 @@ process.on("SIGINT", () => shutdown("SIGINT"));
 // the JID to the console, to paste into CHATS in manybot.toml.
 // Does not enter the normal bot flow (plugins are not loaded).
 if (process.argv.includes("--getid")) {
-    if (!activeDriver.getId) {
+    // getId? is a Baileys-only diagnostic method. Look it
+    // up on the registered Baileys driver regardless of which one is
+    // active — --getid always uses Baileys, even in a whatsmeow-primary
+    // configuration, because it needs the diagnostic session, not the
+    // bot's normal one.
+    const baileys = driverManager.get("baileys");
+    const getIdFn = baileys?.getId;
+    if (!getIdFn) {
         logger.error(`Current driver does not support --getid.`);
         process.exit(1);
     }
-    activeDriver.getId()
+    getIdFn()
         .then(() => process.exit(0))
         .catch((err) => {
         logger.error(`--getid mode failed: ${err.message}`);
         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"));
+    if (STATUS_ENABLED) {
+        startStatusServer(STATUS_PORT);
+    }
     activeDriver.connect()
         .then(() => {
         logger.success(t("bot.ready"));
+        // The secondary driver is connected and paired in the
+        // background so sendFallbackGuard can reach for it without first
+        // having to wait through a connect() round-trip when the primary
+        // fails. The secondary does NOT register `messages.upsert` handlers
+        // (no kernel code subscribes on it — only the primary path does),
+        // so connecting it does not duplicate inbound processing. A failure
+        // 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);