@manybot/manybot 5.7.0 → 5.9.0

package/dist/kernel/driverManager.js

@@ -11,12 +11,7 @@
  * globalSock in pluginLoader.ts. Only main.ts is expected to call
  * register(); everywhere else reads through active() / get() / isDegraded.
  *
- * Shutdown order in shutdown() is reverse-registration, so a driver
- * that was added later (e.g. whatsmeow) is disconnected before the
- * primary one (typically Baileys). Re-registering the same name
- * overwrites the previous instance — the old driver is NOT disconnected
- * automatically, callers must disconnect it first if they want it torn
- * down.
+ * Shutdown order in shutdown() is reverse-registration.
  *
  * See the interface and cooldown semantics.
  */
@@ -69,6 +64,15 @@ class DriverManager {
     markDegraded(name, durationMs) {
         this.degradedUntil.set(name, Date.now() + durationMs);
     }
+    /**
+     * Drop the degradation entry for `name` so the next `isDegraded()`
+     * check returns false. Used after a successful send to clear the
+     * cooldown that the most recent failed send had set, without waiting
+     * for the timer to expire.
+     */
+    clearDegraded(name) {
+        this.degradedUntil.delete(name);
+    }
     /**
      * Promote a different driver to active. Used by tests / hot-swap;
      * the production sendFallbackGuard never calls this — fallback uses

package/dist/kernel/driverManager.test.js

@@ -0,0 +1,90 @@
+import test, { describe, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { getDriverManager, _resetDriverManagerForTests } from "#kernel/driverManager.js";
+function createFakeDriver(name, ready = true) {
+    const state = { disconnected: false };
+    const mockRef = (id) => ({ id, chatId: "123@c.us", timestamp: Date.now() });
+    return {
+        name,
+        isReady: () => ready,
+        disconnect: async () => {
+            state.disconnected = true;
+        },
+        get disconnected() {
+            return state.disconnected;
+        },
+        connect: async () => { },
+        me: () => ({ id: "123@c.us" }),
+        sendText: async () => mockRef("msg1"),
+        sendImage: async () => mockRef("msg2"),
+        sendVideo: async () => mockRef("msg3"),
+        sendAudio: async () => mockRef("msg4"),
+        sendSticker: async () => mockRef("msg5"),
+        sendDocument: async () => mockRef("msg6"),
+        sendLocation: async () => mockRef("msg7"),
+        sendContact: async () => mockRef("msg8"),
+        sendReaction: async () => { },
+        sendPoll: async () => mockRef("msg9"),
+        react: async () => { },
+        deleteMessage: async () => { },
+        editMessage: async () => { },
+        sendPresenceUpdate: async () => { },
+        readMessages: async () => { },
+        onWhatsApp: async () => null,
+        getBusinessProfile: async () => null,
+        profilePictureUrl: async () => null,
+        fetchStatus: async () => null,
+        updateBlockStatus: async () => { },
+        addOrEditContact: async () => { },
+        removeContact: async () => { },
+        groupMetadata: async () => ({ subject: "Test Group", participants: [] }),
+        groupParticipantsUpdate: async () => [],
+        groupUpdateSubject: async () => { },
+        groupUpdateDescription: async () => { },
+        groupInviteCode: async () => "",
+        groupRevokeInvite: async () => "",
+        updateProfilePicture: async () => { },
+        updateProfileName: async () => { },
+        updateProfileStatus: async () => { },
+        downloadMedia: async () => null,
+        getContact: async () => null,
+        getProfilePictureUrl: async () => null,
+        on: () => () => { },
+    };
+}
+describe("kernel/driverManager", () => {
+    beforeEach(() => {
+        _resetDriverManagerForTests();
+    });
+    test("registers driver and returns active instance", () => {
+        const dm = getDriverManager();
+        const baileys = createFakeDriver("baileys");
+        dm.register(baileys, { isPrimary: true });
+        assert.equal(dm.activeName_(), "baileys");
+        assert.equal(dm.active(), baileys);
+        assert.equal(dm.get("baileys"), baileys);
+        assert.equal(dm.isReady("baileys"), true);
+    });
+    test("throws if active() called with no drivers registered", () => {
+        const dm = getDriverManager();
+        assert.throws(() => dm.active(), /no active driver registered/);
+    });
+    test("tracks degradation with expiration", async (t) => {
+        t.mock.timers.enable({ apis: ["Date"] });
+        const dm = getDriverManager();
+        const baileys = createFakeDriver("baileys");
+        dm.register(baileys, { isPrimary: true });
+        assert.equal(dm.isDegraded("baileys"), false);
+        dm.markDegraded("baileys", 1000);
+        assert.equal(dm.isDegraded("baileys"), true);
+        t.mock.timers.tick(1001);
+        assert.equal(dm.isDegraded("baileys"), false);
+    });
+    test("shutdown disconnects all drivers", async () => {
+        const dm = getDriverManager();
+        const baileys = createFakeDriver("baileys");
+        dm.register(baileys, { isPrimary: true });
+        await dm.shutdown();
+        assert.equal(baileys.disconnected, true);
+    });
+});

package/dist/kernel/integrationMode.js

@@ -0,0 +1,88 @@
+/**
+ * kernel/integrationMode.ts
+ *
+ * Toggles the "integration" mode that gates the WhatsApp integration
+ * test suite. In integration mode the bot loads a private plugin
+ * (`__manybot_integration__`) whose job is to drive real-WhatsApp
+ * operations from the test harness, and refuse to act in any chat
+ * other than the configured `TEST_CHAT`.
+ *
+ * Activation requires BOTH signals (mirrors `testConfig`):
+ *   - `MANYBOT_RUN_WHATSAPP_TESTS=1`  (explicit opt-in)
+ *   - a configured `TEST_CHAT`        (env or manybot.toml)
+ *
+ * Production code never imports this module in its hot path. The
+ * integration plugin loader is the only consumer; the production bot
+ * does not load the integration plugin and is not affected by the
+ * opt-in flag.
+ *
+ * The reserved plugin name uses a `__manybot_*__` double-underscore
+ * pattern so it cannot collide with a real plugin (the loader's
+ * normal `~/.manybot/plugins/<name>/` path does not create a
+ * directory starting with `__` on user machines, and the test setup
+ * installs it into a separate, non-user-controlled location).
+ */
+import path from "path";
+import { getTestConfig, requireTestConfig } from "#kernel/testConfig.js";
+import { logger } from "#logger";
+/**
+ * Reserved plugin name. The leading and trailing `__` are
+ * deliberate: this name is documented as reserved by the runtime,
+ * so no real plugin directory should ever be created with it.
+ * Plugins loaded from `~/.manybot/plugins/` with names that match
+ * this pattern are NOT auto-loaded by `loadPlugins()`; the
+ * integration harness has to ask for them explicitly.
+ */
+export const INTEGRATION_PLUGIN_NAME = "__manybot_integration__";
+/**
+ * Absolute path to the integration plugin's source directory inside
+ * the project. The plugin ships with the repo (not with the user's
+ * `~/.manybot/plugins/`) and is loaded directly from `src/`.
+ *
+ * Resolved relative to this module so the path survives the build
+ * (the plugin source is part of the published `src/` tree today;
+ * if/when the integration plugin gets moved into `dist/`, only
+ * this single constant needs to change).
+ */
+const INTEGRATION_PLUGIN_DIR = path.resolve(path.dirname(new URL(import.meta.url).pathname), "..", "plugins", INTEGRATION_PLUGIN_NAME);
+/** True only when the operator has set the explicit opt-in flag. */
+export function isIntegrationOptIn() {
+    return process.env.MANYBOT_RUN_WHATSAPP_TESTS === "1";
+}
+export async function getIntegrationModeStatus() {
+    const cfg = await getTestConfig();
+    if (!isIntegrationOptIn()) {
+        return {
+            ready: false,
+            reason: `MANYBOT_RUN_WHATSAPP_TESTS=1 is required to enable integration mode`,
+            chat: cfg.chat,
+            source: cfg.source,
+        };
+    }
+    if (cfg.chat === null) {
+        return {
+            ready: false,
+            reason: cfg.skipReason,
+            chat: null,
+            source: null,
+        };
+    }
+    return { ready: true, reason: null, chat: cfg.chat, source: cfg.source };
+}
+/**
+ * Hard version: throws if integration mode is not fully ready. Use
+ * this at the entry point of every test that touches the real bot.
+ */
+export async function requireIntegrationMode() {
+    if (!isIntegrationOptIn()) {
+        throw new Error(`[integrationMode] cannot run: MANYBOT_RUN_WHATSAPP_TESTS=1 is required. ` +
+            `Set it explicitly to opt in to the real-WhatsApp test suite.`);
+    }
+    const cfg = await requireTestConfig();
+    logger.info(`[integrationMode] enabled — chat=${cfg.chat} source=${cfg.source}`);
+    return { chat: cfg.chat, source: cfg.source };
+}
+/** Absolute path of the integration plugin's source directory. */
+export function getIntegrationPluginDir() {
+    return INTEGRATION_PLUGIN_DIR;
+}

package/dist/kernel/integrationMode.test.js

@@ -0,0 +1,95 @@
+import test, { describe, before, after, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+const configDir = await fs.mkdtemp(path.join(os.tmpdir(), "manybot-integration-mode-"));
+process.env.MANYBOT_CONFIG_DIR = configDir;
+const { getIntegrationModeStatus, requireIntegrationMode, isIntegrationOptIn, INTEGRATION_PLUGIN_NAME, getIntegrationPluginDir, } = await import("#kernel/integrationMode.js");
+const { _resetTestConfigForTests, TEST_CHAT_ENV, RUN_WHATSAPP_TESTS_ENV, } = await import("#kernel/testConfig.js");
+const tomlPath = path.join(configDir, "manybot.toml");
+function clearEnv() {
+    delete process.env[TEST_CHAT_ENV];
+    delete process.env[RUN_WHATSAPP_TESTS_ENV];
+    delete process.env.MANYBOT_RUN_WHATSAPP_TESTS;
+}
+before(async () => {
+    await fs.writeFile(tomlPath, "", "utf8");
+});
+beforeEach(async () => {
+    clearEnv();
+    await fs.writeFile(tomlPath, "", "utf8");
+    _resetTestConfigForTests();
+});
+after(async () => {
+    clearEnv();
+    await fs.rm(configDir, { recursive: true, force: true });
+});
+describe("kernel/integrationMode — isIntegrationOptIn", () => {
+    test("false when env is unset", () => {
+        assert.equal(isIntegrationOptIn(), false);
+    });
+    test("false when env is anything other than '1'", () => {
+        process.env.MANYBOT_RUN_WHATSAPP_TESTS = "true";
+        assert.equal(isIntegrationOptIn(), false);
+        process.env.MANYBOT_RUN_WHATSAPP_TESTS = "0";
+        assert.equal(isIntegrationOptIn(), false);
+    });
+    test("true only when env equals '1'", () => {
+        process.env.MANYBOT_RUN_WHATSAPP_TESTS = "1";
+        assert.equal(isIntegrationOptIn(), true);
+    });
+});
+describe("kernel/integrationMode — getIntegrationModeStatus", () => {
+    test("not ready when opt-in is missing (even with TEST_CHAT set)", async () => {
+        process.env[TEST_CHAT_ENV] = "5516000000001";
+        const status = await getIntegrationModeStatus();
+        assert.equal(status.ready, false);
+        assert.match(status.reason, /MANYBOT_RUN_WHATSAPP_TESTS=1/);
+        assert.equal(status.chat, "5516000000001@s.whatsapp.net");
+    });
+    test("not ready when TEST_CHAT is missing (even with opt-in)", async () => {
+        process.env.MANYBOT_RUN_WHATSAPP_TESTS = "1";
+        const status = await getIntegrationModeStatus();
+        assert.equal(status.ready, false);
+        assert.match(status.reason, /TEST_CHAT is not set/);
+        assert.equal(status.chat, null);
+    });
+    test("ready only when both opt-in and TEST_CHAT are configured", async () => {
+        process.env[TEST_CHAT_ENV] = "5516000000002";
+        process.env.MANYBOT_RUN_WHATSAPP_TESTS = "1";
+        const status = await getIntegrationModeStatus();
+        assert.equal(status.ready, true);
+        assert.equal(status.reason, null);
+        assert.equal(status.chat, "5516000000002@s.whatsapp.net");
+        assert.equal(status.source, "env");
+    });
+});
+describe("kernel/integrationMode — requireIntegrationMode", () => {
+    test("returns chat and source when ready", async () => {
+        process.env[TEST_CHAT_ENV] = "5516000000003";
+        process.env.MANYBOT_RUN_WHATSAPP_TESTS = "1";
+        const res = await requireIntegrationMode();
+        assert.equal(res.chat, "5516000000003@s.whatsapp.net");
+        assert.equal(res.source, "env");
+    });
+    test("throws when opt-in is missing", async () => {
+        process.env[TEST_CHAT_ENV] = "5516000000004";
+        await assert.rejects(requireIntegrationMode(), /MANYBOT_RUN_WHATSAPP_TESTS=1/);
+    });
+    test("throws when TEST_CHAT is missing", async () => {
+        process.env.MANYBOT_RUN_WHATSAPP_TESTS = "1";
+        await assert.rejects(requireIntegrationMode(), /TEST_CHAT is not set/);
+    });
+});
+describe("kernel/integrationMode — constants", () => {
+    test("integration plugin name is reserved (double-underscore)", () => {
+        assert.equal(INTEGRATION_PLUGIN_NAME, "__manybot_integration__");
+        assert.ok(INTEGRATION_PLUGIN_NAME.startsWith("__"));
+        assert.ok(INTEGRATION_PLUGIN_NAME.endsWith("__"));
+    });
+    test("integration plugin dir resolves under src/plugins/", () => {
+        const dir = getIntegrationPluginDir();
+        assert.ok(dir.endsWith(path.join("src", "plugins", "__manybot_integration__")));
+    });
+});

package/dist/kernel/loadIntegrationPlugin.test.js

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict";
+import { after, beforeEach, describe, test } from "node:test";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+const configDir = await fs.mkdtemp(path.join(os.tmpdir(), "manybot-integration-loader-"));
+process.env.MANYBOT_CONFIG_DIR = configDir;
+const { loadIntegrationPlugin, pluginRegistry, cleanupPlugins, } = await import("#kernel/pluginLoader.js");
+const { INTEGRATION_PLUGIN_NAME } = await import("#kernel/integrationMode.js");
+const ORIGINAL_OPT_IN = process.env.MANYBOT_RUN_WHATSAPP_TESTS;
+beforeEach(async () => {
+    await cleanupPlugins();
+    pluginRegistry.clear();
+    // Force-clear and re-apply the opt-in between tests; each test sets
+    // it explicitly so we know what the contract looks like.
+    delete process.env.MANYBOT_RUN_WHATSAPP_TESTS;
+});
+after(async () => {
+    await cleanupPlugins();
+    pluginRegistry.clear();
+    if (ORIGINAL_OPT_IN === undefined)
+        delete process.env.MANYBOT_RUN_WHATSAPP_TESTS;
+    else
+        process.env.MANYBOT_RUN_WHATSAPP_TESTS = ORIGINAL_OPT_IN;
+    await fs.rm(configDir, { recursive: true, force: true });
+});
+describe("kernel/pluginLoader — loadIntegrationPlugin", () => {
+    test("refuses to load without the opt-in flag", async () => {
+        // opt-in explicitly NOT set
+        await assert.rejects(loadIntegrationPlugin(), /MANYBOT_RUN_WHATSAPP_TESTS=1/);
+        assert.equal(pluginRegistry.has(INTEGRATION_PLUGIN_NAME), false);
+    });
+    test("registers the integration plugin when opt-in is set", async () => {
+        process.env.MANYBOT_RUN_WHATSAPP_TESTS = "1";
+        const entry = await loadIntegrationPlugin();
+        assert.equal(entry.name, INTEGRATION_PLUGIN_NAME);
+        assert.equal(entry.status, "active");
+        assert.equal(typeof entry.run, "function");
+        assert.equal(entry.commands, null, "integration plugin must not register user commands");
+        assert.ok(pluginRegistry.has(INTEGRATION_PLUGIN_NAME));
+    });
+    test("is idempotent — second call returns the same entry without re-importing", async () => {
+        process.env.MANYBOT_RUN_WHATSAPP_TESTS = "1";
+        const first = await loadIntegrationPlugin();
+        const second = await loadIntegrationPlugin();
+        assert.equal(first, second);
+        // Single registration, no duplicate.
+        assert.equal(pluginRegistry.size, 1);
+    });
+    test("exports a public API object via plugin.exports", async () => {
+        process.env.MANYBOT_RUN_WHATSAPP_TESTS = "1";
+        const entry = await loadIntegrationPlugin();
+        const api = entry.exports;
+        assert.ok(api, "integration plugin must expose a public API");
+        assert.equal(typeof api.isTestChat, "function");
+        assert.equal(typeof api.waitForMarker, "function");
+        assert.equal(typeof api.recentBodies, "function");
+        // testChat is populated in setup(), not on registration.
+        assert.equal(api.testChat, "");
+    });
+    test("loads the plugin from the source path shipped with the repo", async () => {
+        process.env.MANYBOT_RUN_WHATSAPP_TESTS = "1";
+        const entry = await loadIntegrationPlugin();
+        // The plugin must be the real one (default export present).
+        assert.equal(typeof entry.run, "function");
+    });
+});