@manybot/manybot 5.7.0 → 5.9.0

package/dist/kernel/runCommand.test.js

@@ -0,0 +1,497 @@
+import test, { describe, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { resolveDispatch, runCommand, renderUsage } from "#kernel/runCommand.js";
+import { buildCommandRegistry, __setRegistryForTests } from "#kernel/commandRegistry.js";
+import { pluginRegistry } from "#kernel/pluginLoader.js";
+import { STOP_CHAIN } from "#kernel/commandsConfig.js";
+import { buildSettingsApi } from "#kernel/settingsDb.js";
+import { CONFIG } from "#config";
+// Pin the "no override" global language independently of whatever
+// ~/.manybot/manybot.toml happens to say on the machine running the
+// suite — CONFIG.LANGUAGE is read from the real config dir unless
+// MANYBOT_CONFIG_DIR is set, and i18n's `currentLang` locks in on the
+// first t()/tFor() call, so this must run before any test does.
+CONFIG.LANGUAGE = "en";
+function emptySpec(overrides) {
+    return {
+        id: overrides.id ?? "todo::add",
+        cmd: overrides.cmd ?? "todo",
+        aliases: overrides.aliases ?? [],
+        plugin: overrides.plugin ?? "todoPlugin",
+        functions: overrides.functions ?? ["addFn"],
+        loading: overrides.loading ?? null,
+        text: overrides.text ?? null,
+        desc: overrides.desc ?? null,
+        category: overrides.category ?? null,
+        group: overrides.group ?? null,
+        manual: overrides.manual ?? null,
+        deprecatedMessage: overrides.deprecatedMessage ?? null,
+        notifyChanges: overrides.notifyChanges ?? null,
+        permissions: overrides.permissions ?? null,
+        messages: overrides.messages ?? null,
+        arguments: overrides.arguments ?? [],
+        subcommands: overrides.subcommands ?? [],
+    };
+}
+function emptySub(overrides) {
+    return {
+        id: overrides.id ?? "todo::list",
+        cmd: overrides.cmd ?? "list",
+        aliases: overrides.aliases ?? [],
+        functions: overrides.functions ?? null,
+        loading: overrides.loading ?? null,
+        desc: overrides.desc ?? null,
+        manual: overrides.manual ?? null,
+        arguments: overrides.arguments ?? [],
+        permissions: overrides.permissions ?? null,
+        messages: overrides.messages ?? null,
+    };
+}
+let addCalls = [];
+let listCalls = [];
+function registerTodoPlugin() {
+    addCalls = [];
+    listCalls = [];
+    const plugin = {
+        name: "todoPlugin",
+        status: "active",
+        run: null,
+        setup: null,
+        exports: {},
+        error: null,
+        guardOptions: {},
+        commands: {
+            addFn: {
+                cmd: "todo",
+                aliases: [],
+                handler: async (ctx, input) => {
+                    addCalls.push({ ctx, input });
+                },
+            },
+            listFn: {
+                cmd: "list",
+                aliases: [],
+                handler: async (ctx, input) => {
+                    listCalls.push({ ctx, input });
+                },
+            },
+            crashFn: {
+                cmd: "crash",
+                aliases: [],
+                handler: async () => {
+                    throw new Error("boom");
+                },
+            },
+            gateFn: {
+                cmd: "gate",
+                aliases: [],
+                handler: async () => STOP_CHAIN,
+            },
+        },
+    };
+    pluginRegistry.set("todoPlugin", plugin);
+}
+function fakeCtx(overrides = {}) {
+    return {
+        chat: {
+            isGroup: overrides.isGroup ?? true,
+            id: "chat1@g.us",
+            isSenderAdmin: async () => true,
+            isBotAdmin: async () => true,
+        },
+        msg: {
+            sender: overrides.sender ?? "5511999999999@s.whatsapp.net",
+        },
+    };
+}
+function buildRegistry(specs) {
+    return buildCommandRegistry(specs, pluginRegistry);
+}
+describe("kernel/runCommand", () => {
+    beforeEach(() => {
+        registerTodoPlugin();
+    });
+    afterEach(() => {
+        pluginRegistry.delete("todoPlugin");
+        __setRegistryForTests(null);
+    });
+    test("resolveDispatch: kind none when registry is empty", () => {
+        __setRegistryForTests(buildCommandRegistry([], new Map()));
+        const { target } = resolveDispatch("todo", "");
+        assert.equal(target.kind, "none");
+    });
+    test("resolveDispatch: kind parent when no subcommands declared", () => {
+        __setRegistryForTests(buildRegistry([emptySpec({})]));
+        const { target } = resolveDispatch("todo", "buy milk");
+        assert.equal(target.kind, "parent");
+        if (target.kind === "parent") {
+            assert.deepEqual(target.args, ["buy", "milk"]);
+        }
+    });
+    test("resolveDispatch: kind sub when a declared subcommand token matches", () => {
+        const spec = emptySpec({ subcommands: [emptySub({ functions: ["listFn"] })] });
+        __setRegistryForTests(buildRegistry([spec]));
+        const { target } = resolveDispatch("todo", "list");
+        assert.equal(target.kind, "sub");
+        if (target.kind === "sub") {
+            assert.equal(target.sub.function, "listFn");
+        }
+    });
+    test("resolveDispatch: unmatchedSubToken falls through to parent", () => {
+        const spec = emptySpec({ subcommands: [emptySub({ functions: ["listFn"] })] });
+        __setRegistryForTests(buildRegistry([spec]));
+        const { target, unmatchedSubToken } = resolveDispatch("todo", "wat now");
+        assert.equal(target.kind, "parent");
+        assert.equal(unmatchedSubToken, "wat");
+    });
+    test("runCommand: executes the parent handler and passes args through", async () => {
+        __setRegistryForTests(buildRegistry([emptySpec({})]));
+        const resolution = resolveDispatch("todo", "buy milk");
+        const replies = [];
+        const result = await runCommand({
+            pluginName: "todoPlugin",
+            ctx: fakeCtx(),
+            resolution,
+            reply: { text: (t) => replies.push(t) },
+        });
+        assert.equal(result.status, "executed");
+        assert.equal(addCalls.length, 1);
+        assert.deepEqual(addCalls[0].input, { args: ["buy", "milk"], subcommand: undefined });
+        assert.equal(replies.length, 0);
+    });
+    test("runCommand: routes to the subcommand handler, not the parent's", async () => {
+        const spec = emptySpec({ subcommands: [emptySub({ functions: ["listFn"] })] });
+        __setRegistryForTests(buildRegistry([spec]));
+        const resolution = resolveDispatch("todo", "list");
+        const result = await runCommand({
+            pluginName: "todoPlugin",
+            ctx: fakeCtx(),
+            resolution,
+            reply: { text: () => { } },
+        });
+        assert.equal(result.status, "executed");
+        assert.equal(listCalls.length, 1);
+        assert.equal(addCalls.length, 0);
+    });
+    test("runCommand: unmatchedSubToken replies with a usage hint and does not dispatch", async () => {
+        const spec = emptySpec({ subcommands: [emptySub({ functions: ["listFn"] })] });
+        __setRegistryForTests(buildRegistry([spec]));
+        const resolution = resolveDispatch("todo", "wat");
+        const replies = [];
+        const result = await runCommand({
+            pluginName: "todoPlugin",
+            ctx: fakeCtx(),
+            resolution,
+            reply: { text: (t) => replies.push(t) },
+        });
+        assert.equal(result.status, "unknown_sub");
+        assert.equal(addCalls.length, 0);
+        assert.equal(replies.length, 1);
+    });
+    test("runCommand: denies on scope mismatch and does not dispatch", async () => {
+        const spec = emptySpec({ permissions: { scope: "group" } });
+        __setRegistryForTests(buildRegistry([spec]));
+        const resolution = resolveDispatch("todo", "buy milk");
+        const result = await runCommand({
+            pluginName: "todoPlugin",
+            ctx: fakeCtx({ isGroup: false }),
+            resolution,
+            reply: { text: () => { } },
+        });
+        assert.equal(result.status, "permission_denied");
+        assert.equal(addCalls.length, 0);
+    });
+    test("runCommand: rejects when a required argument is missing", async () => {
+        const spec = emptySpec({ arguments: [{ name: "item", type: "quoted_text", required: true }] });
+        __setRegistryForTests(buildRegistry([spec]));
+        const resolution = resolveDispatch("todo", "");
+        const result = await runCommand({
+            pluginName: "todoPlugin",
+            ctx: fakeCtx(),
+            resolution,
+            reply: { text: () => { } },
+        });
+        assert.equal(result.status, "argument_missing");
+        assert.equal(addCalls.length, 0);
+    });
+    test("runCommand: re-throws on handler crash after firing the alert", async () => {
+        const spec = emptySpec({ id: "todo::crash", cmd: "crashcmd", functions: ["crashFn"] });
+        __setRegistryForTests(buildRegistry([spec]));
+        const resolution = resolveDispatch("crashcmd", "");
+        await assert.rejects(() => runCommand({
+            pluginName: "todoPlugin",
+            ctx: fakeCtx(),
+            resolution,
+            reply: { text: () => { } },
+        }), /boom/);
+    });
+    test("resolveDispatch: kind none for an unknown invocation", () => {
+        __setRegistryForTests(buildRegistry([emptySpec({})]));
+        const { target } = resolveDispatch("nope", "");
+        assert.equal(target.kind, "none");
+    });
+    test("renderUsage: builds a usage line from declared arguments", () => {
+        const spec = emptySpec({
+            arguments: [
+                { name: "item", type: "quoted_text", required: true },
+                { name: "priority", type: "choice", choices: ["low", "high"], required: false },
+            ],
+        });
+        __setRegistryForTests(buildRegistry([spec]));
+        const { target } = resolveDispatch("todo", "");
+        const usage = renderUsage(target);
+        assert.match(usage, /^!todo /);
+        assert.match(usage, /"<text>"/);
+        assert.match(usage, /\[--priority=<low\|high>\]/);
+    });
+    test("renderUsage: empty string for a none target", () => {
+        const usage = renderUsage({ kind: "none" });
+        assert.equal(usage, "");
+    });
+    test("renderUsage: accepts a prefix override", () => {
+        const spec = emptySpec({
+            arguments: [{ name: "item", type: "quoted_text", required: true }],
+        });
+        __setRegistryForTests(buildRegistry([spec]));
+        const { target } = resolveDispatch("todo", "");
+        const usage = renderUsage(target, "#");
+        assert.match(usage, /^#todo /);
+    });
+    describe("per-chat overrides (prefix / language via !config)", () => {
+        const overrideChatId = "5511988887777@c.us"; // already-normalized form
+        beforeEach(() => {
+            buildSettingsApi("core", overrideChatId).deleteAll();
+        });
+        afterEach(() => {
+            buildSettingsApi("core", overrideChatId).deleteAll();
+        });
+        test("missing-argument usage message uses the chat's saved prefix override", async () => {
+            buildSettingsApi("core", overrideChatId).set("chat_prefix", "#");
+            const spec = emptySpec({ arguments: [{ name: "item", type: "quoted_text", required: true }] });
+            __setRegistryForTests(buildRegistry([spec]));
+            const resolution = resolveDispatch("todo", "");
+            const replies = [];
+            const result = await runCommand({
+                pluginName: "todoPlugin",
+                ctx: fakeCtx(),
+                resolution,
+                reply: { text: (t) => replies.push(t) },
+                chatId: overrideChatId,
+            });
+            assert.equal(result.status, "argument_missing");
+            assert.match(replies[0], /#todo/, "usage line should use the chat's saved prefix, not the global one");
+        });
+        test("missing-argument usage message falls back to the global prefix when no override is set", async () => {
+            const spec = emptySpec({ arguments: [{ name: "item", type: "quoted_text", required: true }] });
+            __setRegistryForTests(buildRegistry([spec]));
+            const resolution = resolveDispatch("todo", "");
+            const replies = [];
+            await runCommand({
+                pluginName: "todoPlugin",
+                ctx: fakeCtx(),
+                resolution,
+                reply: { text: (t) => replies.push(t) },
+                chatId: overrideChatId,
+            });
+            assert.match(replies[0], /!todo/);
+        });
+        test("unknown-subcommand message uses the chat's saved language override", async () => {
+            buildSettingsApi("core", overrideChatId).set("chat_locale", "pt");
+            const spec = emptySpec({ subcommands: [emptySub({ functions: ["listFn"] })] });
+            __setRegistryForTests(buildRegistry([spec]));
+            const resolution = resolveDispatch("todo", "wat");
+            const replies = [];
+            await runCommand({
+                pluginName: "todoPlugin",
+                ctx: fakeCtx(),
+                resolution,
+                reply: { text: (t) => replies.push(t) },
+                chatId: overrideChatId,
+            });
+            assert.match(replies[0], /Subcomando "wat" desconhecido/);
+        });
+        test("unknown-subcommand message falls back to the global language when no override is set", async () => {
+            const spec = emptySpec({ subcommands: [emptySub({ functions: ["listFn"] })] });
+            __setRegistryForTests(buildRegistry([spec]));
+            const resolution = resolveDispatch("todo", "wat");
+            const replies = [];
+            await runCommand({
+                pluginName: "todoPlugin",
+                ctx: fakeCtx(),
+                resolution,
+                reply: { text: (t) => replies.push(t) },
+                chatId: overrideChatId,
+            });
+            assert.match(replies[0], /Unknown subcommand "wat"/);
+        });
+        test("omitting chatId behaves exactly like an unset override (backward compatible)", async () => {
+            const spec = emptySpec({ arguments: [{ name: "item", type: "quoted_text", required: true }] });
+            __setRegistryForTests(buildRegistry([spec]));
+            const resolution = resolveDispatch("todo", "");
+            const replies = [];
+            const result = await runCommand({
+                pluginName: "todoPlugin",
+                ctx: fakeCtx(),
+                resolution,
+                reply: { text: (t) => replies.push(t) },
+            });
+            assert.equal(result.status, "argument_missing");
+            assert.match(replies[0], /!todo/);
+        });
+    });
+    describe("functions: chain + STOP_CHAIN", () => {
+        test("runs every function in the chain in declared order", async () => {
+            let second = false;
+            let third = false;
+            const plugin = {
+                name: "chainPlugin",
+                status: "active",
+                run: null,
+                setup: null,
+                exports: {},
+                error: null,
+                guardOptions: {},
+                commands: {
+                    firstFn: { cmd: "todo", aliases: [], handler: async () => { second = true; } },
+                    secondFn: { cmd: "todo", aliases: [], handler: async () => {
+                            assert.equal(second, true, "second handler ran before first finished");
+                            third = true;
+                        } },
+                    thirdFn: { cmd: "todo", aliases: [], handler: async () => {
+                            assert.equal(third, true, "third handler ran before second finished");
+                        } },
+                },
+            };
+            pluginRegistry.set("chainPlugin", plugin);
+            const specs = [
+                {
+                    id: "chainPlugin::firstFn",
+                    cmd: "chain",
+                    aliases: [],
+                    plugin: "chainPlugin",
+                    functions: ["firstFn", "secondFn", "thirdFn"],
+                    loading: null,
+                    text: null,
+                    desc: null,
+                    category: null,
+                    group: null,
+                    manual: null,
+                    deprecatedMessage: null,
+                    notifyChanges: null,
+                    permissions: null,
+                    messages: null,
+                    arguments: [],
+                    subcommands: [],
+                },
+            ];
+            __setRegistryForTests(buildCommandRegistry(specs, pluginRegistry));
+            const resolution = resolveDispatch("chain", "");
+            const result = await runCommand({
+                pluginName: "chainPlugin",
+                ctx: fakeCtx(),
+                resolution,
+                reply: { text: () => { } },
+            });
+            assert.equal(result.status, "executed");
+            assert.equal(third, true);
+            pluginRegistry.delete("chainPlugin");
+        });
+        test("STOP_CHAIN short-circuits the rest of the chain", async () => {
+            let secondRan = false;
+            const plugin = {
+                name: "stopPlugin",
+                status: "active",
+                run: null,
+                setup: null,
+                exports: {},
+                error: null,
+                guardOptions: {},
+                commands: {
+                    firstFn: { cmd: "stop", aliases: [], handler: async () => STOP_CHAIN },
+                    secondFn: { cmd: "stop", aliases: [], handler: async () => { secondRan = true; } },
+                },
+            };
+            pluginRegistry.set("stopPlugin", plugin);
+            const specs = [
+                {
+                    id: "stopPlugin::firstFn",
+                    cmd: "stop",
+                    aliases: [],
+                    plugin: "stopPlugin",
+                    functions: ["firstFn", "secondFn"],
+                    loading: null,
+                    text: null,
+                    desc: null,
+                    category: null,
+                    group: null,
+                    manual: null,
+                    deprecatedMessage: null,
+                    notifyChanges: null,
+                    permissions: null,
+                    messages: null,
+                    arguments: [],
+                    subcommands: [],
+                },
+            ];
+            __setRegistryForTests(buildCommandRegistry(specs, pluginRegistry));
+            const resolution = resolveDispatch("stop", "");
+            const result = await runCommand({
+                pluginName: "stopPlugin",
+                ctx: fakeCtx(),
+                resolution,
+                reply: { text: () => { } },
+            });
+            assert.equal(result.status, "executed");
+            assert.equal(secondRan, false);
+            pluginRegistry.delete("stopPlugin");
+        });
+        test("chain throw propagates and stops the chain", async () => {
+            let secondRan = false;
+            const plugin = {
+                name: "throwPlugin",
+                status: "active",
+                run: null,
+                setup: null,
+                exports: {},
+                error: null,
+                guardOptions: {},
+                commands: {
+                    firstFn: { cmd: "throw", aliases: [], handler: async () => { throw new Error("mid"); } },
+                    secondFn: { cmd: "throw", aliases: [], handler: async () => { secondRan = true; } },
+                },
+            };
+            pluginRegistry.set("throwPlugin", plugin);
+            const specs = [
+                {
+                    id: "throwPlugin::firstFn",
+                    cmd: "throw",
+                    aliases: [],
+                    plugin: "throwPlugin",
+                    functions: ["firstFn", "secondFn"],
+                    loading: null,
+                    text: null,
+                    desc: null,
+                    category: null,
+                    group: null,
+                    manual: null,
+                    deprecatedMessage: null,
+                    notifyChanges: null,
+                    permissions: null,
+                    messages: null,
+                    arguments: [],
+                    subcommands: [],
+                },
+            ];
+            __setRegistryForTests(buildCommandRegistry(specs, pluginRegistry));
+            const resolution = resolveDispatch("throw", "");
+            await assert.rejects(() => runCommand({
+                pluginName: "throwPlugin",
+                ctx: fakeCtx(),
+                resolution,
+                reply: { text: () => { } },
+            }), /mid/);
+            assert.equal(secondRan, false);
+            pluginRegistry.delete("throwPlugin");
+        });
+    });
+});

package/dist/kernel/sendFallbackGuard.js

@@ -24,11 +24,6 @@ import { waitForSendSlot } from "./sendGuard.js";
 import { getDriverManager } from "./driverManager.js";
 import { fireAlert } from "./alerts.js";
 const sleep = (ms) => new Promise(r => setTimeout(r, ms));
-/**
- * Thrown by sendWithFallback when the message could not be delivered
- * through any available driver. `reason` distinguishes between
- * "primary failed and no secondary was available" vs "both failed".
- */
 export class SendFailedError extends Error {
     jid;
     driver;
@@ -42,44 +37,25 @@ export class SendFailedError extends Error {
     }
 }
 /**
- * Try the active driver, then the other one if the active one failed to
- * confirm the send. Honors `drivers.fallbackCooldownMs` (skip the active
- * if it's currently degraded) and uses `drivers.verifyWindowMs` to decide
- * how long to wait for confirmation before giving up on a given attempt.
+ * Try the active driver and verify the send. Honors `drivers.fallbackCooldownMs`
+ * (though with only one driver, degradation doesn't skip attempts) and uses
+ * `drivers.verifyWindowMs` to decide how long to wait for confirmation.
  *
  * Resolves with the SentMessageRef of the driver that actually delivered
- * the message. Rejects with SendFailedError if neither driver confirmed
- * the send (or if the only driver that could have been tried was the
- * active one and it wasn't ready).
+ * the message. Rejects with SendFailedError with reason "no_fallback" if the
+ * send could not be confirmed.
  */
 export async function sendWithFallback(jid, text, opts = {}) {
     const dm = getDriverManager();
     const drivers = CONFIG.drivers;
     const primary = dm.active();
     const primaryKey = primary.name;
-    // if the primary is in cooldown, skip straight to the secondary
-    // (don't repeat the same failing call message after message). Same
-    // try/catch as the normal path so a failing secondary here also fires
-    // send_failed_both_drivers — observability stays consistent across
-    // the degraded and fresh-primary paths.
+    // Mark as not degraded before attempting (degradation only lasts for cooldown period)
+    // With only one driver, we don't actually skip attempts when degraded - we just track
+    // that the last attempt failed so we can alert appropriately
     if (dm.isDegraded(primaryKey)) {
-        const secondary = pickSecondary(dm, primaryKey);
-        if (secondary && secondary.isReady()) {
-            try {
-                return await sendVia(secondary, jid, text, opts, drivers.verifyWindowMs, /*skipGuard=*/ false);
-            }
-            catch (err) {
-                fireAlert("send_failed_both_drivers", { jid, primary: primaryKey, secondary: secondary.name, error: String(err) });
-                throw err;
-            }
-        }
-        logger.warn({ jid, primary: primaryKey }, "send skipped primary (degraded) and no fallback ready");
-        fireAlert("send_failed_no_fallback", { jid, primary: primaryKey });
-        throw new SendFailedError(jid, primaryKey, "no_fallback");
+        logger.debug({ driver: primaryKey }, "driver in degradation period but attempting send anyway (single driver mode)");
     }
-    // Normal path: try primary, verify, fall back if verification fails.
-    // waitForSendSlot is the same throttle the rest of the senders use
-    // (fallback must respect rate-limit too).
     await waitForSendSlot(jid, { cooldown: true, jitter: true });
     let primaryRef = null;
     let primarySendFailed = false;
@@ -89,28 +65,23 @@ export async function sendWithFallback(jid, text, opts = {}) {
     catch (err) {
         primarySendFailed = true;
         logger.warn({ driver: primaryKey, jid, error: String(err) }, "send threw on primary");
+        dm.markDegraded(primaryKey, drivers.fallbackCooldownMs);
+        fireAlert("send_failed_no_fallback", { jid, primary: primaryKey });
+        throw new SendFailedError(jid, primaryKey, "no_fallback");
     }
     if (!primarySendFailed) {
         if (await verifyDelivery(primary, jid, primaryRef, drivers.verifyWindowMs)) {
+            // Successful send - clear any degradation state
+            dm.clearDegraded(primaryKey);
             return primaryRef;
         }
         logger.warn({ driver: primaryKey, jid, messageId: primaryRef.id }, "send not confirmed by primary");
-    }
-    dm.markDegraded(primaryKey, drivers.fallbackCooldownMs);
-    const secondary = pickSecondary(dm, primaryKey);
-    if (!secondary || !secondary.isReady()) {
+        dm.markDegraded(primaryKey, drivers.fallbackCooldownMs);
         fireAlert("send_failed_no_fallback", { jid, primary: primaryKey });
         throw new SendFailedError(jid, primaryKey, "no_fallback");
     }
-    try {
-        const fallbackRef = await sendVia(secondary, jid, text, opts, drivers.verifyWindowMs, /*skipGuard=*/ true);
-        logger.info({ driver: secondary.name, jid, messageId: fallbackRef.id, reason: primarySendFailed ? "send threw" : "primary verification failed" }, "message sent via fallback");
-        return fallbackRef;
-    }
-    catch (err) {
-        fireAlert("send_failed_both_drivers", { jid, primary: primaryKey, secondary: secondary.name, error: String(err) });
-        throw err;
-    }
+    // Should not reach here
+    throw new SendFailedError(jid, primaryKey, "no_fallback");
 }
 /**
  * Send through a specific driver and verify the result. Throws if the
@@ -178,6 +149,6 @@ async function historyContains(driver, jid, ref) {
     return history.some(m => m.fromMe && m.id === ref.id);
 }
 function pickSecondary(dm, primaryKey) {
-    const other = primaryKey === "baileys" ? "whatsmeow" : "baileys";
-    return dm.get(other);
+    // Currently Baileys is the only supported driver; returns undefined unless a test registers a secondary
+    return dm.get(primaryKey === "baileys" ? "secondary" : "baileys");
 }