@manybot/manybot 5.6.1 → 5.8.0

package/dist/locales/es.json

@@ -36,13 +36,75 @@
     "cacheLoaded": "{{count}} chat(s) cargado(s) desde la caché.",
     "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}})"
+    "sendFailedBothDrivers": "manybot: envío falló en ambos drivers (jid={{jid}}, se probó {{primary}} y luego {{secondary}})",
+    "commandsConfigMissingCmd": "commands.yaml: el comando \"{{id}}\" no tiene el campo obligatorio \"cmd\" — se omitió",
+    "commandRegistryInvalidPluginCommand": "commandRegistry: el plugin \"{{plugin}}\" comando \"{{function}}\" ({{id}}) tiene \"cmd\" inválido o ausente — se omitió",
+    "commandsConfigArgumentMissingName": "commands.yaml: la entrada de argumento bajo \"{{id}}\" no tiene el campo obligatorio \"name\" — se omitió",
+    "commandsConfigArgumentMissingType": "commands.yaml: el argumento \"{{name}}\" bajo \"{{id}}\" no tiene el campo obligatorio \"type\" — se omitió",
+    "commandsConfigUnknownArgType": "commands.yaml: el argumento \"{{name}}\" bajo \"{{id}}\" tiene un tipo desconocido \"{{type}}\" — se omitió",
+    "commandsConfigChoiceArgumentNoChoices": "commands.yaml: el argumento \"{{name}}\" bajo \"{{id}}\" es de tipo \"choice\" pero no declaró ninguna opción — usando placeholder genérico en la sugerencia de uso",
+    "commandsConfigArgumentsNotList": "commands.yaml: arguments bajo \"{{id}}\" debe ser una lista — se ignoró",
+    "commandsConfigSubcommandMissingCmd": "commands.yaml: el subcomando bajo \"{{id}}\" no tiene el campo obligatorio \"cmd\" — se omitió",
+    "commandsConfigSubcommandsNotList": "commands.yaml: subcommands bajo \"{{id}}\" debe ser una lista — se ignoró",
+    "commandsConfigDuplicateSubcommand": "commands.yaml: subcomando duplicado \"{{cmd}}\" bajo \"{{id}}\" — se conserva el primero",
+    "commandsConfigReadFailed": "commands.yaml: no se pudo leer ({{path}}): {{message}}",
+    "commandsConfigParseFailed": "commands.yaml: error de parseo YAML: {{message}}",
+    "commandsConfigInvalidRoot": "commands.yaml: el nivel raíz debe ser un mapa de entradas de comandos",
+    "commandsConfigInvalidEntry": "commands.yaml: la entrada \"{{id}}\" no es un objeto — se omitió",
+    "commandsConfigImportReadFailed": "commands.yaml: no se pudo leer el import \"{{path}}\": {{message}}",
+    "commandsConfigImportParseFailed": "commands.yaml: error de parseo YAML en el import \"{{path}}\": {{message}}",
+    "commandsConfigImportInvalidRoot": "commands.yaml: el import \"{{path}}\" debe tener un mapa de secciones en el nivel raíz — se omitió",
+    "commandsConfigImportNested": "commands.yaml: el import \"{{path}}\" declara su propio \"import\" — los imports anidados no son compatibles y se ignoraron",
+    "commandsConfigImportKeyConflict": "commands.yaml: el import \"{{path}}\" redefine \"{{key}}\", que ya pertenece a \"{{owner}}\" — se conserva el primero",
+    "commandRegistryOrphanEntry": "commandRegistry: la entrada \"{{id}}\" apunta a {{plugin}}.{{function}} pero ningún plugin activo la provee — se omitió",
+    "commandRegistryInvalidEntry": "commandRegistry: la entrada \"{{id}}\" no tiene plugin/function ni text — se omitió",
+    "commandRegistryInvocationCollision": "commandRegistry: la invocación \"{{text}}\" ya pertenece a \"{{winner}}\" — descartando {{loser}} ({{via}})",
+    "commandDeprecationRenamed": "commandRegistry: comando \"{{id}}\" renombrado de \"{{old}}\" a \"{{new}}\" — notificando a quienes llamen al antiguo durante {{days}} días",
+    "commandDeprecationRemoved": "commandRegistry: comando \"{{id}}\" (cmd \"{{old}}\") fue eliminado — notificando a quienes llamen al antiguo durante {{days}} días",
+    "commandDeprecationFallbackRenamed": "El comando \"{{old}}\" se renombró a \"{{new}}\". Actualiza tu mensaje.",
+    "commandDeprecationFallbackRemoved": "El comando \"{{old}}\" ya no está disponible.",
+    "commandDeprecationReservedInvocation": "commandRegistry: la invocación \"{{text}}\" está reservada por deprecation activa de \"{{id}}\" — registro rechazado",
+    "commandManualMissing": "No hay manual detallado disponible para el comando \"{{cmd}}\".",
+    "commandNotFound": "Comando o categoría \"{{cmd}}\" no encontrado. Usa {{prefix}}{{menuCmd}} para ver la lista de comandos.",
+    "commandRegistryMenuAliasCollision": "commandRegistry: alias de menú \"{{alias}}\" colisionó con comando real \"{{winner}}\" — alias de menú ignorado"
   },
   "errors": {
     "stack": "Stack",
     "invalid_config": "Archivo de configuración inválido {{file}}: {{error}}",
     "fix_config": "Corrige la sintaxis en {{file}} antes de iniciar el bot."
   },
+  "menu": {
+    "intro": "Usa {prefix}<comando> para ejecutarlo o {prefix}help <comando> para ver el manual.",
+    "other": "Otros",
+    "category": "Categoría",
+    "manual": "Manual",
+    "description": "Descripción"
+  },
+  "commandPermissions": {
+    "botNotAdmin": "Este comando requiere que el bot sea administrador del grupo.",
+    "senderNotAdmin": "Este comando está restringido a administradores del grupo.",
+    "ownerOnly": "Este comando solo puede ser ejecutado por el dueño del bot.",
+    "wrongScope": "Este comando no puede usarse en este contexto.",
+    "cooldown": "Espera {{seconds}}s antes de volver a usar este comando."
+  },
+  "commandRun": {
+    "missingRequiredArg": "Faltan argumentos obligatorios.",
+    "unknownSubcommand": "Subcomando \"{{sub}}\" desconocido para !{{cmd}}. Válidos: {{valid}}."
+  },
+"alerts": {
+    "noFallbackTitle": "manybot: sin driver de fallback",
+    "bothDriversFailedTitle": "manybot: envío fallido en ambos drivers",
+    "updateAvailableTitle": "Nueva versión del manybot disponible",
+    "updateAvailableMessage": "Instalado: {{instalado}} → disponible: {{disponible}}. Vea {{url}} para instrucciones de actualización.",
+    "reconnectHaltedTitle": "manybot detuvo la reconexión",
+    "reconnectHaltedMessage": "Desistió después de {{intento}} intentos — posible restricción de la cuenta. Ejecute connect() manualmente para intentar nuevamente."
+  },
+  "driver": {
+    "groupParticipantNotFound": "\"{{id}}\" no coincide con ningún participante actual del grupo \"{{group}}\" (comprueba si la persona sigue en el grupo o usa una respuesta/mención en lugar de escribir el número).",
+    "groupParticipantsUpdateRejected": "groupParticipantsUpdate(\"{{action}}\") rechazado para: {{detail}}",
+    "groupParticipantsUpdateFailed": "groupParticipantsUpdate(\"{{action}}\") falló para el grupo \"{{group}}\" con participantes [{{users}}]: {{message}}",
+    "pollDecryptFailed": "No se pudo descifrar el voto de la encuesta: {{error}}"
+  },
   "onboarding": {
     "intro": "ManyBot — primer inicio de sesión",
     "methodPrompt": "¿Cómo quieres conectar tu cuenta de WhatsApp?",
@@ -69,17 +131,6 @@
     "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

@@ -36,13 +36,75 @@
     "cacheLoaded": "{{count}} conversa(s) carregada(s) do cache.",
     "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}})"
+    "sendFailedBothDrivers": "manybot: envio falhou nos dois drivers (jid={{jid}}, tentou {{primary}} depois {{secondary}})",
+    "commandsConfigMissingCmd": "commands.yaml: comando \"{{id}}\" sem o campo obrigatório \"cmd\" — ignorado",
+    "commandRegistryInvalidPluginCommand": "commandRegistry: plugin \"{{plugin}}\" comando \"{{function}}\" ({{id}}) tem \"cmd\" inválido ou ausente — ignorado",
+    "commandsConfigArgumentMissingName": "commands.yaml: entrada de argumento sob \"{{id}}\" sem o campo obrigatório \"name\" — ignorada",
+    "commandsConfigArgumentMissingType": "commands.yaml: argumento \"{{name}}\" sob \"{{id}}\" sem o campo obrigatório \"type\" — ignorado",
+    "commandsConfigUnknownArgType": "commands.yaml: argumento \"{{name}}\" sob \"{{id}}\" com tipo desconhecido \"{{type}}\" — ignorado",
+    "commandsConfigChoiceArgumentNoChoices": "commands.yaml: argumento \"{{name}}\" sob \"{{id}}\" é do tipo \"choice\" mas não declarou nenhuma opção — usando placeholder genérico na sugestão de uso",
+    "commandsConfigArgumentsNotList": "commands.yaml: arguments sob \"{{id}}\" precisa ser uma lista — ignorado",
+    "commandsConfigSubcommandMissingCmd": "commands.yaml: subcomando sob \"{{id}}\" sem o campo obrigatório \"cmd\" — ignorado",
+    "commandsConfigSubcommandsNotList": "commands.yaml: subcommands sob \"{{id}}\" precisa ser uma lista — ignorado",
+    "commandsConfigDuplicateSubcommand": "commands.yaml: subcomando duplicado \"{{cmd}}\" sob \"{{id}}\" — mantendo o primeiro",
+    "commandsConfigReadFailed": "commands.yaml: não foi possível ler ({{path}}): {{message}}",
+    "commandsConfigParseFailed": "commands.yaml: erro de parse YAML: {{message}}",
+    "commandsConfigInvalidRoot": "commands.yaml: o nível raiz deve ser um mapa de entradas de comando",
+    "commandsConfigInvalidEntry": "commands.yaml: entrada \"{{id}}\" não é um objeto — ignorada",
+    "commandsConfigImportReadFailed": "commands.yaml: não foi possível ler o import \"{{path}}\": {{message}}",
+    "commandsConfigImportParseFailed": "commands.yaml: erro de parse YAML no import \"{{path}}\": {{message}}",
+    "commandsConfigImportInvalidRoot": "commands.yaml: o import \"{{path}}\" precisa ter um mapa de seções no nível raiz — ignorado",
+    "commandsConfigImportNested": "commands.yaml: o import \"{{path}}\" declara seu próprio \"import\" — imports aninhados não são suportados e foram ignorados",
+    "commandsConfigImportKeyConflict": "commands.yaml: o import \"{{path}}\" redefine \"{{key}}\", que já pertence a \"{{owner}}\" — mantendo o primeiro",
+    "commandRegistryOrphanEntry": "commandRegistry: entrada \"{{id}}\" aponta para {{plugin}}.{{function}} mas nenhum plugin ativo fornece — ignorada",
+    "commandRegistryInvalidEntry": "commandRegistry: entrada \"{{id}}\" não tem plugin/function nem text — ignorada",
+    "commandRegistryInvocationCollision": "commandRegistry: invocação \"{{text}}\" já pertence a \"{{winner}}\" — descartando {{loser}} ({{via}})",
+    "commandDeprecationRenamed": "commandRegistry: comando \"{{id}}\" renomeado de \"{{old}}\" para \"{{new}}\" — avisando chamadores antigos por {{days}} dias",
+    "commandDeprecationRemoved": "commandRegistry: comando \"{{id}}\" (cmd \"{{old}}\") foi removido — avisando chamadores antigos por {{days}} dias",
+    "commandDeprecationFallbackRenamed": "O comando \"{{old}}\" foi renomeado para \"{{new}}\". Atualize sua mensagem.",
+    "commandDeprecationFallbackRemoved": "O comando \"{{old}}\" não está mais disponível.",
+    "commandDeprecationReservedInvocation": "commandRegistry: invocação \"{{text}}\" está reservada por deprecation ativa de \"{{id}}\" — registro recusado",
+    "commandManualMissing": "Nenhum manual detalhado disponível para o comando \"{{cmd}}\".",
+    "commandNotFound": "Comando ou categoria \"{{cmd}}\" não encontrado. Use {{prefix}}{{menuCmd}} para ver a lista de comandos.",
+    "commandRegistryMenuAliasCollision": "commandRegistry: alias de menu \"{{alias}}\" colidiu com comando real \"{{winner}}\" — alias de menu ignorado"
   },
   "errors": {
     "stack": "Stack",
     "invalid_config": "Arquivo de configuração inválido {{file}}: {{error}}",
     "fix_config": "Corrija a sintaxe em {{file}} antes de iniciar o bot."
   },
+  "menu": {
+    "intro": "Use {prefix}<comando> para executar ou {prefix}help <comando> para ver o manual.",
+    "other": "Outros",
+    "category": "Categoria",
+    "manual": "Manual",
+    "description": "Descrição"
+  },
+  "commandPermissions": {
+    "botNotAdmin": "Este comando exige que o bot seja administrador do grupo.",
+    "senderNotAdmin": "Este comando é restrito a administradores do grupo.",
+    "ownerOnly": "Este comando só pode ser executado pelo dono do bot.",
+    "wrongScope": "Este comando não pode ser usado neste contexto.",
+    "cooldown": "Aguarde {{seconds}}s antes de usar este comando novamente."
+  },
+  "commandRun": {
+    "missingRequiredArg": "Faltam argumentos obrigatórios.",
+    "unknownSubcommand": "Subcomando \"{{sub}}\" desconhecido para !{{cmd}}. Válidos: {{valid}}."
+  },
+"alerts": {
+    "noFallbackTitle": "manybot: sem driver de fallback",
+    "bothDriversFailedTitle": "manybot: envio falhou nos dois drivers",
+    "updateAvailableTitle": "Nova versão do manybot disponível",
+    "updateAvailableMessage": "Instalado: {{installed}} → disponível: {{available}}. Veja {{url}} para instruções de atualização.",
+    "reconnectHaltedTitle": "manybot parou de reconectar",
+    "reconnectHaltedMessage": "Desistiu após {{attempts}} tentativas — possível restrição da conta. Execute connect() manualmente para tentar novamente."
+  },
+  "driver": {
+    "groupParticipantNotFound": "\"{{id}}\" não corresponde a nenhum participante atual do grupo \"{{group}}\" (confira se a pessoa ainda está no grupo, ou use reply/menção em vez de digitar o número).",
+    "groupParticipantsUpdateRejected": "groupParticipantsUpdate(\"{{action}}\") rejeitado para: {{detail}}",
+    "groupParticipantsUpdateFailed": "groupParticipantsUpdate(\"{{action}}\") falhou para o grupo \"{{group}}\" com participantes [{{users}}]: {{message}}",
+    "pollDecryptFailed": "Erro ao decriptar voto da enquete: {{error}}"
+  },
   "onboarding": {
     "intro": "ManyBot — primeiro login",
     "methodPrompt": "Como você quer conectar sua conta do WhatsApp?",
@@ -69,17 +131,6 @@
     "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/logger/logger.js

@@ -3,14 +3,34 @@ const c = {
     green: "\x1b[32m", yellow: "\x1b[33m", cyan: "\x1b[36m",
     red: "\x1b[31m", blue: "\x1b[34m",
 };
+let debugEnabled = process.argv.includes("--debug");
+let logLevel = "normal";
+export function setLogLevel(level) { logLevel = level; }
+export function getLogLevel() { return logLevel; }
 /**
  * ManyBot central logger.
  * Each method only handles output — no business logic or external I/O.
+ *
+ * `debug` is silent by default to keep production logs clean. Pass
+ * `--debug` on the command line to enable it. The check is a single
+ * `Array.includes` on argv, cheap enough to do per call and avoids
+ * requiring logger consumers to know about a global toggle.
  */
 export const logger = {
-    info: (...a) => console.log(`${c.cyan}INFO  ${c.reset}`, ...a),
-    success: (...a) => console.log(`${c.green}OK    ${c.reset}`, ...a),
+    info: (...a) => {
+        if (logLevel === "normal")
+            console.log(`${c.cyan}INFO  ${c.reset}`, ...a);
+    },
+    success: (...a) => {
+        if (logLevel !== "minimal")
+            console.log(`${c.green}OK    ${c.reset}`, ...a);
+    },
     warn: (...a) => console.log(`${c.yellow}WARN  ${c.reset}`, ...a),
     error: (...a) => console.log(`${c.red}ERROR ${c.reset}`, ...a),
-    debug: (...a) => console.log(`${c.blue}DEBUG ${c.reset}`, ...a),
+    debug: (...a) => {
+        if (debugEnabled)
+            console.log(`${c.blue}DEBUG ${c.reset}`, ...a);
+    },
 };
+export function enableDebug() { debugEnabled = true; }
+export function isDebugEnabled() { return debugEnabled; }

package/dist/logger/logger.test.js

@@ -0,0 +1,45 @@
+import test, { describe, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { logger, setLogLevel, getLogLevel } from "./logger.js";
+describe("logger levels", () => {
+    const originalLog = console.log;
+    let lines;
+    beforeEach(() => {
+        lines = [];
+        console.log = (...a) => { lines.push(a.join(" ")); };
+    });
+    afterEach(() => {
+        console.log = originalLog;
+        setLogLevel("normal");
+    });
+    test("defaults to normal", () => {
+        assert.equal(getLogLevel(), "normal");
+    });
+    test("normal shows info, success, warn, error", () => {
+        setLogLevel("normal");
+        logger.info("a");
+        logger.success("b");
+        logger.warn("c");
+        logger.error("d");
+        assert.equal(lines.length, 4);
+    });
+    test("clean hides info but keeps success, warn, error", () => {
+        setLogLevel("clean");
+        logger.info("a");
+        logger.success("b");
+        logger.warn("c");
+        logger.error("d");
+        assert.equal(lines.length, 3);
+        assert.ok(!lines.some(l => l.includes("a")));
+    });
+    test("minimal hides info and success, keeps warn and error", () => {
+        setLogLevel("minimal");
+        logger.info("a");
+        logger.success("b");
+        logger.warn("c");
+        logger.error("d");
+        assert.equal(lines.length, 2);
+        assert.ok(lines.some(l => l.includes("c")));
+        assert.ok(lines.some(l => l.includes("d")));
+    });
+});

package/dist/main.js

@@ -10,49 +10,20 @@ import path from "path";
 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";
 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 { STATUS_ENABLED, STATUS_PORT, LOG_LEVEL } from "#config";
+import { logger, setLogLevel } from "#logger";
 import { t } from "#i18n";
+setLogLevel(LOG_LEVEL);
 let shuttingDown = false;
-// 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.
+// DriverManager registration: only Baileys driver now
 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");
-}
+driverManager.register(baileysContract, { isPrimary: true });
 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;
@@ -87,16 +58,6 @@ async function shutdown(reason, isError = false) {
     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
@@ -116,11 +77,6 @@ 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")) {
-    // 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) {
@@ -134,16 +90,6 @@ 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"));
@@ -153,23 +99,6 @@ else {
     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);

package/dist/plugins/__manybot_integration__/index.js

@@ -0,0 +1,167 @@
+/**
+ * plugins/__manybot_integration__/index.ts
+ *
+ * Internal integration plugin for the WhatsApp test suite. NOT a
+ * user-facing plugin — only the test harness loads it, and only when
+ * integration mode is enabled (see `kernel/integrationMode.ts`).
+ *
+ * Responsibilities:
+ *   - Refuse to act on any chat other than the configured TEST_CHAT.
+ *     Anything arriving in another chat is dropped with a warning,
+ *     never replied to.
+ *   - Expose a small public API the test harness drives:
+ *       - `testChat`        — the JID we will respond in.
+ *       - `isTestChat(jid)` — true iff `jid` matches the test chat.
+ *       - `waitForMarker(marker, timeoutMs)`
+ *                            — resolves with the message id of the
+ *                              first inbound message in the test chat
+ *                              whose body starts with `marker`. Used
+ *                              by tests to observe real round-trips
+ *                              (e.g. "send a message, wait until the
+ *                              contact echoes it back").
+ *   - Keep a bounded ring buffer of recent message bodies in the
+ *     test chat so tests can also assert on what was sent earlier
+ *     in the same run.
+ *
+ * This plugin is intentionally minimal — it does NOT register user
+ * commands, does NOT participate in the `commands.yaml` registry,
+ * and shuts down cleanly via the normal plugin cleanup path
+ * (cleanupPluginEvents is driven by the kernel, not by us).
+ *
+ * Imports are restricted to types and the `events` module from the
+ * kernel — never a driver package, never the raw socket. The
+ * `ctx.wa.contract` neutral access is the only driver surface used
+ * (and only for `me()` and any helper the test harness invokes).
+ */
+import { EventEmitter } from "node:events";
+import { logger } from "#logger";
+import { INTEGRATION_PLUGIN_NAME } from "#kernel/integrationMode.js";
+const RING_BUFFER_LIMIT = 50;
+const DEFAULT_TIMEOUT_MS = 30_000;
+let configuredTestChat = null;
+const recent = new Map();
+let recentSeq = 0;
+const waiter = new EventEmitter();
+function pushRecent(body, from) {
+    const id = ++recentSeq;
+    recent.set(id, { body, from, ts: Date.now() });
+    // Cap the ring buffer; eviction keeps insertion order.
+    while (recent.size > RING_BUFFER_LIMIT) {
+        const firstKey = recent.keys().next().value;
+        if (firstKey === undefined)
+            break;
+        recent.delete(firstKey);
+    }
+}
+function findByMarker(marker) {
+    for (const entry of recent.values()) {
+        if (entry.body.startsWith(marker))
+            return entry;
+    }
+    return null;
+}
+export const api = {
+    testChat: "", // populated in setup()
+    isTestChat(jid) {
+        if (!jid)
+            return false;
+        if (!configuredTestChat)
+            return false;
+        return jid === configuredTestChat;
+    },
+    async waitForMarker(marker, timeoutMs = DEFAULT_TIMEOUT_MS) {
+        const existing = findByMarker(marker);
+        if (existing) {
+            // Return a synthetic id; tests that need the real id should
+            // observe the `messages.upsert` payload directly.
+            return `recent:${existing.ts}`;
+        }
+        return new Promise((resolve, reject) => {
+            const onHit = (entry) => {
+                if (!entry.body.startsWith(marker))
+                    return;
+                waiter.off("hit", onHit);
+                clearTimeout(timer);
+                resolve(`recent:${entry.ts}`);
+            };
+            const timer = setTimeout(() => {
+                waiter.off("hit", onHit);
+                reject(new Error(`[${INTEGRATION_PLUGIN_NAME}] waitForMarker("${marker}") timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            waiter.on("hit", onHit);
+        });
+    },
+    recentBodies() {
+        return [...recent.values()].map((e) => e.body);
+    },
+};
+/**
+ * setup() runs once after the bot connects. We capture the test
+ * chat here so the runtime API can refuse any other chat.
+ */
+export async function setup(ctx) {
+    // The integration chat is decided by the harness BEFORE
+    // setupPlugins() is called. Historically the harness set
+    // MANYBOT_TEST_CHAT, but users often set TEST_CHAT (per docs).
+    // Accept either, normalizing the value to the canonical JID form.
+    // Keep behavior strict: if neither is set, fail.
+    const rawEnv = process.env.MANYBOT_TEST_CHAT ?? process.env.TEST_CHAT;
+    if (!rawEnv) {
+        throw new Error(`[${INTEGRATION_PLUGIN_NAME}] setup() called without MANYBOT_TEST_CHAT or TEST_CHAT — ` +
+            `set MANYBOT_TEST_CHAT (preferred) or TEST_CHAT before setupPlugins().`);
+    }
+    // Normalize and validate the provided chat identifier.
+    let normalized;
+    try {
+        // Importing normalizeTestChat here keeps the module load cheap
+        // when the plugin isn't used in production code paths.
+        const { normalizeTestChat } = await import("#kernel/testConfig.js");
+        normalized = normalizeTestChat(rawEnv);
+    }
+    catch (e) {
+        throw new Error(`[${INTEGRATION_PLUGIN_NAME}] invalid test chat provided: ${e.message}`);
+    }
+    configuredTestChat = normalized;
+    api.testChat = normalized;
+    // Subscribe to the relevant events so waitForMarker works
+    // without requiring a polling loop. `messages.upsert` is the
+    // single source of truth for any new incoming message; `on()`
+    // returns an unsubscribe handle, but cleanupPluginEvents takes
+    // care of it for us.
+    ctx.events.on("messages.upsert", (payload) => {
+        const p = payload;
+        const messages = p.messages ?? [];
+        for (const m of messages) {
+            if (!m.chatId || m.chatId !== configuredTestChat)
+                continue;
+            const body = m.body ?? "";
+            const from = m.from ?? "";
+            pushRecent(body, from);
+            waiter.emit("hit", { body, from, ts: Date.now() });
+        }
+    });
+    logger.info(`[${INTEGRATION_PLUGIN_NAME}] loaded — locked to test chat ${configuredTestChat}`);
+    // ctx reserved for future use (e.g. registering a scheduler)
+    return void ctx;
+}
+/**
+ * default(ctx) runs on every inbound message. We are deliberately
+ * quiet outside the test chat so a stray message in a production
+ * chat never gets a reply from the test plugin; we never throw,
+ * because throwing would propagate up to messageHandler and
+ * potentially break unrelated plugins.
+ */
+export default async function handle(ctx) {
+    if (!configuredTestChat) {
+        logger.warn(`[${INTEGRATION_PLUGIN_NAME}] default() called before setup() — ignoring`);
+        return;
+    }
+    if (ctx.chat.id !== configuredTestChat) {
+        logger.warn(`[${INTEGRATION_PLUGIN_NAME}] ignoring message from non-test chat ${ctx.chat.id}`);
+        return;
+    }
+    // No automatic reply: the test harness drives every send through
+    // `ctx.send.*` or `contract.send*` and waits on `waitForMarker`
+    // for the round-trip. Keeping the plugin passive here is what
+    // makes the suite easy to reason about.
+}