@manybot/manybot 5.6.1 → 5.8.0

package/dist/kernel/commandsConfig.js

@@ -0,0 +1,517 @@
+import fs from "fs/promises";
+import path from "path";
+import * as yaml from "js-yaml";
+import { logger } from "#logger";
+import { t } from "#i18n";
+import { PATHS } from "#config";
+const COMMANDS_FILE = path.join(PATHS.HOME, "commands.yaml");
+function asString(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function asAliasList(value) {
+    if (value === undefined || value === null)
+        return [];
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    for (const item of value) {
+        if (typeof item !== "string")
+            continue;
+        const trimmed = item.trim();
+        if (trimmed.length > 0)
+            out.push(trimmed);
+    }
+    return out;
+}
+function asImportList(value) {
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? [trimmed] : [];
+    }
+    return asAliasList(value);
+}
+function asBool(value) {
+    if (typeof value === "boolean")
+        return value;
+    return null;
+}
+function asPositiveInt(value, fallback) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+        return fallback;
+    return Math.floor(value);
+}
+export function parseLocalizedString(raw) {
+    if (typeof raw === "string") {
+        const trimmed = raw.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    if (raw !== null && typeof raw === "object" && !Array.isArray(raw)) {
+        const out = {};
+        for (const [lang, val] of Object.entries(raw)) {
+            if (typeof val === "string") {
+                const trimmed = val.trim();
+                if (trimmed.length > 0)
+                    out[lang] = trimmed;
+            }
+        }
+        return Object.keys(out).length > 0 ? out : null;
+    }
+    return null;
+}
+export async function resolveFileRef(value) {
+    if (!value)
+        return null;
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed.startsWith("file:")) {
+            const relativePath = trimmed.slice(5).trim();
+            const fullPath = path.resolve(PATHS.HOME, relativePath);
+            try {
+                return await fs.readFile(fullPath, "utf8");
+            }
+            catch (e) {
+                const err = e;
+                logger.warn(`commandsConfig: failed to read file ref "${trimmed}" (${fullPath}): ${err.message}`);
+                return trimmed;
+            }
+        }
+        return trimmed;
+    }
+    if (typeof value === "object" && value !== null) {
+        const out = {};
+        for (const [lang, val] of Object.entries(value)) {
+            if (typeof val === "string") {
+                const resolved = await resolveFileRef(val);
+                if (resolved && typeof resolved === "string") {
+                    out[lang] = resolved;
+                }
+            }
+        }
+        return Object.keys(out).length > 0 ? out : null;
+    }
+    return null;
+}
+function parseGroupUserList(raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return undefined;
+    const obj = raw;
+    const groups = asAliasList(obj.groups);
+    const users = asAliasList(obj.users);
+    if (groups.length === 0 && users.length === 0)
+        return undefined;
+    return {
+        groups: groups.length > 0 ? groups : undefined,
+        users: users.length > 0 ? users : undefined,
+    };
+}
+function parsePermissions(raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const obj = raw;
+    const admin = asBool(obj.admin) ?? undefined;
+    const botAdmin = asBool(obj.botAdmin) ?? undefined;
+    const owner = asBool(obj.owner) ?? undefined;
+    let scope = undefined;
+    const scopeStr = asString(obj.scope)?.toLowerCase();
+    if (scopeStr === "group" || scopeStr === "dm" || scopeStr === "any") {
+        scope = scopeStr;
+    }
+    let cooldownSeconds = undefined;
+    if (typeof obj.cooldownSeconds === "number" && Number.isFinite(obj.cooldownSeconds) && obj.cooldownSeconds >= 0) {
+        cooldownSeconds = obj.cooldownSeconds;
+    }
+    const whitelist = parseGroupUserList(obj.whitelist);
+    const blacklist = parseGroupUserList(obj.blacklist);
+    if (admin === undefined &&
+        botAdmin === undefined &&
+        owner === undefined &&
+        scope === undefined &&
+        cooldownSeconds === undefined &&
+        whitelist === undefined &&
+        blacklist === undefined) {
+        return null;
+    }
+    return {
+        admin,
+        botAdmin,
+        owner,
+        scope,
+        cooldownSeconds,
+        whitelist,
+        blacklist,
+    };
+}
+function parseMessages(raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const obj = raw;
+    const botNotAdmin = asString(obj.botNotAdmin) ?? undefined;
+    const senderNotAdmin = asString(obj.senderNotAdmin) ?? undefined;
+    const ownerOnly = asString(obj.ownerOnly) ?? undefined;
+    const wrongScope = asString(obj.wrongScope) ?? undefined;
+    const cooldown = asString(obj.cooldown) ?? undefined;
+    if (!botNotAdmin && !senderNotAdmin && !ownerOnly && !wrongScope && !cooldown) {
+        return null;
+    }
+    return {
+        botNotAdmin,
+        senderNotAdmin,
+        ownerOnly,
+        wrongScope,
+        cooldown,
+    };
+}
+const ARGUMENT_TYPES = new Set([
+    "mention", "url", "media_direct", "media_reply", "number",
+    "duration", "choice", "boolean", "quoted_text", "reply",
+]);
+function parseArgument(raw, parentId) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const obj = raw;
+    const name = asString(obj.name);
+    if (!name) {
+        logger.warn(t("system.commandsConfigArgumentMissingName", { id: parentId }));
+        return null;
+    }
+    const typeStr = asString(obj.type);
+    if (!typeStr) {
+        logger.warn(t("system.commandsConfigArgumentMissingType", { id: parentId, name }));
+        return null;
+    }
+    if (!ARGUMENT_TYPES.has(typeStr)) {
+        logger.warn(t("system.commandsConfigUnknownArgType", { id: parentId, name, type: typeStr }));
+        return null;
+    }
+    const required = asBool(obj.required) ?? false;
+    let choices;
+    if (typeStr === "choice") {
+        choices = asAliasList(obj.choices);
+        if (choices.length === 0) {
+            logger.warn(t("system.commandsConfigChoiceArgumentNoChoices", { id: parentId, name }));
+            // Still allow the argument; renderUsage just falls back to "<name>".
+        }
+    }
+    return {
+        name,
+        type: typeStr,
+        required,
+        choices,
+    };
+}
+function parseArguments(raw, parentId) {
+    if (raw === undefined || raw === null)
+        return [];
+    if (!Array.isArray(raw)) {
+        logger.warn(t("system.commandsConfigArgumentsNotList", { id: parentId }));
+        return [];
+    }
+    const out = [];
+    for (const item of raw) {
+        const arg = parseArgument(item, parentId);
+        if (arg)
+            out.push(arg);
+    }
+    return out;
+}
+async function parseSubcommand(parentId, raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const obj = raw;
+    const cmd = asString(obj.cmd);
+    if (!cmd) {
+        logger.warn(t("system.commandsConfigSubcommandMissingCmd", { id: parentId }));
+        return null;
+    }
+    const id = `${parentId}::${cmd}`;
+    const rawManual = parseLocalizedString(obj.manual);
+    const manual = rawManual ? await resolveFileRef(rawManual) : null;
+    return {
+        id,
+        cmd,
+        aliases: asAliasList(obj.aliases),
+        function: asString(obj.function),
+        desc: parseLocalizedString(obj.desc),
+        manual,
+        arguments: parseArguments(obj.arguments, id),
+        permissions: parsePermissions(obj.permissions),
+        messages: parseMessages(obj.messages),
+    };
+}
+async function parseSubcommands(raw, parentId) {
+    if (raw === undefined || raw === null)
+        return [];
+    if (!Array.isArray(raw)) {
+        logger.warn(t("system.commandsConfigSubcommandsNotList", { id: parentId }));
+        return [];
+    }
+    const out = [];
+    for (const item of raw) {
+        const sub = await parseSubcommand(parentId, item);
+        if (sub)
+            out.push(sub);
+    }
+    return out;
+}
+const DEFAULT_MENU_CONFIG = {
+    title: "🤖 ManyBot — Menu",
+    intro: {
+        en: "Use {prefix}<command> to run it or {prefix}help <command> to view its manual.",
+        pt: "Use {prefix}<comando> para executar ou {prefix}help <comando> para ver o manual.",
+        es: "Usa {prefix}<comando> para ejecutarlo o {prefix}help <comando> para ver el manual.",
+    },
+    footer: null,
+    cmd: "menu",
+    aliases: ["help", "man", "menu", "bot", "?"],
+    notFoundFallback: false,
+    welcomeMessage: null,
+    welcomeWindowDays: 3,
+    pageSize: 15,
+};
+function parseMenu(raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+        return { ...DEFAULT_MENU_CONFIG };
+    }
+    const obj = raw;
+    const aliases = asAliasList(obj.aliases);
+    return {
+        title: parseLocalizedString(obj.title) ?? DEFAULT_MENU_CONFIG.title,
+        intro: parseLocalizedString(obj.intro) ?? DEFAULT_MENU_CONFIG.intro,
+        footer: parseLocalizedString(obj.footer) ?? DEFAULT_MENU_CONFIG.footer,
+        cmd: asString(obj.cmd) ?? DEFAULT_MENU_CONFIG.cmd,
+        aliases: aliases.length > 0 ? aliases : [...DEFAULT_MENU_CONFIG.aliases],
+        notFoundFallback: asBool(obj.notFoundFallback) ?? DEFAULT_MENU_CONFIG.notFoundFallback,
+        welcomeMessage: parseLocalizedString(obj.welcomeMessage) ?? DEFAULT_MENU_CONFIG.welcomeMessage,
+        welcomeWindowDays: asPositiveInt(obj.welcomeWindowDays, DEFAULT_MENU_CONFIG.welcomeWindowDays),
+        pageSize: asPositiveInt(obj.pageSize, DEFAULT_MENU_CONFIG.pageSize),
+    };
+}
+function parseScopeValue(raw) {
+    const s = asString(raw)?.toLowerCase();
+    if (s === "group" || s === "dm" || s === "any")
+        return s;
+    return null;
+}
+function parseCategories(raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return {};
+    const obj = raw;
+    const out = {};
+    for (const [catKey, value] of Object.entries(obj)) {
+        if (value === null || typeof value !== "object" || Array.isArray(value))
+            continue;
+        const catObj = value;
+        const label = parseLocalizedString(catObj.label) ?? catKey;
+        const order = typeof catObj.order === "number" && Number.isFinite(catObj.order) ? catObj.order : 999;
+        const scope = parseScopeValue(catObj.scope);
+        const hiddenInScope = parseScopeValue(catObj.hiddenInScope);
+        out[catKey] = {
+            label,
+            order,
+            scope: scope ?? null,
+            hiddenInScope: hiddenInScope ?? null,
+        };
+    }
+    return out;
+}
+async function parseManuals(raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return {};
+    const obj = raw;
+    const out = {};
+    for (const [id, value] of Object.entries(obj)) {
+        const parsed = parseLocalizedString(value);
+        if (parsed) {
+            const resolved = await resolveFileRef(parsed);
+            if (resolved)
+                out[id] = resolved;
+        }
+    }
+    return out;
+}
+const DEFAULT_NOTIFY_CHANGES = true;
+const DEFAULT_NOTIFY_PERIOD_DAYS = 7;
+function parseDefaults(raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+        return {
+            notifyChanges: DEFAULT_NOTIFY_CHANGES,
+            notifyPeriodDays: DEFAULT_NOTIFY_PERIOD_DAYS,
+            notifyMessage: null,
+            permissions: null,
+            messages: null,
+        };
+    }
+    const obj = raw;
+    return {
+        notifyChanges: asBool(obj.notifyChanges) ?? DEFAULT_NOTIFY_CHANGES,
+        notifyPeriodDays: asPositiveInt(obj.notifyPeriodDays, DEFAULT_NOTIFY_PERIOD_DAYS),
+        notifyMessage: asString(obj.notifyMessage),
+        permissions: parsePermissions(obj.permissions),
+        messages: parseMessages(obj.messages),
+    };
+}
+async function parseEntry(id, raw) {
+    const cmd = asString(raw.cmd);
+    if (!cmd) {
+        logger.warn(t("system.commandsConfigMissingCmd", {
+            id,
+            path: COMMANDS_FILE
+        }));
+        return null;
+    }
+    const rawText = parseLocalizedString(raw.text);
+    const text = rawText ? await resolveFileRef(rawText) : null;
+    const rawManual = parseLocalizedString(raw.manual);
+    const manual = rawManual ? await resolveFileRef(rawManual) : null;
+    return {
+        id,
+        cmd,
+        aliases: asAliasList(raw.aliases),
+        plugin: asString(raw.plugin),
+        function: asString(raw.function),
+        text,
+        desc: parseLocalizedString(raw.desc),
+        category: asString(raw.category),
+        group: asString(raw.group),
+        manual,
+        deprecatedMessage: asString(raw.deprecatedMessage),
+        notifyChanges: asBool(raw.notifyChanges),
+        permissions: parsePermissions(raw.permissions),
+        messages: parseMessages(raw.messages),
+        arguments: parseArguments(raw.arguments, id),
+        subcommands: await parseSubcommands(raw.subcommands, id),
+    };
+}
+const RESERVED_KEYS = new Set(["defaults", "menu", "categories", "manuals", "import"]);
+/**
+ * Resolves `import:` (a path or list of paths, relative to PATHS.HOME) by
+ * reading each referenced YAML file and folding its top-level sections
+ * into the main root object. Each top-level key (`menu`, `manuals`, a
+ * command id, ...) may be owned by exactly one source file — no deep
+ * merge, first owner wins and any later collision is reported as an
+ * error and skipped, keeping the rest of that import file usable.
+ */
+async function resolveImports(root) {
+    const importPaths = asImportList(root.import);
+    if (importPaths.length === 0)
+        return root;
+    const merged = { ...root };
+    delete merged.import;
+    const owner = new Map();
+    for (const key of Object.keys(merged))
+        owner.set(key, COMMANDS_FILE);
+    for (const relPath of importPaths) {
+        const fullPath = path.resolve(PATHS.HOME, relPath);
+        let raw;
+        try {
+            raw = await fs.readFile(fullPath, "utf8");
+        }
+        catch (e) {
+            const err = e;
+            logger.error(t("system.commandsConfigImportReadFailed", { path: fullPath, message: err.message }));
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = yaml.load(raw, { filename: fullPath });
+        }
+        catch (e) {
+            const err = e;
+            logger.error(t("system.commandsConfigImportParseFailed", { path: fullPath, message: err.message }));
+            continue;
+        }
+        if (parsed === null || parsed === undefined)
+            continue;
+        if (typeof parsed !== "object" || Array.isArray(parsed)) {
+            logger.error(t("system.commandsConfigImportInvalidRoot", { path: fullPath }));
+            continue;
+        }
+        for (const [key, value] of Object.entries(parsed)) {
+            if (key === "import") {
+                logger.warn(t("system.commandsConfigImportNested", { path: fullPath }));
+                continue;
+            }
+            const existingOwner = owner.get(key);
+            if (existingOwner !== undefined) {
+                logger.error(t("system.commandsConfigImportKeyConflict", { key, path: fullPath, owner: existingOwner }));
+                continue;
+            }
+            merged[key] = value;
+            owner.set(key, fullPath);
+        }
+    }
+    return merged;
+}
+export async function loadCommandsConfig() {
+    let raw;
+    try {
+        raw = await fs.readFile(COMMANDS_FILE, "utf8");
+    }
+    catch (e) {
+        const err = e;
+        if (err.code === "ENOENT")
+            return null;
+        logger.error(t("system.commandsConfigReadFailed", {
+            path: COMMANDS_FILE,
+            message: err.message
+        }));
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = yaml.load(raw, { filename: COMMANDS_FILE });
+    }
+    catch (e) {
+        const err = e;
+        logger.error(t("system.commandsConfigParseFailed", {
+            path: COMMANDS_FILE,
+            message: err.message
+        }));
+        return null;
+    }
+    if (parsed === null || parsed === undefined) {
+        return {
+            defaults: {
+                notifyChanges: DEFAULT_NOTIFY_CHANGES,
+                notifyPeriodDays: DEFAULT_NOTIFY_PERIOD_DAYS,
+                notifyMessage: null,
+                permissions: null,
+                messages: null,
+            },
+            menu: { ...DEFAULT_MENU_CONFIG },
+            categories: {},
+            manuals: {},
+            specs: [],
+        };
+    }
+    if (typeof parsed !== "object" || Array.isArray(parsed)) {
+        logger.error(t("system.commandsConfigInvalidRoot", {
+            path: COMMANDS_FILE
+        }));
+        return null;
+    }
+    const root = await resolveImports(parsed);
+    const defaults = parseDefaults(root.defaults);
+    const menu = parseMenu(root.menu);
+    const categories = parseCategories(root.categories);
+    const manuals = await parseManuals(root.manuals);
+    const out = [];
+    for (const [id, value] of Object.entries(root)) {
+        if (RESERVED_KEYS.has(id))
+            continue;
+        if (value === null || typeof value !== "object" || Array.isArray(value)) {
+            logger.warn(t("system.commandsConfigInvalidEntry", {
+                id,
+                path: COMMANDS_FILE
+            }));
+            continue;
+        }
+        const spec = await parseEntry(id, value);
+        if (spec)
+            out.push(spec);
+    }
+    return { defaults, menu, categories, manuals, specs: out };
+}