@manybot/manybot 5.7.0 → 5.9.0

package/dist/kernel/commandDeprecation.test.js

@@ -0,0 +1,114 @@
+import test, { describe } from "node:test";
+import assert from "node:assert/strict";
+import { syncCommandHistory, getActiveDeprecation, formatDeprecationMessage } from "#kernel/commandDeprecation.js";
+function createMockEntry(id, cmd) {
+    return {
+        id,
+        cmd,
+        aliases: [],
+        desc: null,
+        category: null,
+        group: null,
+        manual: null,
+        source: "plugin",
+        pluginName: "testPlugin",
+        function: null,
+        functions: [],
+        loading: null,
+        handler: null,
+        text: null,
+        permissions: {
+            admin: false,
+            botAdmin: false,
+            scope: "any",
+            owner: false,
+            cooldownSeconds: 0,
+            whitelist: null,
+            blacklist: null,
+            dono: null,
+            allowedChats: null,
+            hiddenOutsideScope: null,
+            messages: {},
+        },
+        arguments: [],
+        subcommands: {},
+        categoryHiddenInScope: null,
+        hiddenOutsideScope: null,
+    };
+}
+describe("kernel/commandDeprecation", () => {
+    const defaults = {
+        notifyChanges: true,
+        notifyPeriodDays: 7,
+        notifyMessage: null,
+    };
+    test("silently inserts history on first sync", () => {
+        const byId = new Map([
+            ["plugin::cmd1", createMockEntry("plugin::cmd1", "oldname")],
+        ]);
+        syncCommandHistory(byId, defaults, []);
+        // First sighting should not create an active deprecation for oldname
+        assert.equal(getActiveDeprecation("oldname"), null);
+    });
+    test("records deprecation when command is renamed across syncs", () => {
+        const byId1 = new Map([
+            ["plugin::cmd1", createMockEntry("plugin::cmd1", "oldname")],
+        ]);
+        syncCommandHistory(byId1, defaults, []);
+        // Sync 2: cmd name changed to newname
+        const byId2 = new Map([
+            ["plugin::cmd1", createMockEntry("plugin::cmd1", "newname")],
+        ]);
+        syncCommandHistory(byId2, defaults, []);
+        const deprecation = getActiveDeprecation("oldname");
+        assert.ok(deprecation);
+        assert.equal(deprecation?.old_cmd, "oldname");
+        assert.equal(deprecation?.new_cmd, "newname");
+        const formatted = formatDeprecationMessage(deprecation, defaults);
+        assert.ok(formatted.length > 0);
+    });
+    test("records deprecation when command is removed from registry", () => {
+        const byId1 = new Map([
+            ["plugin::cmdRem", createMockEntry("plugin::cmdRem", "removedcmd")],
+        ]);
+        syncCommandHistory(byId1, defaults, []);
+        // Sync 2: command removed
+        const byId2 = new Map();
+        syncCommandHistory(byId2, defaults, []);
+        const deprecation = getActiveDeprecation("removedcmd");
+        assert.ok(deprecation);
+        assert.equal(deprecation?.old_cmd, "removedcmd");
+        assert.equal(deprecation?.new_cmd, null);
+    });
+    test("respects notifyChanges = false opt-out", () => {
+        const byId1 = new Map([
+            ["plugin::optOut", createMockEntry("plugin::optOut", "alpha")],
+        ]);
+        const specs1 = [{
+                id: "plugin::optOut",
+                plugin: "plugin",
+                functions: ["optOut"],
+                loading: null,
+                cmd: "alpha",
+                aliases: [],
+                desc: null,
+                category: null,
+                group: null,
+                manual: null,
+                text: null,
+                deprecatedMessage: null,
+                notifyChanges: false,
+                permissions: null,
+                messages: null,
+                arguments: [],
+                subcommands: [],
+            }];
+        syncCommandHistory(byId1, defaults, specs1);
+        // Rename with notifyChanges = false
+        const byId2 = new Map([
+            ["plugin::optOut", createMockEntry("plugin::optOut", "beta")],
+        ]);
+        syncCommandHistory(byId2, defaults, specs1);
+        assert.equal(getActiveDeprecation("alpha"), null);
+    });
+});

package/dist/kernel/commandMenu.js

@@ -0,0 +1,357 @@
+/**
+ * commandMenu.ts
+ *
+ * Menu system for ManyBot (overview, category, manual, not-found).
+ */
+import { CMD_PREFIX } from "#config";
+import { getCurrentLang, tFor } from "#i18n";
+import { buildSettingsApi } from "./settingsDb.js";
+/** Maximum age (ms) of an incoming message for the welcome to fire.
+ *  Matches `MAX_MESSAGE_AGE_SECONDS` in `drivers/baileys/index.ts` so the
+ *  welcome can never fire on a message the driver would have dropped as
+ *  stale. See `checkAndTriggerWelcomeMessage` for the full rationale. */
+const MAX_WELCOME_AGE_MS = 60 * 1000;
+/**
+ * Checks if the user should be shown the welcome message,
+ * and marks them as seen if so.
+ *
+ * Two extra gates protect against the "ghost welcome" failure mode where
+ * a welcome fires out of the blue for a sender the bot never heard from:
+ *
+ *   - The incoming message must have non-empty text. Baileys 7.x has a
+ *     documented offline-flush bug where, after a reconnect, the
+ *     event-buffer can reclassify receipts as `messages.upsert` events
+ *     (the buffer interleaves message and receipt frames during the
+ *     replay window). Those events arrive with `fromMe=false`, in a
+ *     real DM, with `body` empty — every other condition for a welcome
+ *     fires, but they aren't real messages. Requiring a non-empty body
+ *     filters this entire class of synthetic upserts.
+ *
+ *   - The incoming message's `timestamp` must be within
+ *     `MAX_WELCOME_AGE_MS` of `now`. The Baileys 7.x line also has
+ *     widely-reported cases where the event-buffer delivers
+ *     `messages.upsert` events minutes, hours, or even days after they
+ *     originally occurred (they sit in the buffer during a long
+ *     disconnect and are drained in order on reconnect). A sender
+ *     whose first-ever contact with the bot was days ago is not a
+ *     "first-time" sender in any meaningful sense — the welcome is for
+ *     a real, live first contact, not a delayed replay. This mirrors
+ *     `isMessageStale()` in `drivers/baileys/index.ts` (60s), which
+ *     is the same threshold the driver itself uses to drop stale
+ *     events before they reach the handler. We keep the threshold the
+ *     same here so the two stay in sync: if the driver decided the
+ *     message is "real-time enough" to dispatch, the welcome fires;
+ *     if the driver would have dropped it, we never reach this path.
+ */
+export function checkAndTriggerWelcomeMessage(userId, registry, msg, lang, prefix = CMD_PREFIX) {
+    if (!registry.menu.welcomeMessage)
+        return null;
+    if (!msg || !msg.body || msg.body.trim() === "")
+        return null;
+    const msgTsMs = msg.timestamp ?? 0;
+    if (msgTsMs > 0) {
+        const ageMs = Date.now() - msgTsMs;
+        if (ageMs > MAX_WELCOME_AGE_MS)
+            return null;
+    }
+    const settings = buildSettingsApi("kernel", userId);
+    const lastSeen = settings.get("last_welcome_seen");
+    const now = Math.floor(Date.now() / 1000);
+    const windowSeconds = (registry.menu.welcomeWindowDays || 3) * 86400;
+    if (!lastSeen || now - lastSeen > windowSeconds) {
+        settings.set("last_welcome_seen", now);
+        const rawMsg = resolveLocalizedString(registry.menu.welcomeMessage, lang);
+        if (!rawMsg)
+            return null;
+        return rawMsg.replace(/\{prefix\}/g, prefix);
+    }
+    return null;
+}
+/**
+ * Resolves a LocalizedString (string | Record<string, string>) to a single
+ * string for the requested language (or system language), falling back to
+ * English or the first available string.
+ */
+export function resolveLocalizedString(raw, lang) {
+    if (!raw)
+        return null;
+    if (typeof raw === "string")
+        return raw;
+    if (typeof raw === "object" && raw !== null) {
+        const targetLang = (lang || getCurrentLang()).toLowerCase();
+        if (typeof raw[targetLang] === "string")
+            return raw[targetLang];
+        if (typeof raw.en === "string")
+            return raw.en;
+        if (typeof raw.pt === "string")
+            return raw.pt;
+        if (typeof raw.es === "string")
+            return raw.es;
+        const values = Object.values(raw);
+        if (values.length > 0 && typeof values[0] === "string")
+            return values[0];
+    }
+    return null;
+}
+export function renderOverview(registry, lang, page, scope) {
+    const parts = [];
+    const titleStr = resolveLocalizedString(registry.menu.title, lang) ?? "🤖 ManyBot — Menu";
+    parts.push(`*${titleStr}*`);
+    const rawIntro = resolveLocalizedString(registry.menu.intro, lang) ??
+        tFor(lang, "menu.intro");
+    const introStr = rawIntro.replace(/\{prefix\}/g, CMD_PREFIX);
+    parts.push(introStr);
+    parts.push(""); // blank line before categories/commands
+    const allEntries = Array.from(registry.byId.values());
+    const categories = Object.entries(registry.categories);
+    const pageSize = registry.menu.pageSize ?? 15;
+    if (categories.length > 0) {
+        // Sort defined categories by order ascending
+        const sortedCategories = categories.sort((a, b) => a[1].order - b[1].order);
+        const assignedIds = new Set();
+        for (const [catKey, catConfig] of sortedCategories) {
+            if (scope && catConfig.scope && catConfig.scope !== scope) {
+                continue;
+            }
+            const entries = allEntries
+                .filter(e => e.category === catKey)
+                .filter(e => {
+                if (!scope)
+                    return true;
+                if (e.categoryHiddenInScope && e.categoryHiddenInScope === scope)
+                    return false;
+                if (e.hiddenOutsideScope && e.hiddenOutsideScope !== "any" && e.hiddenOutsideScope !== scope)
+                    return false;
+                return true;
+            })
+                .sort((a, b) => a.cmd.localeCompare(b.cmd));
+            if (entries.length === 0)
+                continue;
+            const catLabel = resolveLocalizedString(catConfig.label, lang) ?? catKey;
+            parts.push(`📁 *${catLabel}*`);
+            for (const entry of entries) {
+                assignedIds.add(entry.id);
+                const descStr = resolveLocalizedString(entry.desc, lang);
+                if (descStr) {
+                    parts.push(`  • ${CMD_PREFIX}${entry.cmd} — ${descStr}`);
+                }
+                else {
+                    parts.push(`  • ${CMD_PREFIX}${entry.cmd}`);
+                }
+            }
+            parts.push("");
+        }
+        // Uncategorized entries
+        const uncategorized = allEntries
+            .filter(e => !assignedIds.has(e.id))
+            .filter(e => {
+            if (!scope)
+                return true;
+            if (e.categoryHiddenInScope && e.categoryHiddenInScope === scope)
+                return false;
+            if (e.hiddenOutsideScope && e.hiddenOutsideScope !== "any" && e.hiddenOutsideScope !== scope)
+                return false;
+            return true;
+        })
+            .sort((a, b) => a.cmd.localeCompare(b.cmd));
+        if (uncategorized.length > 0) {
+            const otherLabel = tFor(lang, "menu.other");
+            parts.push(`📁 *${otherLabel}*`);
+            for (const entry of uncategorized) {
+                const descStr = resolveLocalizedString(entry.desc, lang);
+                if (descStr) {
+                    parts.push(`  • ${CMD_PREFIX}${entry.cmd} — ${descStr}`);
+                }
+                else {
+                    parts.push(`  • ${CMD_PREFIX}${entry.cmd}`);
+                }
+            }
+            parts.push("");
+        }
+    }
+    else {
+        // Flat command list with pagination
+        const filteredEntries = allEntries.filter(e => {
+            if (!scope)
+                return true;
+            if (e.categoryHiddenInScope && e.categoryHiddenInScope === scope)
+                return false;
+            if (e.hiddenOutsideScope && e.hiddenOutsideScope !== "any" && e.hiddenOutsideScope !== scope)
+                return false;
+            return true;
+        });
+        const startIdx = page ? (page - 1) * pageSize : 0;
+        const visibleEntries = filteredEntries.slice(startIdx, startIdx + pageSize);
+        for (const entry of visibleEntries) {
+            const descStr = resolveLocalizedString(entry.desc, lang);
+            if (descStr) {
+                parts.push(`• ${CMD_PREFIX}${entry.cmd} — ${descStr}`);
+            }
+            else {
+                parts.push(`• ${CMD_PREFIX}${entry.cmd}`);
+            }
+        }
+        parts.push("");
+    }
+    const footerStr = resolveLocalizedString(registry.menu.footer, lang);
+    if (footerStr) {
+        parts.push(footerStr.replace(/\{prefix\}/g, CMD_PREFIX));
+    }
+    return parts.join("\n").trim();
+}
+export function renderCategory(registry, categoryKey, lang, scope) {
+    const normTarget = categoryKey.trim().toLowerCase();
+    // Match category key or category label
+    let matchedKey = null;
+    let matchedLabel = null;
+    for (const [catKey, catConfig] of Object.entries(registry.categories)) {
+        if (scope && catConfig.scope && catConfig.scope !== scope) {
+            continue;
+        }
+        const labelStr = resolveLocalizedString(catConfig.label, lang) ?? catKey;
+        if (catKey.toLowerCase() === normTarget || labelStr.toLowerCase() === normTarget) {
+            matchedKey = catKey;
+            matchedLabel = labelStr;
+            break;
+        }
+    }
+    if (!matchedKey) {
+        // Try matching if any command has entry.category === categoryKey
+        const hasCategoryInEntries = Array.from(registry.byId.values()).some(e => e.category?.toLowerCase() === normTarget);
+        if (hasCategoryInEntries) {
+            matchedKey = categoryKey;
+            matchedLabel = categoryKey;
+        }
+        else {
+            return null; // Category not found
+        }
+    }
+    // If we have a scope and the matched category has a scope that doesn't match, return null
+    if (scope && matchedKey && registry.categories[matchedKey]?.scope && registry.categories[matchedKey].scope !== scope) {
+        return null;
+    }
+    const entries = Array.from(registry.byId.values())
+        .filter(e => e.category?.toLowerCase() === matchedKey.toLowerCase())
+        .filter(e => {
+        if (!scope)
+            return true;
+        // If entry has a specific scope defined and it doesn't match the requested scope, exclude it
+        if (e.categoryHiddenInScope && e.categoryHiddenInScope === scope)
+            return false;
+        if (e.hiddenOutsideScope && e.hiddenOutsideScope !== "any" && e.hiddenOutsideScope !== scope)
+            return false;
+        return true;
+    })
+        .sort((a, b) => a.cmd.localeCompare(b.cmd));
+    if (entries.length === 0)
+        return null;
+    const parts = [];
+    parts.push(`📁 *${tFor(lang, "menu.category")}: ${matchedLabel}*`);
+    parts.push("");
+    for (const entry of entries) {
+        const descStr = resolveLocalizedString(entry.desc, lang);
+        if (descStr) {
+            parts.push(`• ${CMD_PREFIX}${entry.cmd} — ${descStr}`);
+        }
+        else {
+            parts.push(`• ${CMD_PREFIX}${entry.cmd}`);
+        }
+    }
+    return parts.join("\\n").trim();
+}
+export function renderManual(entry, registry, lang) {
+    const parts = [];
+    parts.push(`📖 *${tFor(lang, "menu.manual")}: ${CMD_PREFIX}${entry.cmd}*`);
+    if (entry.aliases.length > 0) {
+        parts.push(`*Aliases:* ${entry.aliases.map(a => CMD_PREFIX + a).join(", ")}`);
+    }
+    if (entry.category && registry.categories[entry.category]) {
+        const catLabel = resolveLocalizedString(registry.categories[entry.category].label, lang) ?? entry.category;
+        parts.push(`*${tFor(lang, "menu.category")}:* ${catLabel}`);
+    }
+    parts.push("");
+    const descStr = resolveLocalizedString(entry.desc, lang);
+    if (descStr) {
+        parts.push(`*${tFor(lang, "menu.description")}:* ${descStr}`);
+        parts.push("");
+    }
+    const manualStr = resolveLocalizedString(entry.manual, lang);
+    if (manualStr) {
+        parts.push(manualStr);
+    }
+    else {
+        parts.push(tFor(lang, "system.commandManualMissing", { cmd: entry.cmd }));
+    }
+    return parts.join("\n").trim();
+}
+function levenshtein(a, b) {
+    const m = a.length, n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++)
+        dp[i][0] = i;
+    for (let j = 0; j <= n; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] = a[i - 1] === b[j - 1]
+                ? dp[i - 1][j - 1]
+                : 1 + Math.min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]);
+        }
+    }
+    return dp[m][n];
+}
+/** Closest known cmd/alias to `invocation` within `maxDistance`, or null. */
+function findClosestInvocation(invocation, registry, maxDistance) {
+    let best = null;
+    let bestDist = Infinity;
+    for (const known of registry.byInvocation.keys()) {
+        const dist = levenshtein(invocation, known);
+        if (dist < bestDist) {
+            bestDist = dist;
+            best = known;
+        }
+    }
+    return best !== null && bestDist > 0 && bestDist <= maxDistance ? best : null;
+}
+export function renderNotFound(invocation, registry, lang) {
+    const menuCmd = registry.menu.cmd;
+    if (registry.menu.suggestSimilar) {
+        const suggestion = findClosestInvocation(invocation, registry, registry.menu.suggestMaxDistance);
+        if (suggestion) {
+            return tFor(lang, "system.commandNotFoundSuggestion", {
+                cmd: invocation,
+                suggestion,
+                prefix: CMD_PREFIX,
+                menuCmd
+            });
+        }
+    }
+    return tFor(lang, "system.commandNotFound", { cmd: invocation, prefix: CMD_PREFIX, menuCmd });
+}
+export function handleMenuCommand(command, rawArgs, registry, lang, scope) {
+    const trimmed = rawArgs.trim();
+    if (!trimmed) {
+        return renderOverview(registry, lang, undefined, scope);
+    }
+    // Check if rawArgs is a page number or starts with "page <number>"
+    const pageMatch = trimmed.match(/^(?:page\s+)?(\d+)$/i);
+    if (pageMatch) {
+        const pageNum = parseInt(pageMatch[1], 10);
+        return renderOverview(registry, lang, pageNum, scope);
+    }
+    const arg1 = trimmed.split(/\s+/)[0].toLowerCase();
+    const cleanArg = arg1.startsWith(CMD_PREFIX) ? arg1.slice(CMD_PREFIX.length) : arg1;
+    // 1. Match category
+    const categoryResult = renderCategory(registry, cleanArg, lang, scope);
+    if (categoryResult) {
+        return categoryResult;
+    }
+    // 2. Match command entry
+    const entryId = registry.byInvocation.get(cleanArg);
+    const entry = entryId ? registry.byId.get(entryId) : null;
+    if (entry) {
+        return renderManual(entry, registry, lang);
+    }
+    // 3. Fallback not-found
+    return renderNotFound(cleanArg, registry, lang);
+}