registry.rs

//! Command registry for cortex-tui slash commands.
//!
//! This module provides the `CommandRegistry` which stores all available
//! commands and provides lookup by name or alias.

use std::collections::HashMap;

use super::types::{CommandCategory, CommandDef};

// ============================================================
// COMMAND REGISTRY
// ============================================================

/// Registry storing all available slash commands.
///
/// Provides efficient lookup by command name or alias, and supports
/// filtering by category.
pub struct CommandRegistry {
    /// Map from primary command name to definition.
    commands: HashMap<&'static str, CommandDef>,
    /// Map from alias to primary command name.
    aliases: HashMap<&'static str, &'static str>,
}

impl CommandRegistry {
    /// Creates a new empty command registry.
    pub fn new() -> Self {
        Self {
            commands: HashMap::new(),
            aliases: HashMap::new(),
        }
    }

    /// Registers a command in the registry.
    ///
    /// Also registers all aliases to point to the primary command name.
    pub fn register(&mut self, def: CommandDef) {
        // Register aliases
        for alias in def.aliases {
            self.aliases.insert(alias, def.name);
        }

        // Register the command
        self.commands.insert(def.name, def);
    }

    /// Gets a command by name or alias.
    ///
    /// The lookup is case-insensitive.
    pub fn get(&self, name: &str) -> Option<&CommandDef> {
        let name_lower = name.to_lowercase();

        // Try direct lookup first
        if let Some(def) = self.commands.get(name_lower.as_str()) {
            return Some(def);
        }

        // Try alias lookup
        if let Some(&primary) = self.aliases.get(name_lower.as_str()) {
            return self.commands.get(primary);
        }

        // Try case-insensitive scan as fallback
        for (cmd_name, def) in &self.commands {
            if cmd_name.eq_ignore_ascii_case(&name_lower) {
                return Some(def);
            }
        }

        for (alias, primary) in &self.aliases {
            if alias.eq_ignore_ascii_case(&name_lower) {
                return self.commands.get(primary);
            }
        }

        None
    }

    /// Gets all commands in a specific category.
    ///
    /// Results are sorted by command name.
    pub fn get_by_category(&self, category: CommandCategory) -> Vec<&CommandDef> {
        let mut commands: Vec<_> = self
            .commands
            .values()
            .filter(|def| def.category == category && !def.hidden)
            .collect();

        commands.sort_by_key(|def| def.name);
        commands
    }

    /// Gets all visible (non-hidden) commands.
    ///
    /// Results are sorted by command name.
    pub fn all(&self) -> Vec<&CommandDef> {
        let mut commands: Vec<_> = self.commands.values().filter(|def| !def.hidden).collect();

        commands.sort_by_key(|def| def.name);
        commands
    }

    /// Gets all commands including hidden ones.
    pub fn all_including_hidden(&self) -> Vec<&CommandDef> {
        let mut commands: Vec<_> = self.commands.values().collect();
        commands.sort_by_key(|def| def.name);
        commands
    }

    /// Checks if a command exists by name or alias.
    pub fn exists(&self, name: &str) -> bool {
        self.get(name).is_some()
    }

    /// Returns the number of registered commands.
    pub fn len(&self) -> usize {
        self.commands.len()
    }

    /// Returns true if no commands are registered.
    pub fn is_empty(&self) -> bool {
        self.commands.is_empty()
    }

    /// Returns all command names (primary names only).
    pub fn command_names(&self) -> Vec<&'static str> {
        let mut names: Vec<_> = self.commands.keys().copied().collect();
        names.sort();
        names
    }

    /// Returns all names including aliases.
    pub fn all_names(&self) -> Vec<&'static str> {
        let mut names: Vec<_> = self
            .commands
            .keys()
            .copied()
            .chain(self.aliases.keys().copied())
            .collect();
        names.sort();
        names.dedup();
        names
    }
}

impl Default for CommandRegistry {
    fn default() -> Self {
        let mut registry = Self::new();
        register_builtin_commands(&mut registry);
        registry
    }
}

// ============================================================
// BUILTIN COMMANDS
// ============================================================

/// Registers all builtin commands in the registry.
pub fn register_builtin_commands(registry: &mut CommandRegistry) {
    // ========================================
    // GENERAL COMMANDS
    // ========================================

    registry.register(CommandDef::new(
        "help",
        &["h", "?"],
        "Show help information",
        "/help [topic]",
        CommandCategory::General,
        true,
    ));

    registry.register(CommandDef::new(
        "quit",
        &["q", "exit"],
        "Quit the application",
        "/quit",
        CommandCategory::General,
        false,
    ));

    registry.register(CommandDef::new(
        "version",
        &["v"],
        "Show version information",
        "/version",
        CommandCategory::General,
        false,
    ));

    registry.register(CommandDef::new(
        "upgrade",
        &["update"],
        "Check for and install updates",
        "/upgrade",
        CommandCategory::General,
        false,
    ));

    registry.register(CommandDef::new(
        "settings",
        &["config", "prefs"],
        "Open settings panel",
        "/settings",
        CommandCategory::General,
        false,
    ));

    // Config reload command (#2806)
    registry.register(CommandDef::new(
        "reload-config",
        &["reload"],
        "Reload configuration from disk",
        "/reload-config",
        CommandCategory::General,
        false,
    ));

    registry.register(CommandDef::new(
        "copy",
        &["cp"],
        "Show how to copy text",
        "/copy",
        CommandCategory::General,
        false,
    ));

    registry.register(CommandDef::new(
        "theme",
        &[],
        "Change color theme",
        "/theme [name]",
        CommandCategory::General,
        true,
    ));

    registry.register(CommandDef::new(
        "compact",
        &[],
        "Toggle compact display mode",
        "/compact",
        CommandCategory::General,
        false,
    ));

    registry.register(CommandDef::new(
        "palette",
        &["cmd"],
        "Open command palette",
        "/palette",
        CommandCategory::General,
        false,
    ));

    registry.register(CommandDef::new(
        "init",
        &[],
        "Initialize AGENTS.md in project directory",
        "/init [--force]",
        CommandCategory::General,
        true,
    ));

    registry.register(CommandDef::new(
        "commands",
        &["cmds"],
        "List all available custom commands",
        "/commands",
        CommandCategory::General,
        false,
    ));

    registry.register(CommandDef::new(
        "agents",
        &["subagents"],
        "List and manage custom agents",
        "/agents",
        CommandCategory::General,
        false,
    ));

    registry.register(CommandDef::new(
        "tasks",
        &["bg", "background"],
        "View and manage background tasks",
        "/tasks",
        CommandCategory::General,
        false,
    ));

    registry.register(CommandDef::new(
        "skills",
        &["sk"],
        "List and manage skills",
        "/skills",
        CommandCategory::General,
        false,
    ));

    registry.register(CommandDef::new(
        "skill",
        &["invoke"],
        "Invoke a skill by name",
        "/skill <name> [args...]",
        CommandCategory::General,
        true,
    ));

    registry.register(CommandDef::new(
        "skill-reload",
        &["sr"],
        "Reload skills from disk",
        "/skill-reload",
        CommandCategory::General,
        false,
    ));

    registry.register(CommandDef::new(
        "share",
        &[],
        "Generate a share link for current session",
        "/share [duration]",
        CommandCategory::Session,
        true,
    ));

    // ========================================
    // AUTH COMMANDS
    // ========================================

    registry.register(CommandDef::new(
        "login",
        &["signin"],
        "Authenticate with Cortex",
        "/login",
        CommandCategory::Auth,
        false,
    ));

    registry.register(CommandDef::new(
        "logout",
        &["signout"],
        "Clear stored credentials",
        "/logout",
        CommandCategory::Auth,
        false,
    ));

    registry.register(CommandDef::new(
        "account",
        &["whoami", "me"],
        "Show account information",
        "/account",
        CommandCategory::Auth,
        false,
    ));

    // ========================================
    // BILLING COMMANDS
    // ========================================

    registry.register(CommandDef::new(
        "billing",
        &["plan", "subscription"],
        "Show billing status and credits",
        "/billing",
        CommandCategory::Billing,
        false,
    ));

    registry.register(CommandDef::new(
        "usage",
        &["stats", "credits"],
        "Show detailed usage breakdown",
        "/usage [--from YYYY-MM-DD] [--to YYYY-MM-DD]",
        CommandCategory::Billing,
        true,
    ));

    registry.register(CommandDef::new(
        "refresh",
        &["retry"],
        "Refresh billing status after adding payment method",
        "/refresh",
        CommandCategory::Billing,
        false,
    ));

    // ========================================
    // SESSION COMMANDS
    // ========================================

    registry.register(CommandDef::new(
        "session",
        &["info"],
        "Show current session info",
        "/session",
        CommandCategory::Session,
        false,
    ));

    registry.register(CommandDef::new(
        "clear",
        &["cls"],
        "Clear current conversation",
        "/clear",
        CommandCategory::Session,
        false,
    ));

    registry.register(CommandDef::new(
        "new",
        &["n"],
        "Start a new session",
        "/new",
        CommandCategory::Session,
        false,
    ));

    registry.register(CommandDef::new(
        "resume",
        &["r", "load"],
        "Resume a previous session",
        "/resume [session-id]",
        CommandCategory::Session,
        true,
    ));

    registry.register(CommandDef::new(
        "sessions",
        &["list", "ls-sessions"],
        "List all sessions",
        "/sessions",
        CommandCategory::Session,
        false,
    ));

    registry.register(CommandDef::new(
        "fork",
        &["branch"],
        "Fork current session",
        "/fork [name]",
        CommandCategory::Session,
        true,
    ));

    registry.register(CommandDef::new(
        "rename",
        &["mv"],
        "Rename current session",
        "/rename <name>",
        CommandCategory::Session,
        true,
    ));

    registry.register(CommandDef::new(
        "favorite",
        &["fav", "star"],
        "Mark session as favorite",
        "/favorite",
        CommandCategory::Session,
        false,
    ));

    registry.register(CommandDef::new(
        "unfavorite",
        &["unfav", "unstar"],
        "Remove favorite mark",
        "/unfavorite",
        CommandCategory::Session,
        false,
    ));

    registry.register(CommandDef::new(
        "export",
        &["save"],
        "Export session to file",
        "/export [format]",
        CommandCategory::Session,
        true,
    ));

    registry.register(CommandDef::new(
        "timeline",
        &["tl"],
        "View session timeline",
        "/timeline",
        CommandCategory::Session,
        false,
    ));

    registry.register(CommandDef::new(
        "rewind",
        &["rw"],
        "Rewind to a previous point",
        "/rewind [steps]",
        CommandCategory::Session,
        true,
    ));

    registry.register(CommandDef::new(
        "undo",
        &["u"],
        "Undo last action",
        "/undo",
        CommandCategory::Session,
        false,
    ));

    registry.register(CommandDef::new(
        "redo",
        &[],
        "Redo last undone action",
        "/redo",
        CommandCategory::Session,
        false,
    ));

    registry.register(CommandDef::new(
        "delete",
        &["rm"],
        "Delete a session",
        "/delete [session-id]",
        CommandCategory::Session,
        true,
    ));

    // ========================================
    // NAVIGATION COMMANDS
    // ========================================

    registry.register(CommandDef::new(
        "diff",
        &["d"],
        "Show file diff",
        "/diff [file]",
        CommandCategory::Navigation,
        true,
    ));

    registry.register(CommandDef::new(
        "transcript",
        &["tr"],
        "View session transcript",
        "/transcript",
        CommandCategory::Navigation,
        false,
    ));

    registry.register(CommandDef::new(
        "history",
        &["hist"],
        "View command history",
        "/history",
        CommandCategory::Navigation,
        false,
    ));

    registry.register(CommandDef::new(
        "scroll",
        &[],
        "Scroll to position",
        "/scroll <top|bottom|n>",
        CommandCategory::Navigation,
        true,
    ));

    registry.register(CommandDef::new(
        "goto",
        &["g"],
        "Go to message number",
        "/goto <n>",
        CommandCategory::Navigation,
        true,
    ));

    // ========================================
    // FILE COMMANDS
    // ========================================

    registry.register(CommandDef::new(
        "add",
        &["a", "include"],
        "Add file to context",
        "/add <file>...",
        CommandCategory::Files,
        true,
    ));

    registry.register(CommandDef::new(
        "remove",
        &["rm-file", "exclude"],
        "Remove file from context",
        "/remove <file>...",
        CommandCategory::Files,
        true,
    ));

    registry.register(CommandDef::new(
        "search",
        &["find", "grep"],
        "Search in files",
        "/search <pattern>",
        CommandCategory::Files,
        true,
    ));

    registry.register(CommandDef::new(
        "ls",
        &["dir", "files"],
        "List files in directory",
        "/ls [path]",
        CommandCategory::Files,
        true,
    ));

    registry.register(CommandDef::new(
        "mention",
        &["@", "ref"],
        "Mention a file or symbol",
        "/mention <file|symbol>",
        CommandCategory::Files,
        true,
    ));

    registry.register(CommandDef::new(
        "images",
        &["img", "pics"],
        "Add images to context",
        "/images <file>...",
        CommandCategory::Files,
        true,
    ));

    registry.register(CommandDef::new(
        "tree",
        &[],
        "Show directory tree",
        "/tree [path]",
        CommandCategory::Files,
        true,
    ));

    registry.register(CommandDef::new(
        "context",
        &["ctx"],
        "Show current context files",
        "/context",
        CommandCategory::Files,
        false,
    ));

    // ========================================
    // MODEL COMMANDS
    // ========================================

    registry.register(CommandDef::new(
        "model",
        &["m"],
        "Switch to a model",
        "/model <name>",
        CommandCategory::Model,
        true,
    ));

    registry.register(CommandDef::new(
        "models",
        &["lm", "list-models"],
        "List available models",
        "/models",
        CommandCategory::Model,
        false,
    ));

    registry.register(CommandDef::new(
        "approval",
        &["approve"],
        "Set tool approval mode",
        "/approval <ask|session|always>",
        CommandCategory::Model,
        true,
    ));

    registry.register(CommandDef::new(
        "sandbox",
        &["sb"],
        "Toggle sandbox mode",
        "/sandbox [on|off]",
        CommandCategory::Model,
        true,
    ));

    registry.register(CommandDef::new(
        "auto",
        &["autopilot"],
        "Toggle auto-approve mode",
        "/auto [on|off]",
        CommandCategory::Model,
        true,
    ));

    // NOTE: /provider and /providers are deprecated. Cortex is now a unified platform.
    // These commands are hidden from help but still work (with deprecation warning).
    registry.register(CommandDef::hidden(
        "provider",
        &["prov"],
        "[Deprecated] Switch provider - Cortex is now a unified platform",
        "/provider <name>",
        CommandCategory::Model,
        true,
    ));

    registry.register(CommandDef::hidden(
        "providers",
        &["lp", "list-providers"],
        "[Deprecated] List available providers - Cortex is now a unified platform",
        "/providers",
        CommandCategory::Model,
        false,
    ));

    registry.register(CommandDef::new(
        "temperature",
        &["temp"],
        "Set temperature",
        "/temperature <0.0-2.0>",
        CommandCategory::Model,
        true,
    ));

    registry.register(CommandDef::new(
        "tokens",
        &["max-tokens"],
        "Set max tokens",
        "/tokens <n>",
        CommandCategory::Model,
        true,
    ));

    // ========================================
    // MCP COMMANDS
    // ========================================

    registry.register(CommandDef::new(
        "mcp",
        &[],
        "MCP server management (interactive)",
        "/mcp",
        CommandCategory::Mcp,
        false,
    ));

    // NOTE: /mcp-tools, /mcp-auth, /mcp-reload, /mcp-logs are deprecated.
    // All MCP management is now centralized in the interactive /mcp panel.
    // These commands are hidden but still work for backwards compatibility.
    registry.register(CommandDef::hidden(
        "mcp-tools",
        &["tools", "lt"],
        "[Deprecated] Use /mcp instead - List MCP tools",
        "/mcp-tools [server]",
        CommandCategory::Mcp,
        true,
    ));

    registry.register(CommandDef::hidden(
        "mcp-auth",
        &["auth"],
        "[Deprecated] Use /mcp instead - Authenticate MCP server",
        "/mcp-auth <server>",
        CommandCategory::Mcp,
        true,
    ));

    registry.register(CommandDef::hidden(
        "mcp-reload",
        &["reload"],
        "[Deprecated] Use /mcp instead - Reload MCP servers",
        "/mcp-reload [server]",
        CommandCategory::Mcp,
        true,
    ));

    registry.register(CommandDef::hidden(
        "mcp-logs",
        &[],
        "[Deprecated] Use /mcp instead - View MCP server logs",
        "/mcp-logs [server]",
        CommandCategory::Mcp,
        true,
    ));

    // ========================================
    // DEBUG COMMANDS
    // ========================================

    registry.register(CommandDef::new(
        "debug",
        &["dbg"],
        "Toggle debug mode",
        "/debug [on|off]",
        CommandCategory::Debug,
        true,
    ));

    registry.register(CommandDef::new(
        "status",
        &["stat"],
        "Show application status",
        "/status",
        CommandCategory::Debug,
        false,
    ));

    registry.register(CommandDef::new(
        "config",
        &["cfg"],
        "Show configuration",
        "/config [key]",
        CommandCategory::Debug,
        true,
    ));

    registry.register(CommandDef::new(
        "logs",
        &["log"],
        "View application logs",
        "/logs [level]",
        CommandCategory::Debug,
        true,
    ));

    registry.register(CommandDef::new(
        "dump",
        &[],
        "Dump session state",
        "/dump [file]",
        CommandCategory::Debug,
        true,
    ));

    registry.register(CommandDef::new(
        "metrics",
        &["perf"],
        "Show performance metrics",
        "/metrics",
        CommandCategory::Debug,
        false,
    ));

    registry.register(CommandDef::hidden(
        "crash",
        &[],
        "Test crash handler",
        "/crash",
        CommandCategory::Debug,
        false,
    ));

    registry.register(CommandDef::hidden(
        "eval",
        &[],
        "Evaluate expression",
        "/eval <expr>",
        CommandCategory::Debug,
        true,
    ));
}

// ============================================================
// TESTS
// ============================================================

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_registry_new() {
        let registry = CommandRegistry::new();
        assert!(registry.is_empty());
    }

    #[test]
    fn test_registry_default_has_commands() {
        let registry = CommandRegistry::default();
        assert!(!registry.is_empty());
        assert!(registry.len() >= 49);
    }

    #[test]
    fn test_registry_get_by_name() {
        let registry = CommandRegistry::default();

        let help = registry.get("help").unwrap();
        assert_eq!(help.name, "help");
        assert_eq!(help.category, CommandCategory::General);
    }

    #[test]
    fn test_registry_get_by_alias() {
        let registry = CommandRegistry::default();

        let help = registry.get("h").unwrap();
        assert_eq!(help.name, "help");

        let help = registry.get("?").unwrap();
        assert_eq!(help.name, "help");
    }

    #[test]
    fn test_registry_case_insensitive() {
        let registry = CommandRegistry::default();

        assert!(registry.get("HELP").is_some());
        assert!(registry.get("Help").is_some());
        assert!(registry.get("H").is_some());
    }

    #[test]
    fn test_registry_get_nonexistent() {
        let registry = CommandRegistry::default();
        assert!(registry.get("nonexistent").is_none());
    }

    #[test]
    fn test_registry_exists() {
        let registry = CommandRegistry::default();

        assert!(registry.exists("help"));
        assert!(registry.exists("h"));
        assert!(!registry.exists("nonexistent"));
    }

    #[test]
    fn test_registry_get_by_category() {
        let registry = CommandRegistry::default();

        let general = registry.get_by_category(CommandCategory::General);
        assert!(!general.is_empty());
        assert!(
            general
                .iter()
                .all(|cmd| cmd.category == CommandCategory::General)
        );

        let session = registry.get_by_category(CommandCategory::Session);
        assert!(!session.is_empty());
        assert!(
            session
                .iter()
                .all(|cmd| cmd.category == CommandCategory::Session)
        );
    }

    #[test]
    fn test_registry_all_sorted() {
        let registry = CommandRegistry::default();
        let all = registry.all();

        // Check sorted order
        for i in 1..all.len() {
            assert!(all[i - 1].name <= all[i].name);
        }
    }

    #[test]
    fn test_registry_hidden_commands() {
        let registry = CommandRegistry::default();

        // Hidden commands should exist
        assert!(registry.exists("crash"));

        // But not appear in all()
        let all = registry.all();
        assert!(!all.iter().any(|cmd| cmd.name == "crash"));

        // But appear in all_including_hidden()
        let all_hidden = registry.all_including_hidden();
        assert!(all_hidden.iter().any(|cmd| cmd.name == "crash"));
    }

    #[test]
    fn test_registry_command_names() {
        let registry = CommandRegistry::default();
        let names = registry.command_names();

        assert!(names.contains(&"help"));
        assert!(names.contains(&"quit"));
        assert!(!names.contains(&"h")); // alias, not primary
    }

    #[test]
    fn test_registry_all_names() {
        let registry = CommandRegistry::default();
        let names = registry.all_names();

        assert!(names.contains(&"help"));
        assert!(names.contains(&"h")); // includes aliases
        assert!(names.contains(&"?"));
    }

    #[test]
    fn test_specific_commands_registered() {
        let registry = CommandRegistry::default();

        // General
        assert!(registry.exists("help"));
        assert!(registry.exists("quit"));
        assert!(registry.exists("version"));
        assert!(registry.exists("settings"));
        assert!(registry.exists("theme"));
        assert!(registry.exists("compact"));
        assert!(registry.exists("init"));
        assert!(registry.exists("commands"));
        assert!(registry.exists("agents"));

        // Session
        assert!(registry.exists("clear"));
        assert!(registry.exists("share"));
        assert!(registry.exists("new"));
        assert!(registry.exists("resume"));
        assert!(registry.exists("sessions"));
        assert!(registry.exists("fork"));
        assert!(registry.exists("rename"));
        assert!(registry.exists("favorite"));
        assert!(registry.exists("unfavorite"));
        assert!(registry.exists("export"));
        assert!(registry.exists("timeline"));
        assert!(registry.exists("rewind"));
        assert!(registry.exists("undo"));
        assert!(registry.exists("redo"));

        // Navigation
        assert!(registry.exists("diff"));
        assert!(registry.exists("transcript"));
        assert!(registry.exists("history"));

        // Files
        assert!(registry.exists("add"));
        assert!(registry.exists("remove"));
        assert!(registry.exists("search"));
        assert!(registry.exists("ls"));
        assert!(registry.exists("mention"));
        assert!(registry.exists("images"));

        // Model
        assert!(registry.exists("model"));
        assert!(registry.exists("models"));
        assert!(registry.exists("approval"));
        assert!(registry.exists("sandbox"));
        assert!(registry.exists("auto"));

        // MCP
        assert!(registry.exists("mcp"));
        assert!(registry.exists("mcp-tools"));
        assert!(registry.exists("mcp-auth"));
        assert!(registry.exists("mcp-reload"));

        // Auth
        assert!(registry.exists("login"));
        assert!(registry.exists("logout"));
        assert!(registry.exists("account"));

        // Debug
        assert!(registry.exists("debug"));
        assert!(registry.exists("status"));
        assert!(registry.exists("config"));
        assert!(registry.exists("logs"));
    }

    #[test]
    fn test_auth_commands_registered() {
        let registry = CommandRegistry::default();

        // Login command
        let login = registry.get("login").unwrap();
        assert_eq!(login.name, "login");
        assert_eq!(login.category, CommandCategory::Auth);
        assert!(login.aliases.contains(&"signin"));

        // Logout command
        let logout = registry.get("logout").unwrap();
        assert_eq!(logout.name, "logout");
        assert_eq!(logout.category, CommandCategory::Auth);
        assert!(logout.aliases.contains(&"signout"));

        // Account command
        let account = registry.get("account").unwrap();
        assert_eq!(account.name, "account");
        assert_eq!(account.category, CommandCategory::Auth);
        assert!(account.aliases.contains(&"whoami"));
        assert!(account.aliases.contains(&"me"));
    }

    #[test]
    fn test_auth_aliases() {
        let registry = CommandRegistry::default();

        // Signin alias
        let signin = registry.get("signin").unwrap();
        assert_eq!(signin.name, "login");

        // Signout alias
        let signout = registry.get("signout").unwrap();
        assert_eq!(signout.name, "logout");

        // Whoami alias
        let whoami = registry.get("whoami").unwrap();
        assert_eq!(whoami.name, "account");

        // Me alias
        let me = registry.get("me").unwrap();
        assert_eq!(me.name, "account");
    }

    #[test]
    fn test_auth_category() {
        let registry = CommandRegistry::default();
        let auth_commands = registry.get_by_category(CommandCategory::Auth);

        assert!(!auth_commands.is_empty());
        assert_eq!(auth_commands.len(), 3);

        let names: Vec<_> = auth_commands.iter().map(|c| c.name).collect();
        assert!(names.contains(&"login"));
        assert!(names.contains(&"logout"));
        assert!(names.contains(&"account"));
    }
}