@manybot/manybot 5.5.4 → 5.6.1

package/dist/drivers/whatsmeow/supervisor.js

@@ -0,0 +1,328 @@
+/**
+ * supervisor.ts
+ *
+ * Lifecycle manager for the Go whatsmeow subprocess. Two responsibilities:
+ *
+ *   1. Spawn the binary, watch for crashes, restart with exponential
+ *      backoff (same circuit-breaker pattern the Baileys driver uses in
+ *      drivers/baileys/index.ts:98-106). After MAX_RECONNECT_ATTEMPTS
+ *      consecutive failures, halt permanently and fire
+ *      `whatsmeow_subprocess_halted` — ManyBot keeps running on Baileys
+ *      alone.
+ *   2. Block `whenReady()` until the gRPC server has answered
+ *      `HealthCheck{ready:true}` at least once. Without this, callers
+ *      race ahead of the subprocess and try to `connect()` against an
+ *      empty SQLite / pre-auth state.
+ *
+ * Resolution of the binary path: `CONFIG.drivers.whatsmeow.binaryPath`
+ * wins; if empty, falls back to the env var `WM_BINARY_PATH`, then
+ * `<cwd>/whatsmeow-service/bin/whatsmeow-service` (dev), then the
+ * npm-global install layout. Falls open into a logged fatal if nothing
+ * matches — `enabled=true` without a binary is a setup bug, not a
+ * silent degradation.
+ *
+ * `config.drivers.whatsmeow.enabled = false` (TOML:
+ * `driver_whatsmeow_enabled = false`) ⇒ no supervisor at all
+ * (`null` return from `startWhatsmeowSupervisor`); the rest of the
+ * codebase is unaware anything is missing — it just never sees a
+ * ready whatsmeow.
+ *
+ * See the lifecycle contract this implements.
+ */
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+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;
+const MAX_RECONNECT_ATTEMPTS = 6;
+const HEALTHCHECK_INTERVAL_MS = 500;
+const HEALTHCHECK_TIMEOUT_MS = 5_000;
+const SHUTDOWN_GRACE_MS = 5_000;
+// ── Resolution helpers ─────────────────────────────────────────────────────
+/**
+ * Walks the conventional locations looking for the binary. Returns the
+ * 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. 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() {
+    const candidates = [];
+    const fromConfig = CONFIG.drivers.whatsmeow.binaryPath;
+    if (fromConfig)
+        candidates.push(path.resolve(fromConfig));
+    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`
+    // `<prefix>` is the parent of the running node binary on most setups.
+    const prefix = path.dirname(path.dirname(process.execPath));
+    candidates.push(path.join(prefix, "share", "manybot", "bin", "whatsmeow-service"));
+    // Belt-and-suspenders: macOS/Linux homebrew-style shared dir.
+    candidates.push(path.join(prefix, "lib", "node_modules", "manybot", "whatsmeow-service", "bin", "whatsmeow-service"));
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    return null;
+}
+/**
+ * Single HealthCheck RPC against `addr`. Implemented with the low-level
+ * @grpc/grpc-js client API so the supervisor doesn't need the rest of
+ * the whatsmeow driver to be importable (the supervisor can outlive a
+ * broken contract, e.g. when the proto is being regenerated).
+ *
+ * Uses an in-memory `.proto` with the bare minimum types needed for
+ * HealthCheck so we don't depend on the driver module's loader cache.
+ */
+async function probeHealth(addr) {
+    // Lazy imports keep the fast path (enabled=false) cheap.
+    const grpc = await import("@grpc/grpc-js");
+    const protoLoader = await import("@grpc/proto-loader");
+    // Resolve the .proto relative to this compiled module — works under
+    // `node dist/main.js` (proto is copied into dist/drivers/whatsmeow/
+    // by the build script), under a global npm install (proto ships in
+    // the package's `dist/`), and in dev (`tsx src/main.ts`, where the
+    // proto sits next to this source file). ESM has no `__dirname`, so
+    // use `import.meta.url`.
+    const protoPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "whatsmeow.proto");
+    if (!existsSync(protoPath)) {
+        return { ready: false, error: `proto not found at ${protoPath}` };
+    }
+    const def = protoLoader.loadSync(protoPath, {
+        keepCase: true,
+        longs: String,
+        enums: String,
+        defaults: true,
+        oneofs: true,
+    });
+    const Service = grpc.loadPackageDefinition(def).whatsmeow.WhatsmeowService;
+    const client = new Service(addr, grpc.credentials.createInsecure());
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            try {
+                client.close();
+            }
+            catch { }
+            resolve({ ready: false, error: "healthcheck timeout" });
+        }, HEALTHCHECK_TIMEOUT_MS);
+        client.HealthCheck({}, (err, resp) => {
+            clearTimeout(timer);
+            try {
+                client.close();
+            }
+            catch { }
+            if (err)
+                return resolve({ ready: false, error: err.message });
+            resolve({ ready: !!resp?.ready, error: resp?.last_error || undefined });
+        });
+    });
+}
+async function waitMs(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+/**
+ * Spawn the subprocess, register lifecycle handlers, and kick the
+ * healthcheck loop. Returns the supervisor handle, or `null` if
+ * `enabled = false`. Throws only on fatal startup conditions (binary
+ * not found, spawn() failed synchronously); transient RPC failures are
+ * logged + backed off, never thrown.
+ */
+export async function startWhatsmeowSupervisor() {
+    if (!CONFIG.drivers.whatsmeow.enabled) {
+        logger.info("[supervisor] disabled by config (driver_whatsmeow_enabled = false)");
+        return null;
+    }
+    const binary = resolveBinaryPath();
+    if (!binary) {
+        logger.error("[supervisor] whatsmeow-service binary not found. Set `driver_whatsmeow_binary_path` in manybot.toml, " +
+            "set env WM_BINARY_PATH, or place the binary at " +
+            "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(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,
+        addr: grpcAddress,
+        binary,
+        sessionDir,
+        reconnectTries: 0,
+        halted: false,
+        ready: false,
+        readyDeferred: null,
+        shuttingDown: false,
+        restartTimer: null,
+    };
+    // First ready promise — created lazily on the first `whenReady()` so
+    // a never-called instance doesn't carry dangling deferreds.
+    function ensureReadyPromise() {
+        if (state.ready)
+            return Promise.resolve();
+        if (state.halted)
+            return Promise.reject(new Error("whatsmeow supervisor halted"));
+        if (!state.readyDeferred) {
+            let resolve;
+            let reject;
+            const p = new Promise((res, rej) => { resolve = res; reject = rej; });
+            state.readyDeferred = { resolve, reject };
+        }
+        return new Promise((resolve, reject) => {
+            // Re-attach so callers can `await` multiple times.
+            const d = state.readyDeferred;
+            const origResolve = d.resolve;
+            const origReject = d.reject;
+            d.resolve = () => { origResolve(); resolve(); };
+            d.reject = (e) => { origReject(e); reject(e); };
+        });
+    }
+    function markReady() {
+        if (state.ready)
+            return;
+        state.ready = true;
+        state.reconnectTries = 0; // healthy again → reset circuit breaker
+        state.readyDeferred?.resolve();
+    }
+    function markHalted(reason) {
+        state.halted = true;
+        state.ready = false;
+        state.readyDeferred?.reject(new Error(reason));
+        getDriverManager().markDegraded("whatsmeow", 600_000);
+        fireAlert("whatsmeow_subprocess_halted", { reason });
+    }
+    function scheduleRestart() {
+        if (state.shuttingDown || state.halted)
+            return;
+        if (state.reconnectTries >= MAX_RECONNECT_ATTEMPTS) {
+            logger.error(`[supervisor] exhausted ${MAX_RECONNECT_ATTEMPTS} reconnect attempts — halting`);
+            markHalted(`exhausted ${MAX_RECONNECT_ATTEMPTS} reconnect attempts`);
+            return;
+        }
+        const delay = Math.min(RECONNECT_BASE_MS * 2 ** state.reconnectTries, RECONNECT_MAX_MS);
+        state.reconnectTries += 1;
+        logger.warn(`[supervisor] scheduling restart in ${delay}ms (attempt ${state.reconnectTries}/${MAX_RECONNECT_ATTEMPTS})`);
+        state.restartTimer = setTimeout(() => {
+            state.restartTimer = null;
+            void spawnAndWatch();
+        }, delay);
+    }
+    async function spawnAndWatch() {
+        if (state.shuttingDown || state.halted)
+            return;
+        let proc;
+        try {
+            proc = spawn(state.binary, ["--grpc-addr", state.addr, "--session-dir", state.sessionDir], {
+                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) {
+            logger.error(`[supervisor] spawn failed: ${e.message}`);
+            scheduleRestart();
+            return;
+        }
+        state.proc = proc;
+        state.pid = proc.pid ?? null;
+        proc.on("error", (err) => {
+            logger.warn(`[supervisor] subprocess error: ${err.message}`);
+            // Don't restart here — the `exit` handler will fire on ENOENT etc.
+        });
+        proc.on("exit", (code, signal) => {
+            logger.warn(`[supervisor] subprocess exited code=${code} signal=${signal} ready=${state.ready}`);
+            state.proc = null;
+            state.pid = null;
+            state.ready = false;
+            if (!state.shuttingDown && !state.halted)
+                scheduleRestart();
+        });
+        logger.info(`[supervisor] subprocess started (pid=${state.pid}, binary=${state.binary})`);
+        // Don't await — healthcheck loop runs in its own cycle.
+        void runHealthLoop();
+    }
+    async function runHealthLoop() {
+        while (!state.shuttingDown && !state.halted) {
+            await waitMs(HEALTHCHECK_INTERVAL_MS);
+            if (!state.proc)
+                break; // subprocess died; `exit` handler owns restart
+            const result = await probeHealth(state.addr);
+            if (result.ready) {
+                if (!state.ready)
+                    logger.info("[supervisor] healthcheck ready");
+                markReady();
+                // Once ready, keep polling at the same cadence to detect
+                // when the subprocess silently dies. A slow poll would mean
+                // we miss the reconnect window.
+            }
+            else if (result.error) {
+                logger.debug(`[supervisor] healthcheck: not ready (${result.error})`);
+            }
+        }
+    }
+    const supervisor = {
+        whenReady: ensureReadyPromise,
+        isReady: () => state.ready && !!state.proc,
+        isAlive: () => !!state.proc,
+        pid: () => state.pid,
+        async shutdown() {
+            if (state.shuttingDown)
+                return;
+            state.shuttingDown = true;
+            if (state.restartTimer) {
+                clearTimeout(state.restartTimer);
+                state.restartTimer = null;
+            }
+            state.readyDeferred?.reject(new Error("supervisor shutting down"));
+            const proc = state.proc;
+            if (!proc)
+                return;
+            try {
+                proc.kill("SIGTERM");
+            }
+            catch { }
+            const exited = await new Promise((resolve) => {
+                const t = setTimeout(() => {
+                    try {
+                        proc.kill("SIGKILL");
+                    }
+                    catch { }
+                    resolve(true);
+                }, SHUTDOWN_GRACE_MS);
+                proc.once("exit", () => { clearTimeout(t); resolve(true); });
+            });
+            state.proc = null;
+            state.pid = null;
+            void exited;
+        },
+    };
+    // Kick off — intentionally not awaited. The supervisor handle is
+    // returned synchronously so callers can stash it / attach shutdown
+    // hooks; the spawn + healthcheck loop runs in the background.
+    void spawnAndWatch();
+    return supervisor;
+}

package/dist/drivers/whatsmeow/whatsmeow.proto

@@ -0,0 +1,64 @@
+syntax = "proto3";
+package whatsmeow;
+
+service WhatsmeowService {
+  rpc Connect(ConnectRequest) returns (ConnectResponse);
+  rpc Disconnect(Empty) returns (Empty);
+  rpc SendText(SendTextRequest) returns (SentMessageRef);
+  rpc SendMedia(SendMediaRequest) returns (SentMessageRef);
+  rpc React(ReactRequest) returns (Empty);
+  rpc GetHistory(GetHistoryRequest) returns (GetHistoryResponse);
+  rpc SubscribeEvents(Empty) returns (stream WaEvent);
+  rpc HealthCheck(Empty) returns (HealthStatus);
+}
+
+message Empty {}
+
+message ConnectRequest { string sessionDir = 1; }
+message ConnectResponse { bool ok = 1; string qrCode = 2; }
+
+message SendTextRequest {
+  string jid = 1;
+  string text = 2;
+  string quotedId = 3;
+  repeated string mentions = 4;
+}
+
+message SendMediaRequest {
+  string jid = 1;
+  string kind = 2; // image|video|audio|sticker|document
+  bytes buffer = 3;
+  string caption = 4;
+  string quotedId = 5;
+}
+
+message SentMessageRef {
+  string id = 1;
+  string chatId = 2;
+  int64 timestamp = 3;
+}
+
+message ReactRequest { string jid = 1; string messageId = 2; string emoji = 3; }
+
+message GetHistoryRequest { string jid = 1; int32 limit = 2; }
+message GetHistoryResponse { repeated BotMessage messages = 1; }
+
+message BotMessage {
+  string id = 1;
+  string chatId = 2;
+  bool fromMe = 3;
+  string type = 4;
+  string contentHash = 5;
+  int64 timestamp = 6;
+}
+
+message WaEvent {
+  oneof payload {
+    BotMessage message = 1;
+    ConnStateUpdate connState = 2;
+  }
+}
+
+message ConnStateUpdate { string state = 1; }
+
+message HealthStatus { bool ready = 1; }

package/dist/i18n/index.js

@@ -123,12 +123,6 @@ function interpolate(str, context = {}) {
         return context[key] !== undefined ? String(context[key]) : match;
     });
 }
-/**
- * Main translation function
- * @param {string} key - translation key (e.g., "system.connected")
- * @param {object} context - values to interpolate {{key}}
- * @returns {string}
- */
 export function t(key, context = {}) {
     ensureLoaded();
     // Try current language first
@@ -141,6 +135,11 @@ export function t(key, context = {}) {
     if (value === undefined) {
         return key;
     }
+    // Caller explicitly wants the raw nested object (e.g. a map like
+    // messages.mobs), skip stringification/interpolation entirely.
+    if (context.returnObjects && typeof value === "object" && value !== null) {
+        return value;
+    }
     // If not string, convert
     if (typeof value !== "string") {
         return String(value);
@@ -191,12 +190,6 @@ export function createPluginT(pluginMetaUrl) {
     catch (err) {
         // Silent fail - plugin may not have translations
     }
-    /**
-     * Plugin-specific translation function
-     * @param {string} key
-     * @param {object} context
-     * @returns {string}
-     */
     function pluginT(key, context = {}) {
         // Try plugin's target language first
         let value = getNestedValue(pluginTranslations, key);
@@ -208,6 +201,9 @@ export function createPluginT(pluginMetaUrl) {
         if (value === undefined) {
             return key;
         }
+        if (context.returnObjects && typeof value === "object" && value !== null) {
+            return value;
+        }
         if (typeof value !== "string") {
             return String(value);
         }

package/dist/kernel/alerts.js

@@ -0,0 +1,190 @@
+/**
+ * alerts.ts
+ *
+ * Local-first critical alerting. The whole point is to still reach the
+ * dev when the thing most likely to fail — the bot's own WhatsApp
+ * connection — is exactly what's down. So WhatsApp is one sink among
+ * several, never the only one:
+ *
+ *   1. Log file (~/.manybot/alerts.log) — always written, no dependency
+ *      on anything external. The one sink guaranteed to work.
+ *   2. OS notification (notify-send / osascript) — best-effort, only
+ *      if the process is still alive to fire it.
+ *   3. WhatsApp (ADMIN_JID)              — best-effort, only if a
+ *      socket has been registered and the bot is actually connected.
+ *   4. Email (SMTP)                      — best-effort, only if
+ *      SMTP_HOST is configured.
+ *
+ * Sinks never block each other — a failure in one (e.g. SMTP down)
+ * must not stop the log write or the other sinks.
+ *
+ * Kernel code must stay driver-agnostic: this module never imports the
+ * WhatsApp driver directly. Instead the driver calls
+ * registerAlertSockProvider() once at startup so this module can reach
+ * it indirectly, keeping the dependency pointing driver → kernel.
+ */
+import fs from "fs/promises";
+import path from "path";
+import { spawn } from "child_process";
+import nodemailer from "nodemailer";
+import { CONFIG_DIR, ADMIN_JID, SMTP_HOST, SMTP_PORT, SMTP_SEC, SMTP_USER, SMTP_PASS, SMTP_FROM, SMTP_TO, SMTP_INSECURE, } from "#config";
+import { logger } from "#logger";
+const ALERTS_LOG_FILE = path.join(CONFIG_DIR, "alerts.log");
+let sockProvider = null;
+/**
+ * Called once by a driver (e.g. the WhatsApp driver) at startup so alerts
+ * can reach ADMIN_JID when the bot is connected. Safe to call multiple
+ * times — the latest provider wins.
+ * @param {() => SockLike | null} provider
+ */
+export function registerAlertSockProvider(provider) {
+    sockProvider = provider;
+}
+// ── Sinks ─────────────────────────────────────────────────────────────────
+async function logToFile(event) {
+    try {
+        await fs.mkdir(CONFIG_DIR, { recursive: true });
+        const line = `[${new Date().toISOString()}] [${event.level.toUpperCase()}] ${event.title} — ${event.message}\n`;
+        await fs.appendFile(ALERTS_LOG_FILE, line, "utf8");
+    }
+    catch (e) {
+        // Last-resort fallback — if even the log write fails, at least surface
+        // it on stderr so it's visible in whatever is supervising the process.
+        logger.error(`[alerts] failed to write ${ALERTS_LOG_FILE}: ${e.message}`);
+    }
+}
+function notifyOS(event) {
+    return new Promise((resolve) => {
+        const platform = process.platform;
+        let cmd;
+        let args;
+        if (platform === "linux") {
+            cmd = "notify-send";
+            args = [event.title, event.message];
+        }
+        else if (platform === "darwin") {
+            cmd = "osascript";
+            args = ["-e", `display notification ${JSON.stringify(event.message)} with title ${JSON.stringify(event.title)}`];
+        }
+        else {
+            // Windows toast notifications need extra tooling (BurntToast) that
+            // isn't available out of the box — skip rather than half-implement.
+            logger.debug(`[alerts] OS notification not supported on ${platform}, skipping`);
+            resolve();
+            return;
+        }
+        const proc = spawn(cmd, args, { stdio: "ignore" });
+        proc.on("error", (e) => {
+            logger.debug(`[alerts] OS notification failed (non-fatal): ${e.message}`);
+            resolve();
+        });
+        proc.on("exit", () => resolve());
+    });
+}
+/**
+ * Accepts either a full JID ("5511999999999@s.whatsapp.net") or a bare
+ * phone number ("+55 11 99999-9999", "5511999999999") in ADMIN_JID —
+ * strips formatting and appends the WhatsApp suffix when missing.
+ * @param {string} raw
+ */
+function normalizeAdminJid(raw) {
+    if (raw.includes("@"))
+        return raw;
+    const digits = raw.replace(/\D/g, "");
+    return `${digits}@s.whatsapp.net`;
+}
+async function notifyWhatsApp(event) {
+    if (!ADMIN_JID)
+        return;
+    const sock = sockProvider?.();
+    if (!sock)
+        return; // bot not connected — expected during the exact outages this exists for
+    try {
+        await sock.sendMessage(normalizeAdminJid(ADMIN_JID), { text: `*[${event.level.toUpperCase()}] ${event.title}*\n\n${event.message}` });
+    }
+    catch (e) {
+        logger.debug(`[alerts] WhatsApp sink failed (non-fatal): ${e.message}`);
+    }
+}
+let mailer = null;
+function getMailer() {
+    if (!SMTP_HOST || !SMTP_TO)
+        return null;
+    if (mailer)
+        return mailer;
+    mailer = nodemailer.createTransport({
+        host: SMTP_HOST,
+        port: SMTP_PORT,
+        secure: SMTP_SEC === "ssl",
+        requireTLS: SMTP_SEC === "starttls",
+        auth: SMTP_USER ? { user: SMTP_USER, pass: SMTP_PASS } : undefined,
+        // Local SMTP proxies (Proton Mail Bridge, Mailhog, Mailpit...) present
+        // a self-signed cert — only skip validation when explicitly opted in.
+        tls: SMTP_INSECURE ? { rejectUnauthorized: false } : undefined,
+    });
+    return mailer;
+}
+async function notifyEmail(event) {
+    const transport = getMailer();
+    if (!transport)
+        return;
+    try {
+        await transport.sendMail({
+            from: SMTP_FROM || SMTP_USER,
+            to: SMTP_TO,
+            subject: `[manybot] [${event.level.toUpperCase()}] ${event.title}`,
+            text: event.message,
+        });
+    }
+    catch (e) {
+        logger.debug(`[alerts] email sink failed (non-fatal): ${e.message}`);
+    }
+}
+// ── Public API ────────────────────────────────────────────────────────────
+/**
+ * Fires an alert through every configured sink. The log write always
+ * happens; OS notification, WhatsApp, and email are best-effort and run
+ * independently — one failing never blocks the others.
+ * @param {AlertEvent} event
+ */
+export async function sendAlert(event) {
+    await logToFile(event);
+    await Promise.allSettled([
+        notifyOS(event),
+        notifyWhatsApp(event),
+        notifyEmail(event),
+    ]);
+}
+export function fireAlert(kind, details = {}) {
+    let event;
+    if (kind === "send_failed_no_fallback") {
+        event = {
+            level: "critical",
+            title: "manybot: sem driver de fallback",
+            message: `jid=${details.jid} primary=${details.primary}`,
+        };
+    }
+    else if (kind === "send_failed_both_drivers") {
+        event = {
+            level: "critical",
+            title: "manybot: envio falhou nos dois drivers",
+            message: `jid=${details.jid} ${details.primary}->${details.secondary}` +
+                (details.error ? ` error=${String(details.error)}` : ""),
+        };
+    }
+    else if (kind === "whatsmeow_subprocess_halted") {
+        event = {
+            level: "critical",
+            title: "manybot: subprocesso whatsmeow halted",
+            message: `fallback indisponível: ${details.reason ?? "unknown"} — bot segue só com Baileys`,
+        };
+    }
+    else {
+        event = {
+            level: "warning",
+            title: kind,
+            message: JSON.stringify(details),
+        };
+    }
+    void sendAlert(event);
+}