feat: update TUI MCP Manager Modal to support remote registry

- Add RegistryEntry and RegistrySource types in registry.rs
- Add From<RegistryServer> impl to convert remote entries
- Add get_local_registry_entries() and get_remote_server_config()
- Add RegistryLoadState enum in types.rs
- Update SelectFromRegistry mode to include entries and load_state
- Update handlers to work with new RegistryEntry structure
- Update rendering to display category and required env indicators
- Re-export remote registry types for future async loading

Author: echobt

src/cortex-tui/src/modal/mcp_manager/handlers.rs

@@ -2,10 +2,11 @@
 //!
 //! Contains all key event handling for the MCP Manager modal.
 
-use super::registry::{get_registry_server_config, get_registry_servers};
+use super::registry::{get_local_registry_entries, get_registry_server_config};
 use super::state::McpManagerModal;
 use super::types::{
     AddHttpServerFocus, AddStdioServerFocus, McpMode, McpServerSource, McpStatus,
+    RegistryLoadState,
 };
 use crate::modal::{ModalAction, ModalResult};
 use crate::widgets::selection_list::SelectionResult;
@@ -95,10 +96,12 @@ impl McpManagerModal {
                             };
                         }
                         McpServerSource::Registry => {
-                            // Go directly to registry selection
+                            // Go to registry selection with local entries preloaded
                             self.mode = McpMode::SelectFromRegistry {
                                 selected: 0,
                                 search_query: String::new(),
+                                entries: get_local_registry_entries(),
+                                load_state: RegistryLoadState::Loaded,
                             };
                         }
                     }
@@ -300,18 +303,25 @@ impl McpManagerModal {
         if let McpMode::SelectFromRegistry {
             ref mut selected,
             ref mut search_query,
+            ref entries,
+            load_state: _,
         } = self.mode
         {
-            let registry_servers = get_registry_servers();
+            // Filter entries based on search
             let filtered: Vec<_> = if search_query.is_empty() {
-                registry_servers.iter().collect()
+                entries.iter().collect()
             } else {
                 let query_lower = search_query.to_lowercase();
-                registry_servers
+                entries
                     .iter()
-                    .filter(|(name, desc)| {
-                        name.to_lowercase().contains(&query_lower)
-                            || desc.to_lowercase().contains(&query_lower)
+                    .filter(|e| {
+                        e.name.to_lowercase().contains(&query_lower)
+                            || e.description.to_lowercase().contains(&query_lower)
+                            || e.tags.iter().any(|t| t.to_lowercase().contains(&query_lower))
+                            || e.category
+                                .as_ref()
+                                .map(|c| c.to_lowercase().contains(&query_lower))
+                                .unwrap_or(false)
                     })
                     .collect()
             };
@@ -330,11 +340,10 @@ impl McpManagerModal {
                     ModalResult::Continue
                 }
                 KeyCode::Enter => {
-                    if let Some((name, _)) = filtered.get(*selected) {
-                        // For registry servers, we use predefined commands
-                        let (command, args) = get_registry_server_config(name);
+                    if let Some(entry) = filtered.get(*selected) {
+                        let (command, args) = get_registry_server_config(&entry.name);
                         return ModalResult::Action(ModalAction::AddMcpServer {
-                            name: name.to_string(),
+                            name: entry.name.clone(),
                             command,
                             args,
                         });

src/cortex-tui/src/modal/mcp_manager/mod.rs

@@ -59,6 +59,8 @@ impl Modal for McpManagerModal {
             McpMode::SelectFromRegistry {
                 selected: _,
                 search_query,
+                entries: _,
+                load_state: _,
             } => {
                 search_query.push_str(text);
                 true

src/cortex-tui/src/modal/mcp_manager/registry.rs

@@ -1,8 +1,67 @@
 //! MCP Registry
 //!
-//! Contains predefined MCP server configurations from the registry.
+//! Provides access to MCP server configurations from both local fallbacks
+//! and the remote registry at registry.cortex.foundation/mcp
 
-/// Get list of available servers from registry
+use cortex_engine::mcp::RegistryServer;
+
+/// Registry entry for display in the TUI
+#[derive(Debug, Clone)]
+pub struct RegistryEntry {
+    /// Server name
+    pub name: String,
+    /// Description
+    pub description: String,
+    /// Category
+    pub category: Option<String>,
+    /// Vendor
+    pub vendor: Option<String>,
+    /// Tags for search
+    pub tags: Vec<String>,
+    /// Whether stdio transport is available
+    pub has_stdio: bool,
+    /// Whether HTTP transport is available
+    pub has_http: bool,
+    /// Required environment variables
+    pub required_env: Vec<String>,
+    /// Source (local or remote)
+    pub source: RegistrySource,
+}
+
+/// Source of the registry entry
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RegistrySource {
+    /// Local fallback
+    Local,
+    /// Remote registry
+    Remote,
+}
+
+impl From<RegistryServer> for RegistryEntry {
+    fn from(server: RegistryServer) -> Self {
+        let required_env = server
+            .install
+            .stdio
+            .as_ref()
+            .map(|s| s.required_env.clone())
+            .unwrap_or_default();
+
+        Self {
+            name: server.name,
+            description: server.description,
+            category: server.category,
+            vendor: server.vendor,
+            tags: server.tags,
+            has_stdio: server.install.stdio.is_some(),
+            has_http: server.install.http.is_some(),
+            required_env,
+            source: RegistrySource::Remote,
+        }
+    }
+}
+
+/// Get list of available servers from local fallback registry
+/// Returns (name, description) tuples for backwards compatibility
 pub fn get_registry_servers() -> Vec<(&'static str, &'static str)> {
     vec![
         ("filesystem", "File system operations and management"),
@@ -20,7 +79,7 @@ pub fn get_registry_servers() -> Vec<(&'static str, &'static str)> {
     ]
 }
 
-/// Get the command and args for a registry server
+/// Get the command and args for a local registry server
 pub fn get_registry_server_config(name: &str) -> (String, Vec<String>) {
     match name {
         "filesystem" => (
@@ -99,3 +158,49 @@ pub fn get_registry_server_config(name: &str) -> (String, Vec<String>) {
         _ => ("npx".to_string(), vec!["-y".to_string(), name.to_string()]),
     }
 }
+
+/// Get registry entries as RegistryEntry structs
+pub fn get_local_registry_entries() -> Vec<RegistryEntry> {
+    get_registry_servers()
+        .into_iter()
+        .map(|(name, description)| {
+            // Determine required env vars based on server
+            let required_env = match name {
+                "github" => vec!["GITHUB_TOKEN".to_string()],
+                "brave-search" => vec!["BRAVE_API_KEY".to_string()],
+                "google-maps" => vec!["GOOGLE_MAPS_API_KEY".to_string()],
+                "slack" => vec!["SLACK_TOKEN".to_string()],
+                "postgres" => vec!["DATABASE_URL".to_string()],
+                _ => vec![],
+            };
+
+            RegistryEntry {
+                name: name.to_string(),
+                description: description.to_string(),
+                category: None,
+                vendor: None,
+                tags: vec![],
+                has_stdio: true,
+                has_http: false,
+                required_env,
+                source: RegistrySource::Local,
+            }
+        })
+        .collect()
+}
+
+/// Convert a RegistryServer from remote to command/args for installation
+pub fn get_remote_server_config(server: &RegistryServer) -> Option<(String, Vec<String>)> {
+    server
+        .install
+        .stdio
+        .as_ref()
+        .map(|stdio| (stdio.command.clone(), stdio.args.clone()))
+}
+
+// Re-export types for convenience (allow unused imports since they're for API exposure)
+#[allow(unused_imports)]
+pub use cortex_engine::mcp::{
+    HttpConfig as RemoteHttpConfig, McpRegistryClient, RegistryInstallConfig,
+    RegistryServer as RemoteRegistryServer, StdioConfig as RemoteStdioConfig,
+};

src/cortex-tui/src/modal/mcp_manager/rendering.rs

@@ -2,7 +2,7 @@
 //!
 //! Contains all rendering methods for the MCP Manager modal.
 
-use super::registry::get_registry_servers;
+use super::registry::RegistryEntry;
 use super::state::McpManagerModal;
 use super::types::{AddHttpServerFocus, AddStdioServerFocus, McpMode, McpStatus};
 use crate::modal::render_search_bar;
@@ -507,6 +507,8 @@ impl McpManagerModal {
         if let McpMode::SelectFromRegistry {
             selected,
             ref search_query,
+            ref entries,
+            load_state: _,
         } = self.mode
         {
             Clear.render(area, buf);
@@ -548,21 +550,25 @@ impl McpManagerModal {
 
             // Render server list
             let list_area = chunks[2];
-            let registry_servers = get_registry_servers();
-            let filtered: Vec<_> = if search_query.is_empty() {
-                registry_servers.iter().collect()
+            let filtered: Vec<&RegistryEntry> = if search_query.is_empty() {
+                entries.iter().collect()
             } else {
                 let query_lower = search_query.to_lowercase();
-                registry_servers
+                entries
                     .iter()
-                    .filter(|(name, desc)| {
-                        name.to_lowercase().contains(&query_lower)
-                            || desc.to_lowercase().contains(&query_lower)
+                    .filter(|e| {
+                        e.name.to_lowercase().contains(&query_lower)
+                            || e.description.to_lowercase().contains(&query_lower)
+                            || e.tags.iter().any(|t| t.to_lowercase().contains(&query_lower))
+                            || e.category
+                                .as_ref()
+                                .map(|c| c.to_lowercase().contains(&query_lower))
+                                .unwrap_or(false)
                     })
                     .collect()
             };
 
-            for (i, (name, desc)) in filtered.iter().enumerate() {
+            for (i, entry) in filtered.iter().enumerate() {
                 if i as u16 >= list_area.height {
                     break;
                 }
@@ -584,18 +590,32 @@ impl McpManagerModal {
                 } else {
                     Style::default().fg(TEXT)
                 };
-                buf.set_string(list_area.x + 3, y, name, name_style);
-
-                // Description (on same line, after name)
-                let desc_x = list_area.x + 3 + name.len() as u16 + 2;
-                if desc_x < list_area.x + list_area.width {
-                    let max_desc_len = (list_area.x + list_area.width - desc_x) as usize;
-                    let truncated_desc = if desc.len() > max_desc_len {
-                        format!("{}...", &desc[..max_desc_len.saturating_sub(3)])
+                buf.set_string(list_area.x + 3, y, &entry.name, name_style);
+
+                // Category indicator if available
+                let mut desc_start_x = list_area.x + 3 + entry.name.len() as u16 + 1;
+                if let Some(ref category) = entry.category {
+                    let cat_text = format!("[{}]", category);
+                    buf.set_string(desc_start_x, y, &cat_text, Style::default().fg(WARNING));
+                    desc_start_x += cat_text.len() as u16 + 1;
+                }
+
+                // Required env indicator
+                if !entry.required_env.is_empty() {
+                    let env_indicator = "●";
+                    buf.set_string(desc_start_x, y, env_indicator, Style::default().fg(WARNING));
+                    desc_start_x += 2;
+                }
+
+                // Description (on same line, after name and indicators)
+                if desc_start_x < list_area.x + list_area.width {
+                    let max_desc_len = (list_area.x + list_area.width - desc_start_x) as usize;
+                    let truncated_desc = if entry.description.len() > max_desc_len {
+                        format!("{}...", &entry.description[..max_desc_len.saturating_sub(3)])
                     } else {
-                        desc.to_string()
+                        entry.description.clone()
                     };
-                    buf.set_string(desc_x, y, &truncated_desc, Style::default().fg(TEXT_DIM));
+                    buf.set_string(desc_start_x, y, &truncated_desc, Style::default().fg(TEXT_DIM));
                 }
             }
 

src/cortex-tui/src/modal/mcp_manager/types.rs

@@ -78,6 +78,16 @@ pub enum McpTransportType {
     Http,
 }
 
+/// Registry loading state
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum RegistryLoadState {
+    #[default]
+    NotLoaded,
+    Loading,
+    Loaded,
+    Error,
+}
+
 // ============================================================================
 // MODE ENUMS
 // ============================================================================
@@ -113,6 +123,10 @@ pub enum McpMode {
     SelectFromRegistry {
         selected: usize,
         search_query: String,
+        /// Cached registry entries (if loaded)
+        entries: Vec<super::registry::RegistryEntry>,
+        /// Loading state
+        load_state: RegistryLoadState,
     },
     /// Confirming deletion
     ConfirmDelete { server_name: String },