@manybot/manybot 5.6.1 → 5.8.0

package/dist/kernel/commandMenu.test.js

@@ -0,0 +1,234 @@
+import test, { describe } from "node:test";
+import assert from "node:assert/strict";
+import { resolveLocalizedString, renderOverview, renderCategory, renderManual, handleMenuCommand, checkAndTriggerWelcomeMessage } from "#kernel/commandMenu.js";
+import { buildCommandRegistry } from "#kernel/commandRegistry.js";
+import { buildSettingsApi } from "#kernel/settingsDb.js";
+function createTestRegistry() {
+    const plugins = new Map([
+        [
+            "utilPlugin",
+            {
+                name: "utilPlugin",
+                status: "active",
+                manifest: { name: "utilPlugin", version: "1.0.0" },
+                commands: {
+                    pingFn: {
+                        cmd: "ping",
+                        aliases: ["p"],
+                        desc: { pt: "Testa a latência", en: "Tests latency" },
+                        category: "utils",
+                        manual: "Uso: !ping",
+                    },
+                    infoFn: {
+                        cmd: "info",
+                        aliases: [],
+                        desc: "Informações do bot",
+                        category: "utils",
+                    },
+                    adminCmd: {
+                        cmd: "adminonly",
+                        aliases: [],
+                        desc: "Comando restrito",
+                        category: "adminCat",
+                    },
+                },
+            },
+        ],
+    ]);
+    const categories = {
+        utils: { label: { pt: "Utilitários", en: "Utilities" }, order: 1 },
+        adminCat: { label: { pt: "Administração", en: "Administration" }, order: 2, scope: "group" },
+    };
+    const menu = {
+        title: "ManyBot — Menu",
+        intro: "Help menu",
+        footer: "Footer text",
+        cmd: "help",
+        aliases: ["help", "menu"],
+        notFoundFallback: false,
+        welcomeMessage: { pt: "Bem-vindo ao bot! Use {prefix}help para o menu.", en: "Welcome! Use {prefix}help." },
+        welcomeWindowDays: 3,
+        pageSize: 2,
+    };
+    return buildCommandRegistry(null, plugins, undefined, menu, categories);
+}
+describe("kernel/commandMenu", () => {
+    describe("resolveLocalizedString", () => {
+        test("returns string directly if plain string", () => {
+            assert.equal(resolveLocalizedString("hello"), "hello");
+        });
+        test("resolves requested language from object map", () => {
+            const localized = { en: "Hello", pt: "Olá", es: "Hola" };
+            assert.equal(resolveLocalizedString(localized, "pt"), "Olá");
+            assert.equal(resolveLocalizedString(localized, "en"), "Hello");
+        });
+        test("falls back to en or first key if target language missing", () => {
+            const localized = { en: "English fallback", es: "Hola" };
+            assert.equal(resolveLocalizedString(localized, "fr"), "English fallback");
+        });
+        test("returns null for nullish inputs", () => {
+            assert.equal(resolveLocalizedString(null), null);
+            assert.equal(resolveLocalizedString(undefined), null);
+        });
+    });
+    describe("renderOverview", () => {
+        test("uses English built-in labels by default in tests", () => {
+            const registry = createTestRegistry();
+            const overview = renderOverview(registry, "en");
+            assert.match(overview, /Help menu/);
+        });
+        test("renders categorized menu overview", () => {
+            const registry = createTestRegistry();
+            const overview = renderOverview(registry, "pt");
+            assert.match(overview, /ManyBot — Menu/);
+            assert.match(overview, /📁 \*Utilitários\*/);
+            assert.match(overview, /!ping — Testa a latência/);
+            assert.match(overview, /!info — Informações do bot/);
+        });
+        test("filters out category when outside defined scope", () => {
+            const registry = createTestRegistry();
+            const overviewGroup = renderOverview(registry, "pt", undefined, "group");
+            assert.match(overviewGroup, /📁 \*Administração\*/);
+            const overviewDm = renderOverview(registry, "pt", undefined, "dm");
+            assert.doesNotMatch(overviewDm, /📁 \*Administração\*/);
+        });
+        test("handles flat command list with pagination", () => {
+            const plugins = new Map([
+                [
+                    "utilPlugin",
+                    {
+                        name: "utilPlugin",
+                        status: "active",
+                        manifest: { name: "utilPlugin", version: "1.0.0" },
+                        commands: {
+                            cmd1: { cmd: "c1", aliases: [], desc: "desc 1" },
+                            cmd2: { cmd: "c2", aliases: [], desc: "desc 2" },
+                            cmd3: { cmd: "c3", aliases: [], desc: "desc 3" },
+                        },
+                    },
+                ],
+            ]);
+            const menu = {
+                title: "Flat",
+                intro: null,
+                footer: null,
+                cmd: "help",
+                aliases: ["help"],
+                notFoundFallback: false,
+                welcomeMessage: null,
+                welcomeWindowDays: 3,
+                pageSize: 2,
+            };
+            const flatRegistry = buildCommandRegistry(null, plugins, undefined, menu, {});
+            const page1 = renderOverview(flatRegistry, "en", 1);
+            assert.match(page1, /!c1/);
+            assert.match(page1, /!c2/);
+            assert.doesNotMatch(page1, /!c3/);
+            const page2 = renderOverview(flatRegistry, "en", 2);
+            assert.match(page2, /!c3/);
+            assert.doesNotMatch(page2, /!c1/);
+        });
+    });
+    describe("renderCategory", () => {
+        test("renders commands under a specific category", () => {
+            const registry = createTestRegistry();
+            const output = renderCategory(registry, "utils", "pt");
+            assert.ok(output);
+            assert.match(output, /Categoria: Utilitários/);
+            assert.match(output, /!ping/);
+            assert.match(output, /!info/);
+        });
+        test("respects scope filtering in renderCategory", () => {
+            const registry = createTestRegistry();
+            const dmOutput = renderCategory(registry, "adminCat", "pt", "dm");
+            assert.equal(dmOutput, null);
+            const groupOutput = renderCategory(registry, "adminCat", "pt", "group");
+            assert.ok(groupOutput);
+            assert.match(groupOutput, /Categoria: Administração/);
+        });
+        test("returns null for unknown category", () => {
+            const registry = createTestRegistry();
+            assert.equal(renderCategory(registry, "unknown"), null);
+        });
+    });
+    describe("renderManual", () => {
+        test("renders command manual with aliases and description", () => {
+            const registry = createTestRegistry();
+            const entry = registry.byId.get("utilPlugin::pingFn");
+            const manual = renderManual(entry, registry, "pt");
+            assert.match(manual, /Manual: !ping/);
+            assert.match(manual, /\*Aliases:\* !p/);
+            assert.match(manual, /\*Categoria:\* Utilitários/);
+            assert.match(manual, /\*Descrição:\* Testa a latência/);
+            assert.match(manual, /Uso: !ping/);
+        });
+    });
+    describe("handleMenuCommand", () => {
+        test("shows overview when no args provided", () => {
+            const registry = createTestRegistry();
+            const result = handleMenuCommand("help", "", registry, "pt");
+            assert.match(result, /ManyBot — Menu/);
+        });
+        test("handles page number argument", () => {
+            const plugins = new Map([
+                [
+                    "utilPlugin",
+                    {
+                        name: "utilPlugin",
+                        status: "active",
+                        manifest: { name: "utilPlugin", version: "1.0.0" },
+                        commands: {
+                            cmd1: { cmd: "c1", aliases: [] },
+                            cmd2: { cmd: "c2", aliases: [] },
+                            cmd3: { cmd: "c3", aliases: [] },
+                        },
+                    },
+                ],
+            ]);
+            const menu = {
+                title: null,
+                intro: null,
+                footer: null,
+                cmd: "help",
+                aliases: ["help"],
+                notFoundFallback: false,
+                welcomeMessage: null,
+                welcomeWindowDays: 3,
+                pageSize: 1,
+            };
+            const flatRegistry = buildCommandRegistry(null, plugins, undefined, menu, {});
+            const result = handleMenuCommand("help", "page 2", flatRegistry, "pt");
+            assert.match(result, /!c2/);
+            assert.doesNotMatch(result, /!c1/);
+        });
+        test("routes to category if arg matches category name", () => {
+            const registry = createTestRegistry();
+            const result = handleMenuCommand("help", "utils", registry, "pt");
+            assert.match(result, /Categoria: Utilitários/);
+        });
+        test("routes to manual if arg matches command invocation", () => {
+            const registry = createTestRegistry();
+            const result = handleMenuCommand("help", "ping", registry, "pt");
+            assert.match(result, /Manual: !ping/);
+        });
+        test("returns not found message for unknown query", () => {
+            const registry = createTestRegistry();
+            const result = handleMenuCommand("help", "nonexistent", registry, "pt");
+            assert.match(result, /nonexistent/);
+        });
+    });
+    describe("checkAndTriggerWelcomeMessage", () => {
+        test("triggers welcome message for new user and tracks seen timestamp", () => {
+            const registry = createTestRegistry();
+            const userId = "test_user_welcome_1";
+            const settings = buildSettingsApi("kernel", userId);
+            settings.delete("last_welcome_seen");
+            const msg = checkAndTriggerWelcomeMessage(userId, registry, "pt");
+            assert.ok(msg);
+            assert.match(msg, /Bem-vindo ao bot! Use !help para o menu\./);
+            // Immediately checking again returns null
+            const secondCheck = checkAndTriggerWelcomeMessage(userId, registry, "pt");
+            assert.equal(secondCheck, null);
+        });
+    });
+});

package/dist/kernel/commandPermissions.js

@@ -0,0 +1,125 @@
+/**
+ * commandPermissions.ts
+ *
+ * Permission engine for ManyBot commands.
+ * Checks owner, scope, blacklist, whitelist, botAdmin, admin, and cooldown.
+ *
+ * Order of evaluation:
+ *   1. owner
+ *   2. scope
+ *   3. blacklist
+ *   4. whitelist
+ *   5. botAdmin
+ *   6. admin
+ *   7. cooldown (only consumed if all prior checks pass)
+ */
+import { OWNER_NUMBER } from "#config";
+import { normalizeJid } from "#drivers/jid.js";
+const cooldownMap = new Map();
+export function clearCooldowns() {
+    cooldownMap.clear();
+}
+export function getCooldownMap() {
+    return cooldownMap;
+}
+export function matchId(targetId, candidate) {
+    if (!targetId || !candidate)
+        return false;
+    const normTarget = normalizeJid(targetId.trim());
+    const normCandidate = normalizeJid(candidate.trim());
+    if (normTarget === normCandidate)
+        return true;
+    const digitsTarget = targetId.replace(/\D/g, "");
+    const digitsCandidate = candidate.replace(/\D/g, "");
+    if (digitsTarget.length > 0 && digitsTarget === digitsCandidate) {
+        return true;
+    }
+    return false;
+}
+export function matchesAny(targetId, candidates) {
+    return candidates.some(candidate => matchId(targetId, candidate));
+}
+export async function checkPermission(entry, ctx) {
+    const perms = entry.permissions;
+    const msgs = perms.messages;
+    // 1. Owner check
+    if (perms.owner) {
+        if (!OWNER_NUMBER || !matchId(ctx.senderId, OWNER_NUMBER)) {
+            return { allowed: false, message: msgs.ownerOnly };
+        }
+    }
+    // 2. Scope check (group | dm | any)
+    if (perms.scope === "group" && !ctx.isGroup) {
+        return { allowed: false, message: msgs.wrongScope };
+    }
+    if (perms.scope === "dm" && ctx.isGroup) {
+        return { allowed: false, message: msgs.wrongScope };
+    }
+    // 3. Blacklist check
+    if (perms.blacklist) {
+        if (ctx.isGroup && perms.blacklist.groups.length > 0) {
+            if (matchesAny(ctx.chatId, perms.blacklist.groups)) {
+                return { allowed: false, message: msgs.wrongScope };
+            }
+        }
+        if (perms.blacklist.users.length > 0) {
+            if (matchesAny(ctx.senderId, perms.blacklist.users)) {
+                return { allowed: false, message: msgs.wrongScope };
+            }
+        }
+    }
+    // 4. Whitelist check (defined list and outside it -> deny)
+    if (perms.whitelist) {
+        const hasGroupList = perms.whitelist.groups.length > 0;
+        const hasUserList = perms.whitelist.users.length > 0;
+        if (ctx.isGroup && hasGroupList) {
+            if (!matchesAny(ctx.chatId, perms.whitelist.groups)) {
+                return { allowed: false, message: msgs.wrongScope };
+            }
+        }
+        else if (!ctx.isGroup && hasGroupList && !hasUserList) {
+            return { allowed: false, message: msgs.wrongScope };
+        }
+        if (hasUserList) {
+            if (!matchesAny(ctx.senderId, perms.whitelist.users)) {
+                return { allowed: false, message: msgs.wrongScope };
+            }
+        }
+    }
+    // 5. botAdmin check
+    if (perms.botAdmin) {
+        if (!ctx.isGroup) {
+            return { allowed: false, message: msgs.botNotAdmin };
+        }
+        const isBotAdmin = await ctx.isBotAdmin();
+        if (!isBotAdmin) {
+            return { allowed: false, message: msgs.botNotAdmin };
+        }
+    }
+    // 6. admin check
+    if (perms.admin) {
+        if (!ctx.isGroup) {
+            return { allowed: false, message: msgs.senderNotAdmin };
+        }
+        const isSenderAdmin = await ctx.isSenderAdmin();
+        if (!isSenderAdmin) {
+            return { allowed: false, message: msgs.senderNotAdmin };
+        }
+    }
+    // 7. Cooldown check (only consumed if all other checks pass)
+    if (perms.cooldownSeconds > 0) {
+        const key = `${entry.id}:${ctx.senderId}`;
+        const now = Date.now();
+        const lastUsed = cooldownMap.get(key) ?? 0;
+        const elapsedSeconds = (now - lastUsed) / 1000;
+        if (elapsedSeconds < perms.cooldownSeconds) {
+            const remaining = Math.ceil(perms.cooldownSeconds - elapsedSeconds);
+            const msg = msgs.cooldown
+                .replace(/\{\{seconds\}\}/g, String(remaining))
+                .replace(/\{\{time\}\}/g, String(remaining));
+            return { allowed: false, message: msg };
+        }
+        cooldownMap.set(key, now);
+    }
+    return { allowed: true };
+}

package/dist/kernel/commandPermissions.test.js

@@ -0,0 +1,159 @@
+import test, { describe } from "node:test";
+import assert from "node:assert/strict";
+import { checkPermission, clearCooldowns, matchId, matchesAny } from "./commandPermissions.js";
+import { resolvePermissions } from "./commandRegistry.js";
+function createMockContext(overrides) {
+    return {
+        isGroup: false,
+        chatId: "123456789@c.us",
+        senderId: "5511999999999@c.us",
+        isSenderAdmin: async () => false,
+        isBotAdmin: async () => false,
+        ...overrides,
+    };
+}
+function createMockEntry(specPerms, specMsgs, pluginPerms, defaultsPerms, defaultsMsgs) {
+    const permissions = resolvePermissions(specPerms, specMsgs, pluginPerms, defaultsPerms, defaultsMsgs);
+    return {
+        id: "test::command",
+        cmd: "test",
+        aliases: [],
+        desc: "Test command",
+        category: null,
+        group: null,
+        manual: null,
+        source: "plugin",
+        pluginName: "testPlugin",
+        function: null,
+        handler: async () => "ok",
+        text: null,
+        permissions,
+        arguments: [],
+        subcommands: {},
+        categoryHiddenInScope: null,
+    };
+}
+describe("commandPermissions", () => {
+    test("matching utilities (matchId, matchesAny)", () => {
+        assert.equal(matchId("5511999999999@c.us", "5511999999999"), true);
+        assert.equal(matchId("5511999999999@s.whatsapp.net", "5511999999999@c.us"), true);
+        assert.equal(matchId("5511999999999", "5511888888888"), false);
+        assert.equal(matchesAny("5511999999999@c.us", ["5511888888888", "5511999999999"]), true);
+        assert.equal(matchesAny("5511777777777@c.us", ["5511888888888", "5511999999999"]), false);
+    });
+    test("permission resolution hierarchy (yaml > plugin > defaults)", () => {
+        const entry = createMockEntry({ admin: true, cooldownSeconds: 10 }, { senderNotAdmin: "Admin only!" }, { admin: false, botAdmin: true }, { cooldownSeconds: 60 }, { senderNotAdmin: "Default admin msg", botNotAdmin: "Default bot admin msg" });
+        assert.equal(entry.permissions.admin, true); // yaml overrides plugin
+        assert.equal(entry.permissions.botAdmin, true); // from plugin
+        assert.equal(entry.permissions.cooldownSeconds, 10); // yaml overrides global default
+        assert.equal(entry.permissions.messages.senderNotAdmin, "Admin only!"); // yaml msg overrides default
+        assert.equal(entry.permissions.messages.botNotAdmin, "Default bot admin msg"); // fallback to global default msg
+    });
+    test("owner permission check", async () => {
+        const ownerEntry = createMockEntry({ owner: true }, { ownerOnly: "Only owner allowed" });
+        const nonOwnerCtx = createMockContext({ senderId: "5511888888888@c.us" });
+        // When OWNER_NUMBER is not set or sender does not match
+        const res = await checkPermission(ownerEntry, nonOwnerCtx);
+        assert.equal(res.allowed, false);
+        if (!res.allowed)
+            assert.equal(res.message, "Only owner allowed");
+    });
+    test("scope permission check", async () => {
+        const groupEntry = createMockEntry({ scope: "group" }, { wrongScope: "Group only" });
+        const dmEntry = createMockEntry({ scope: "dm" }, { wrongScope: "DM only" });
+        const dmCtx = createMockContext({ isGroup: false });
+        const groupCtx = createMockContext({ isGroup: true, chatId: "12036301234567890@g.us" });
+        const res1 = await checkPermission(groupEntry, dmCtx);
+        assert.equal(res1.allowed, false);
+        if (!res1.allowed)
+            assert.equal(res1.message, "Group only");
+        const res2 = await checkPermission(groupEntry, groupCtx);
+        assert.equal(res2.allowed, true);
+        const res3 = await checkPermission(dmEntry, groupCtx);
+        assert.equal(res3.allowed, false);
+        if (!res3.allowed)
+            assert.equal(res3.message, "DM only");
+        const res4 = await checkPermission(dmEntry, dmCtx);
+        assert.equal(res4.allowed, true);
+    });
+    test("blacklist check", async () => {
+        const entry = createMockEntry({
+            blacklist: {
+                groups: ["120363999999999999@g.us"],
+                users: ["5511888888888@c.us"],
+            },
+        });
+        const blacklistedUserCtx = createMockContext({ senderId: "5511888888888@c.us" });
+        const blacklistedGroupCtx = createMockContext({ isGroup: true, chatId: "120363999999999999@g.us" });
+        const allowedCtx = createMockContext({ senderId: "5511999999999@c.us" });
+        assert.equal((await checkPermission(entry, blacklistedUserCtx)).allowed, false);
+        assert.equal((await checkPermission(entry, blacklistedGroupCtx)).allowed, false);
+        assert.equal((await checkPermission(entry, allowedCtx)).allowed, true);
+    });
+    test("whitelist check", async () => {
+        const entry = createMockEntry({
+            whitelist: {
+                groups: ["120363111111111111@g.us"],
+                users: ["5511999999999@c.us"],
+            },
+        });
+        const whitelistedUserCtx = createMockContext({ senderId: "5511999999999@c.us" });
+        const unwhitelistedUserCtx = createMockContext({ senderId: "5511888888888@c.us" });
+        assert.equal((await checkPermission(entry, whitelistedUserCtx)).allowed, true);
+        assert.equal((await checkPermission(entry, unwhitelistedUserCtx)).allowed, false);
+    });
+    test("admin and botAdmin checks", async () => {
+        const adminEntry = createMockEntry({ admin: true }, { senderNotAdmin: "Need admin" });
+        const botAdminEntry = createMockEntry({ botAdmin: true }, { botNotAdmin: "Need bot admin" });
+        const nonAdminGroupCtx = createMockContext({
+            isGroup: true,
+            isSenderAdmin: async () => false,
+            isBotAdmin: async () => false,
+        });
+        const adminGroupCtx = createMockContext({
+            isGroup: true,
+            isSenderAdmin: async () => true,
+            isBotAdmin: async () => true,
+        });
+        const resAdmin = await checkPermission(adminEntry, nonAdminGroupCtx);
+        assert.equal(resAdmin.allowed, false);
+        if (!resAdmin.allowed)
+            assert.equal(resAdmin.message, "Need admin");
+        const resBotAdmin = await checkPermission(botAdminEntry, nonAdminGroupCtx);
+        assert.equal(resBotAdmin.allowed, false);
+        if (!resBotAdmin.allowed)
+            assert.equal(resBotAdmin.message, "Need bot admin");
+        assert.equal((await checkPermission(adminEntry, adminGroupCtx)).allowed, true);
+        assert.equal((await checkPermission(botAdminEntry, adminGroupCtx)).allowed, true);
+    });
+    test("cooldown check and state consumption", async () => {
+        clearCooldowns();
+        const entry = createMockEntry({ cooldownSeconds: 30 }, { cooldown: "Wait {{seconds}}s" });
+        const ctx = createMockContext({ senderId: "5511999999999@c.us" });
+        // First invocation passes and sets cooldown
+        const res1 = await checkPermission(entry, ctx);
+        assert.equal(res1.allowed, true);
+        // Immediate second invocation fails
+        const res2 = await checkPermission(entry, ctx);
+        assert.equal(res2.allowed, false);
+        if (!res2.allowed) {
+            assert.match(res2.message ?? "", /Wait 30s/);
+        }
+        // Resetting cooldown allows next call
+        clearCooldowns();
+        const res3 = await checkPermission(entry, ctx);
+        assert.equal(res3.allowed, true);
+    });
+    test("cooldown is NOT consumed when an earlier check fails", async () => {
+        clearCooldowns();
+        const entry = createMockEntry({ scope: "group", cooldownSeconds: 30 }, { wrongScope: "Group only" });
+        const dmCtx = createMockContext({ isGroup: false });
+        // Scope check fails
+        const res1 = await checkPermission(entry, dmCtx);
+        assert.equal(res1.allowed, false);
+        // Now test in group context — first group call should pass because cooldown was never recorded
+        const groupCtx = createMockContext({ isGroup: true, chatId: "120363111@g.us" });
+        const res2 = await checkPermission(entry, groupCtx);
+        assert.equal(res2.allowed, true);
+    });
+});