@manybot/manybot 5.6.0 → 5.7.0

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.7.0",
   "license": "GPL-3.0-only",
   "private": false,
   "engines": {
@@ -40,7 +40,7 @@
     "@grpc/grpc-js": "^1.14.4",
     "@grpc/proto-loader": "^0.7.15",
     "@hapi/boom": "^10.0.1",
-    "@whiskeysockets/baileys": "6.7.23",
+    "@whiskeysockets/baileys": "6.7.24",
     "node-cron": "^4.6.0",
     "node-webpmux": "^3.2.1",
     "nodemailer": "^9.0.3",