@manybot/manybot 5.7.0 → 5.8.0

package/dist/kernel/commandRegistry.js

@@ -0,0 +1,459 @@
+/**
+ * commandRegistry.ts
+ *
+ * Merges commands.yaml user overrides with each active plugin's
+ * `commands` defaults into a single, in-memory registry — the single
+ * source of truth for command routing. No routing happens here yet
+ * (that's the next step); this module just builds the structure and
+ * can be exercised in isolation with a unit test.
+ */
+import { logger } from "#logger";
+import { t } from "#i18n";
+import { loadCommandsConfig, } from "./commandsConfig.js";
+import { pluginRegistry, resolvePluginCommandHandler, } from "./pluginLoader.js";
+import { getActiveDeprecation, syncCommandHistory } from "./commandDeprecation.js";
+export const DEFAULT_PERMISSION_MESSAGES = {
+    botNotAdmin: () => t("commandPermissions.botNotAdmin"),
+    senderNotAdmin: () => t("commandPermissions.senderNotAdmin"),
+    ownerOnly: () => t("commandPermissions.ownerOnly"),
+    wrongScope: () => t("commandPermissions.wrongScope"),
+    cooldown: () => t("commandPermissions.cooldown"),
+};
+export function resolvePermissions(specPerms, specMsgs, pluginPerms, defaultsPerms, defaultsMsgs, fallbackScope) {
+    const admin = specPerms?.admin ?? pluginPerms?.admin ?? false;
+    const botAdmin = specPerms?.botAdmin ?? pluginPerms?.botAdmin ?? false;
+    const scope = specPerms?.scope ?? pluginPerms?.scope ?? fallbackScope ?? "any";
+    const owner = specPerms?.owner ?? pluginPerms?.owner ?? false;
+    const cooldownSeconds = specPerms?.cooldownSeconds ?? pluginPerms?.cooldownSeconds ?? defaultsPerms?.cooldownSeconds ?? 0;
+    const rawWhitelist = specPerms?.whitelist ?? pluginPerms?.whitelist ?? defaultsPerms?.whitelist ?? null;
+    const rawBlacklist = specPerms?.blacklist ?? pluginPerms?.blacklist ?? defaultsPerms?.blacklist ?? null;
+    const whitelist = rawWhitelist
+        ? {
+            groups: rawWhitelist.groups ? [...rawWhitelist.groups] : [],
+            users: rawWhitelist.users ? [...rawWhitelist.users] : [],
+        }
+        : null;
+    const blacklist = rawBlacklist
+        ? {
+            groups: rawBlacklist.groups ? [...rawBlacklist.groups] : [],
+            users: rawBlacklist.users ? [...rawBlacklist.users] : [],
+        }
+        : null;
+    const messages = {
+        botNotAdmin: specMsgs?.botNotAdmin ?? defaultsMsgs?.botNotAdmin ?? DEFAULT_PERMISSION_MESSAGES.botNotAdmin(),
+        senderNotAdmin: specMsgs?.senderNotAdmin ?? defaultsMsgs?.senderNotAdmin ?? DEFAULT_PERMISSION_MESSAGES.senderNotAdmin(),
+        ownerOnly: specMsgs?.ownerOnly ?? defaultsMsgs?.ownerOnly ?? undefined,
+        wrongScope: specMsgs?.wrongScope ?? defaultsMsgs?.wrongScope ?? DEFAULT_PERMISSION_MESSAGES.wrongScope(),
+        cooldown: specMsgs?.cooldown ?? defaultsMsgs?.cooldown ?? DEFAULT_PERMISSION_MESSAGES.cooldown(),
+    };
+    return {
+        admin,
+        botAdmin,
+        scope,
+        owner,
+        cooldownSeconds,
+        whitelist,
+        blacklist,
+        messages,
+    };
+}
+function pluginCommandKey(pluginName, functionName) {
+    return `${pluginName}::${functionName}`;
+}
+/**
+ * Plugin-provided command defaults (`export const commands = {...}`) are
+ * plain JS, not parsed/validated YAML — a plugin can hand us any runtime
+ * value regardless of the `PluginCommandDefault` compile-time type. `cmd`
+ * and `aliases` end up bound to SQLite params (deprecation lookups) and a
+ * non-string/undefined value there throws instead of failing gracefully.
+ * Sanitize before it ever reaches the registry.
+ */
+function sanitizePluginCmd(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function sanitizePluginAliases(value) {
+    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 normalizePluginCommand(def) {
+    const handler = resolvePluginCommandHandler(def);
+    if (def && typeof def === "object") {
+        return {
+            cmd: sanitizePluginCmd(def.cmd),
+            aliases: sanitizePluginAliases(def.aliases),
+            desc: def.desc ?? null,
+            category: typeof def.category === "string" ? def.category : null,
+            manual: def.manual ?? null,
+            permissions: def.permissions ?? null,
+            handler,
+        };
+    }
+    // Bare function (pure-function style — no built-in identity), or
+    // something malformed entirely (handler stays null in that case).
+    return { cmd: null, aliases: [], desc: null, category: null, manual: null, permissions: null, handler };
+}
+/** Whether a `commands[fn]` export is a shape worth remembering at all —
+ *  a bare handler function, or an object (even one missing `handler`,
+ *  which is only validated at dispatch time, same as before this
+ *  module supported the bare-function shape). Anything else (a string,
+ *  a number, null/undefined) is not a command definition. */
+function isUsablePluginCommandExport(def) {
+    return typeof def === "function" || (def !== null && typeof def === "object");
+}
+function registerInvocation(byInvocation, text, entryId, isOverride) {
+    const existing = byInvocation.get(text);
+    if (existing === undefined) {
+        byInvocation.set(text, entryId);
+        return true;
+    }
+    if (existing === entryId)
+        return true;
+    logger.warn(t("system.commandRegistryInvocationCollision", {
+        text,
+        winner: existing,
+        loser: entryId,
+        via: isOverride ? "yaml override" : "plugin default"
+    }));
+    return false;
+}
+function registerInvocationWithDeprecationGuard(byInvocation, text, entryId, isOverride, notifyChanges) {
+    if (!notifyChanges) {
+        return registerInvocation(byInvocation, text, entryId, isOverride);
+    }
+    const deprecation = getActiveDeprecation(text);
+    if (deprecation) {
+        logger.warn(t("system.commandDeprecationReservedInvocation", {
+            text,
+            id: deprecation.id
+        }));
+        return false;
+    }
+    return registerInvocation(byInvocation, text, entryId, isOverride);
+}
+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 resolveCategoryHiddenInScope(category, categories) {
+    if (!category)
+        return null;
+    return categories[category]?.hiddenInScope ?? null;
+}
+/**
+ * Resolve a `CommandSubcommandSpec` into the runtime `CommandSubcommand`.
+ * The sub shares the parent's plugin handler function by default; if
+ * `spec.function` is set, it overrides the parent's `function` field.
+ * Subcommand permissions inherit from the parent's resolved permissions
+ * unless the spec overrides them — `parent.permissions.scope` is passed
+ * as `fallbackScope` to close the category → command → subcommand chain.
+ */
+function buildSubcommandFromSpec(spec, parent, pluginName, defaultsByKey, defaults, manuals) {
+    const manual = spec.manual ?? manuals[spec.id] ?? null;
+    const fnName = spec.function ?? parent.function ?? "";
+    // Each sub can point at a *different* plugin function than its
+    // siblings (that's the whole point of "add"/"list"/"done" sharing one
+    // parent) — resolve this sub's own default permissions from its own
+    // function, not from whatever function the parent happens to carry.
+    const subDef = pluginName && fnName
+        ? defaultsByKey.get(pluginCommandKey(pluginName, fnName))?.norm ?? null
+        : null;
+    return {
+        id: spec.id,
+        cmd: spec.cmd,
+        aliases: [...spec.aliases],
+        desc: spec.desc,
+        manual,
+        function: fnName,
+        arguments: [...spec.arguments],
+        permissions: resolvePermissions(spec.permissions, spec.messages, subDef?.permissions ?? null, defaults.permissions, defaults.messages, parent.permissions.scope),
+    };
+}
+function buildSubcommandsFromSpecs(specs, parent, pluginName, defaultsByKey, defaults, manuals) {
+    const out = {};
+    for (const spec of specs) {
+        const token = spec.cmd.toLowerCase();
+        if (out[token]) {
+            logger.warn(t("system.commandsConfigDuplicateSubcommand", {
+                id: parent.id,
+                cmd: spec.cmd
+            }));
+            continue;
+        }
+        out[token] = buildSubcommandFromSpec(spec, parent, pluginName, defaultsByKey, defaults, manuals);
+    }
+    return out;
+}
+export function buildCommandRegistry(specs, pluginRegistry, defaults = {
+    notifyChanges: true,
+    notifyPeriodDays: 7,
+    notifyMessage: null,
+}, menu = { ...DEFAULT_MENU_CONFIG }, categories = {}, manuals = {}) {
+    const byId = new Map();
+    const byInvocation = new Map();
+    const defaultsByKey = new Map();
+    for (const plugin of pluginRegistry.values()) {
+        if (plugin.status !== "active")
+            continue;
+        if (!plugin.commands)
+            continue;
+        for (const [fn, def] of Object.entries(plugin.commands)) {
+            const id = pluginCommandKey(plugin.name, fn);
+            // Only a genuinely broken export (not a function and not an
+            // object at all) is unusable no matter what commands.yaml says
+            // later — that's the one case worth a warning + a full skip.
+            if (!isUsablePluginCommandExport(def)) {
+                logger.warn(t("system.commandRegistryInvalidPluginCommand", {
+                    id,
+                    plugin: plugin.name,
+                    function: fn
+                }));
+                continue;
+            }
+            const norm = normalizePluginCommand(def);
+            // Remembered regardless of whether the plugin gave it a `cmd` —
+            // a "pure function" export (bare handler, no built-in identity)
+            // is only reachable once a commands.yaml entry supplies `cmd`,
+            // but it still needs to be findable by pluginCommandKey() below.
+            // A malformed `cmd` (present but not a usable string) also lands
+            // here silently — not an error, just no auto-registration.
+            defaultsByKey.set(id, { plugin, fn, norm });
+            if (!norm.cmd)
+                continue; // no built-in identity — yaml-only until overridden
+            const manual = norm.manual ?? manuals[id] ?? manuals[norm.cmd] ?? null;
+            const category = norm.category;
+            const entry = {
+                id,
+                cmd: norm.cmd,
+                aliases: norm.aliases,
+                desc: norm.desc,
+                category,
+                group: null,
+                manual,
+                source: "plugin",
+                pluginName: plugin.name,
+                function: fn,
+                handler: norm.handler,
+                text: null,
+                permissions: resolvePermissions(null, null, norm.permissions, defaults.permissions, defaults.messages, category ? categories[category]?.scope : null),
+                arguments: [],
+                subcommands: {},
+                categoryHiddenInScope: null,
+            };
+            byId.set(id, entry);
+        }
+    }
+    if (specs) {
+        for (const spec of specs) {
+            if (spec.plugin && spec.function) {
+                const key = pluginCommandKey(spec.plugin, spec.function);
+                const pluginDefault = defaultsByKey.get(key);
+                if (!pluginDefault) {
+                    logger.warn(t("system.commandRegistryOrphanEntry", {
+                        id: spec.id,
+                        plugin: spec.plugin,
+                        function: spec.function
+                    }));
+                    continue;
+                }
+                const norm = pluginDefault.norm;
+                let existing = byId.get(key);
+                if (!existing) {
+                    // Pure-function plugin export: no auto-registered entry yet
+                    // (norm.cmd was null), so commands.yaml is the sole source of
+                    // `cmd`. Without it there's nothing to invoke this command by.
+                    const cmd = spec.cmd;
+                    if (!cmd) {
+                        logger.warn(t("system.commandRegistryOrphanEntry", {
+                            id: spec.id,
+                            plugin: spec.plugin,
+                            function: spec.function
+                        }));
+                        continue;
+                    }
+                    existing = {
+                        id: key,
+                        cmd,
+                        aliases: [],
+                        desc: null,
+                        category: null,
+                        group: null,
+                        manual: null,
+                        source: "plugin",
+                        pluginName: spec.plugin,
+                        function: spec.function,
+                        handler: norm.handler,
+                        text: null,
+                        permissions: resolvePermissions(null, null, null, defaults.permissions, defaults.messages, null),
+                        arguments: [],
+                        subcommands: {},
+                        categoryHiddenInScope: null,
+                    };
+                    byId.set(key, existing);
+                }
+                if (spec.cmd)
+                    existing.cmd = spec.cmd;
+                if (spec.aliases.length > 0)
+                    existing.aliases = [...spec.aliases];
+                if (spec.desc)
+                    existing.desc = spec.desc;
+                if (spec.category)
+                    existing.category = spec.category;
+                if (spec.group !== null)
+                    existing.group = spec.group;
+                existing.manual = spec.manual ?? norm.manual ?? manuals[spec.id] ?? manuals[existing.cmd] ?? null;
+                existing.permissions = resolvePermissions(spec.permissions, spec.messages, norm.permissions, defaults.permissions, defaults.messages, existing.category ? categories[existing.category]?.scope : null);
+                existing.arguments = [...spec.arguments];
+                existing.categoryHiddenInScope = resolveCategoryHiddenInScope(existing.category, categories);
+                existing.subcommands = buildSubcommandsFromSpecs(spec.subcommands, existing, spec.plugin, defaultsByKey, defaults, manuals);
+            }
+            else if (spec.plugin && !spec.function && spec.subcommands.length > 0) {
+                // Parent-only container: the top-level entry has no handler of
+                // its own (e.g. `todo:`), it just groups subcommands that each
+                // declare their own `function:`. Never dispatched directly —
+                // resolveDispatch() always routes into one of `subcommands`.
+                const id = `parent::${spec.id}`;
+                const entry = {
+                    id,
+                    cmd: spec.cmd,
+                    aliases: [...spec.aliases],
+                    desc: spec.desc,
+                    category: spec.category ?? null,
+                    group: spec.group,
+                    manual: spec.manual ?? manuals[spec.id] ?? manuals[spec.cmd] ?? null,
+                    source: "plugin",
+                    pluginName: spec.plugin,
+                    function: null,
+                    handler: null,
+                    text: null,
+                    permissions: resolvePermissions(spec.permissions, spec.messages, null, defaults.permissions, defaults.messages, spec.category ? categories[spec.category]?.scope : null),
+                    arguments: [...spec.arguments],
+                    subcommands: {},
+                    categoryHiddenInScope: resolveCategoryHiddenInScope(spec.category, categories),
+                };
+                entry.subcommands = buildSubcommandsFromSpecs(spec.subcommands, entry, spec.plugin, defaultsByKey, defaults, manuals);
+                byId.set(id, entry);
+            }
+            else if (!spec.plugin) {
+                if (!spec.text) {
+                    logger.warn(t("system.commandRegistryInvalidEntry", {
+                        id: spec.id
+                    }));
+                    continue;
+                }
+                const id = `text::${spec.id}`;
+                const manual = spec.manual ?? manuals[spec.id] ?? manuals[spec.cmd] ?? null;
+                const entry = {
+                    id,
+                    cmd: spec.cmd,
+                    aliases: [...spec.aliases],
+                    desc: spec.desc,
+                    category: spec.category ?? null,
+                    group: spec.group,
+                    manual,
+                    source: "text",
+                    pluginName: null,
+                    function: null,
+                    handler: null,
+                    text: spec.text,
+                    permissions: resolvePermissions(spec.permissions, spec.messages, null, defaults.permissions, defaults.messages, spec.category ? categories[spec.category]?.scope : null),
+                    arguments: [...spec.arguments],
+                    subcommands: {},
+                    categoryHiddenInScope: resolveCategoryHiddenInScope(spec.category, categories),
+                };
+                entry.subcommands = buildSubcommandsFromSpecs(spec.subcommands, entry, null, defaultsByKey, defaults, manuals);
+                byId.set(id, entry);
+            }
+            else {
+                // spec.plugin set, but neither `function:` nor a non-empty
+                // `subcommands:` block — nothing tells the kernel what to run.
+                logger.warn(t("system.commandRegistryInvalidEntry", {
+                    id: spec.id
+                }));
+            }
+        }
+    }
+    for (const entry of byId.values()) {
+        registerInvocationWithDeprecationGuard(byInvocation, entry.cmd, entry.id, false, defaults.notifyChanges);
+        for (const alias of entry.aliases) {
+            registerInvocationWithDeprecationGuard(byInvocation, alias, entry.id, false, defaults.notifyChanges);
+        }
+    }
+    // Validate menu cmd + aliases against command invocations
+    const menuAliases = new Set();
+    const menuInvocations = [menu.cmd, ...menu.aliases.filter(a => a !== menu.cmd)];
+    for (const alias of menuInvocations) {
+        const existing = byInvocation.get(alias);
+        if (existing !== undefined) {
+            logger.warn(t("system.commandRegistryMenuAliasCollision", {
+                alias,
+                winner: existing
+            }));
+        }
+        else {
+            menuAliases.add(alias);
+        }
+    }
+    return { byId, byInvocation, defaults, menu, menuAliases, categories, manuals };
+}
+let currentRegistry = null;
+export async function initCommandRegistry() {
+    const config = await loadCommandsConfig();
+    const defaults = config?.defaults ?? {
+        notifyChanges: true,
+        notifyPeriodDays: 7,
+        notifyMessage: null,
+    };
+    const menu = config?.menu ?? { ...DEFAULT_MENU_CONFIG };
+    const categories = config?.categories ?? {};
+    const manuals = config?.manuals ?? {};
+    const specs = config?.specs ?? [];
+    const registry = buildCommandRegistry(specs, pluginRegistry, defaults, menu, categories, manuals);
+    syncCommandHistory(registry.byId, defaults, specs);
+    currentRegistry = registry;
+    return registry;
+}
+export function getCommandRegistry() {
+    return currentRegistry;
+}
+/**
+ * Test-only: inject a registry built with {@link buildCommandRegistry}
+ * directly, bypassing `initCommandRegistry()`'s disk config + real
+ * `pluginRegistry` load. Lets `runCommand.test.ts` exercise
+ * `resolveDispatch()`/`runCommand()`, which read the module-singleton
+ * `currentRegistry` and have no injectable-registry parameter (unlike
+ * `commandAccess.ts`'s functions). Pass `null` to reset.
+ */
+export function __setRegistryForTests(registry) {
+    currentRegistry = registry;
+}
+export function getCommandByInvocation(command) {
+    if (!currentRegistry)
+        return null;
+    const id = currentRegistry.byInvocation.get(command);
+    if (id === undefined)
+        return null;
+    return currentRegistry.byId.get(id) ?? null;
+}

package/dist/kernel/commandRegistry.test.js

@@ -0,0 +1,156 @@
+import test, { describe } from "node:test";
+import assert from "node:assert/strict";
+import { buildCommandRegistry } from "#kernel/commandRegistry.js";
+function createMockPluginRegistry(plugins) {
+    const map = new Map();
+    for (const p of plugins) {
+        map.set(p.name, {
+            name: p.name,
+            status: p.status ?? "active",
+            manifest: { name: p.name, version: "1.0.0" },
+            commands: p.commands ?? {},
+        });
+    }
+    return map;
+}
+describe("kernel/commandRegistry", () => {
+    test("builds registry from active plugin defaults", () => {
+        const plugins = createMockPluginRegistry([
+            {
+                name: "pingPlugin",
+                commands: {
+                    pingFn: {
+                        cmd: "ping",
+                        aliases: ["p"],
+                        desc: "Pong command",
+                        handler: async () => "pong",
+                    },
+                },
+            },
+        ]);
+        const registry = buildCommandRegistry(null, plugins);
+        assert.equal(registry.byId.size, 1);
+        const entry = registry.byId.get("pingPlugin::pingFn");
+        assert.ok(entry);
+        assert.equal(entry?.cmd, "ping");
+        assert.deepEqual(entry?.aliases, ["p"]);
+        assert.equal(entry?.source, "plugin");
+        assert.equal(registry.byInvocation.get("ping"), "pingPlugin::pingFn");
+        assert.equal(registry.byInvocation.get("p"), "pingPlugin::pingFn");
+    });
+    test("skips plugin commands with a non-string cmd instead of throwing", () => {
+        const plugins = createMockPluginRegistry([
+            {
+                name: "brokenPlugin",
+                commands: {
+                    badFn: {
+                        cmd: true,
+                        handler: async () => "x",
+                    },
+                    goodFn: {
+                        cmd: "ok",
+                        aliases: [1, "valid", null],
+                        handler: async () => "x",
+                    },
+                },
+            },
+        ]);
+        assert.doesNotThrow(() => buildCommandRegistry(null, plugins));
+        const registry = buildCommandRegistry(null, plugins);
+        assert.equal(registry.byId.has("brokenPlugin::badFn"), false);
+        const good = registry.byId.get("brokenPlugin::goodFn");
+        assert.ok(good);
+        assert.equal(good?.cmd, "ok");
+        assert.deepEqual(good?.aliases, ["valid"]);
+    });
+    test("applies spec overrides to plugin commands", () => {
+        const plugins = createMockPluginRegistry([
+            {
+                name: "funPlugin",
+                commands: {
+                    jokeFn: {
+                        cmd: "joke",
+                        aliases: ["j"],
+                        desc: "Original desc",
+                    },
+                },
+            },
+        ]);
+        const specs = [
+            {
+                id: "funPlugin::jokeFn",
+                plugin: "funPlugin",
+                function: "jokeFn",
+                cmd: "telljoke",
+                aliases: ["tj"],
+                desc: "Overridden desc",
+                category: "Fun",
+                group: null,
+                manual: null,
+                text: null,
+                deprecatedMessage: null,
+                notifyChanges: null,
+                permissions: { admin: true },
+                messages: null,
+                arguments: [],
+                subcommands: [],
+            },
+        ];
+        const registry = buildCommandRegistry(specs, plugins);
+        const entry = registry.byId.get("funPlugin::jokeFn");
+        assert.ok(entry);
+        assert.equal(entry?.cmd, "telljoke");
+        assert.deepEqual(entry?.aliases, ["tj"]);
+        assert.equal(entry?.desc, "Overridden desc");
+        assert.equal(entry?.category, "Fun");
+        assert.equal(entry?.permissions.admin, true);
+        // Old invocation "joke" should no longer map to entry if overridden by new cmd/aliases
+        assert.equal(registry.byInvocation.get("telljoke"), "funPlugin::jokeFn");
+        assert.equal(registry.byInvocation.get("tj"), "funPlugin::jokeFn");
+    });
+    test("registers text-only command specs", () => {
+        const plugins = createMockPluginRegistry([]);
+        const specs = [
+            {
+                id: "custom_hello",
+                plugin: null,
+                function: null,
+                cmd: "hello",
+                aliases: ["hi"],
+                desc: "Says hello",
+                category: "General",
+                group: null,
+                manual: null,
+                text: "Hello World!",
+                deprecatedMessage: null,
+                notifyChanges: null,
+                permissions: null,
+                messages: null,
+                arguments: [],
+                subcommands: [],
+            },
+        ];
+        const registry = buildCommandRegistry(specs, plugins);
+        assert.equal(registry.byId.size, 1);
+        const entry = registry.byId.get("text::custom_hello");
+        assert.ok(entry);
+        assert.equal(entry?.source, "text");
+        assert.equal(entry?.text, "Hello World!");
+        assert.equal(registry.byInvocation.get("hello"), "text::custom_hello");
+        assert.equal(registry.byInvocation.get("hi"), "text::custom_hello");
+    });
+    test("ignores inactive plugin commands", () => {
+        const plugins = createMockPluginRegistry([
+            {
+                name: "disabledPlugin",
+                status: "inactive",
+                commands: {
+                    testFn: { cmd: "disabledCmd" },
+                },
+            },
+        ]);
+        const registry = buildCommandRegistry(null, plugins);
+        assert.equal(registry.byId.size, 0);
+        assert.equal(registry.byInvocation.has("disabledCmd"), false);
+    });
+});