opendev-tui 0.1.4

Ratatui-based terminal UI for OpenDev
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! MCP command controller for managing MCP servers via slash commands.
//!
//! Mirrors the `/mcp list|add|remove|enable|disable` commands from
//! `opendev/ui_textual/controllers/mcp_command_controller.py`.

/// Information about an MCP server.
#[derive(Debug, Clone)]
pub struct McpServerInfo {
    /// Server name/alias.
    pub name: String,
    /// Command to launch the server.
    pub command: String,
    /// Whether the server is currently enabled.
    pub enabled: bool,
}

/// Controller for handling MCP server management commands.
pub struct McpCommandController {
    servers: Vec<McpServerInfo>,
}

impl McpCommandController {
    /// Create a new controller with the given server list.
    pub fn new(servers: Vec<McpServerInfo>) -> Self {
        Self { servers }
    }

    /// Get the current server list.
    pub fn servers(&self) -> &[McpServerInfo] {
        &self.servers
    }

    /// Handle an MCP subcommand string (e.g. "list", "add myserver uvx cmd").
    ///
    /// Returns a human-readable response string.
    pub fn handle_command(&mut self, args: &str) -> String {
        let parts: Vec<&str> = args.trim().splitn(2, char::is_whitespace).collect();
        let subcommand = parts.first().copied().unwrap_or("");
        let rest = parts.get(1).copied().unwrap_or("").trim();

        match subcommand {
            "list" | "" => self.list_servers(),
            "add" => self.add_server(rest),
            "remove" => self.remove_server(rest),
            "enable" => self.enable_server(rest),
            "disable" => self.disable_server(rest),
            other => format!(
                "Unknown MCP subcommand: '{}'. Use list/add/remove/enable/disable.",
                other
            ),
        }
    }

    fn list_servers(&self) -> String {
        if self.servers.is_empty() {
            return "No MCP servers configured.".into();
        }
        let mut lines = vec!["MCP Servers:".to_string()];
        for (i, server) in self.servers.iter().enumerate() {
            let status = if server.enabled {
                "enabled"
            } else {
                "disabled"
            };
            lines.push(format!(
                "  {}. {} ({}) [{}]",
                i + 1,
                server.name,
                server.command,
                status,
            ));
        }
        lines.join("\n")
    }

    fn add_server(&mut self, rest: &str) -> String {
        let parts: Vec<&str> = rest.splitn(2, char::is_whitespace).collect();
        let name = parts.first().copied().unwrap_or("").trim();
        let command = parts.get(1).copied().unwrap_or("").trim();

        if name.is_empty() || command.is_empty() {
            return "Usage: mcp add <name> <command>".into();
        }

        if self.servers.iter().any(|s| s.name == name) {
            return format!("Server '{}' already exists.", name);
        }

        self.servers.push(McpServerInfo {
            name: name.to_string(),
            command: command.to_string(),
            enabled: true,
        });
        format!("Added MCP server '{}'.", name)
    }

    fn remove_server(&mut self, name: &str) -> String {
        let name = name.trim();
        if name.is_empty() {
            return "Usage: mcp remove <name>".into();
        }
        let before = self.servers.len();
        self.servers.retain(|s| s.name != name);
        if self.servers.len() < before {
            format!("Removed MCP server '{}'.", name)
        } else {
            format!("Server '{}' not found.", name)
        }
    }

    fn enable_server(&mut self, name: &str) -> String {
        let name = name.trim();
        if let Some(server) = self.servers.iter_mut().find(|s| s.name == name) {
            server.enabled = true;
            format!("Enabled MCP server '{}'.", name)
        } else {
            format!("Server '{}' not found.", name)
        }
    }

    fn disable_server(&mut self, name: &str) -> String {
        let name = name.trim();
        if let Some(server) = self.servers.iter_mut().find(|s| s.name == name) {
            server.enabled = false;
            format!("Disabled MCP server '{}'.", name)
        } else {
            format!("Server '{}' not found.", name)
        }
    }
}

#[cfg(test)]
#[path = "mcp_command_tests.rs"]
mod tests;