feat(cortex-cli): implement open PR features (#183)

This commit implements features from the following open PRs:

PR #166 - CLI features and behavior improvements:
- Add --yes/-y flag to logout command to skip confirmation prompt
- Add color preview in 'agent show' command (displays hex color as ANSI block)
- Update environment variable names from FABRIC_ to CORTEX_ prefix
  (FABRIC_ still supported for backward compatibility)

PR #136 - MCP server configuration options:
- Add --transport flag (stdio/http, default: stdio)
- Add --port flag for HTTP transport (default: 3001)
- Add --host flag for HTTP transport (default: 127.0.0.1)
- Add --name flag for server name (default: cortex-mcp-server)
- Add mcp-http feature flag for HTTP transport support

Additional improvements:
- Add cortex-mcp-server dependency to cortex-cli
- Update debug command to show both CORTEX_ and FABRIC_ env vars
- Improve documentation for environment variables

Author: factorydroid

Cargo.lock

@@ -20,6 +20,8 @@ workspace = true
 default = ["cortex-tui"]
 # Use the new Cortex TUI (120 FPS, Cortex theme)
 cortex-tui = ["dep:cortex-tui"]
+# Enable HTTP transport for MCP server
+mcp-http = ["cortex-mcp-server/http"]
 
 [dependencies]
 cortex-engine = { workspace = true }
@@ -31,6 +33,7 @@ cortex-login = { workspace = true }
 cortex-process-hardening = { workspace = true }
 cortex-app-server = { workspace = true }
 cortex-update = { workspace = true }
+cortex-mcp-server = { workspace = true }
 
 clap = { workspace = true }
 clap_complete = { workspace = true }

cortex-cli/Cargo.toml

@@ -839,7 +839,9 @@ async fn run_show(args: ShowArgs) -> Result<()> {
     }
 
     if let Some(ref color) = agent.color {
-        println!("Color: {color}");
+        // Display color with preview (colored block using ANSI escape codes)
+        let color_preview = format_color_preview(color);
+        println!("Color: {color} {color_preview}");
     }
 
     if !agent.tags.is_empty() {
@@ -1512,6 +1514,30 @@ Provide architectural recommendations with:
 - Implementation roadmap
 "#;
 
+/// Format a hex color as an ANSI-colored preview block.
+///
+/// Converts a hex color like "#FF5733" to an ANSI escape sequence that
+/// displays a colored block (using true color if supported).
+fn format_color_preview(hex_color: &str) -> String {
+    // Parse hex color (strip leading # if present)
+    let hex = hex_color.trim_start_matches('#');
+
+    // Only process valid 6-character hex colors
+    if hex.len() != 6 {
+        return String::new();
+    }
+
+    // Parse RGB components
+    let r = u8::from_str_radix(&hex[0..2], 16).unwrap_or(128);
+    let g = u8::from_str_radix(&hex[2..4], 16).unwrap_or(128);
+    let b = u8::from_str_radix(&hex[4..6], 16).unwrap_or(128);
+
+    // Create ANSI true color (24-bit) escape sequence for background
+    // Format: \x1b[48;2;R;G;Bm (background color)
+    // Use 2 space characters as the "block" with reset at end
+    format!("\x1b[48;2;{};{};{}m  \x1b[0m", r, g, b)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

cortex-cli/src/agent_cmd.rs

@@ -262,9 +262,7 @@ pub fn maybe_prompt_completion_setup() {
     println!();
     println!("Welcome to Cortex CLI!");
     println!();
-    println!(
-        "Would you like to enable tab completion for your shell ({shell_str})?",
-    );
+    println!("Would you like to enable tab completion for your shell ({shell_str})?",);
     println!("This will allow you to press TAB to complete commands and options.");
     println!();
     print!("Enable tab completion? [y/N] ");

cortex-cli/src/completion_setup.rs

@@ -128,20 +128,28 @@ async fn run_config(args: ConfigArgs) -> Result<()> {
 
     let environment = if args.env {
         let mut env_vars = HashMap::new();
-        let fabric_vars = [
+        // Cortex environment variables (CORTEX_ prefix is preferred, FABRIC_ supported for compat)
+        let cortex_vars = [
+            "CORTEX_HOME",
+            "CORTEX_MODEL",
+            "CORTEX_PROVIDER",
+            "CORTEX_API_KEY",
+            "CORTEX_DEBUG",
+            "CORTEX_LOG_LEVEL",
+            "CORTEX_AUTH_TOKEN",
+            "CORTEX_API_URL",
+            // Legacy FABRIC_ variables (backward compatibility)
             "FABRIC_HOME",
             "FABRIC_MODEL",
             "FABRIC_PROVIDER",
-            "CORTEX_API_KEY",
             "FABRIC_DEBUG",
             "FABRIC_LOG_LEVEL",
-            "CORTEX_AUTH_TOKEN",
-            "CORTEX_API_URL",
+            // Standard environment variables
             "EDITOR",
             "VISUAL",
             "SHELL",
         ];
-        for var in fabric_vars {
+        for var in cortex_vars {
             if let Ok(val) = std::env::var(var) {
                 // Mask API keys
                 let display_val = if var.contains("API_KEY") || var.contains("SECRET") {

cortex-cli/src/debug_cmd.rs

@@ -139,15 +139,20 @@ pub async fn run_login_status(config_overrides: CliConfigOverrides) -> ! {
 }
 
 /// Run logout.
-pub async fn run_logout(config_overrides: CliConfigOverrides) -> ! {
+///
+/// # Arguments
+/// * `config_overrides` - CLI configuration overrides
+/// * `skip_confirmation` - If true, skip the confirmation prompt (--yes flag)
+pub async fn run_logout(config_overrides: CliConfigOverrides, skip_confirmation: bool) -> ! {
     check_duplicate_config_overrides(&config_overrides);
     let fabric_home = get_fabric_home();
 
     // Check if user is logged in first
     match load_auth_with_fallback(&fabric_home) {
         Ok(Some(_)) => {
             // User is logged in, ask for confirmation if terminal is interactive
-            if std::io::stdin().is_terminal() {
+            // unless --yes flag is passed
+            if !skip_confirmation && std::io::stdin().is_terminal() {
                 eprint!(
                     "Are you sure you want to log out? This will remove your stored credentials. [y/N]: "
                 );

cortex-cli/src/login.rs

@@ -39,7 +39,7 @@ use cortex_common::CliConfigOverrides;
 /// Log verbosity level for CLI output.
 ///
 /// Controls the amount of logging detail shown. Can also be set via
-/// the FABRIC_LOG_LEVEL environment variable.
+/// the CORTEX_LOG_LEVEL environment variable.
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, clap::ValueEnum)]
 pub enum LogLevel {
     /// Only show errors
@@ -176,7 +176,7 @@ struct InteractiveArgs {
     images: Vec<PathBuf>,
 
     /// Set log verbosity level (error, warn, info, debug, trace)
-    /// Can also be set via FABRIC_LOG_LEVEL environment variable
+    /// Can also be set via CORTEX_LOG_LEVEL environment variable
     #[arg(long = "log-level", short = 'L', value_enum, default_value = "info")]
     log_level: LogLevel,
 
@@ -211,8 +211,10 @@ enum Commands {
     /// Manage agents (list, create, show)
     Agent(AgentCli),
 
-    /// Run the MCP server (stdio transport)
-    McpServer,
+    /// Run the MCP server.
+    /// Exposes Cortex tools via the Model Context Protocol for integration
+    /// with other AI applications and IDEs.
+    McpServer(McpServerCommand),
 
     /// Generate shell completion scripts
     Completion(CompletionCommand),
@@ -350,6 +352,11 @@ enum LoginSubcommand {
 struct LogoutCommand {
     #[clap(skip)]
     config_overrides: CliConfigOverrides,
+
+    /// Skip confirmation prompt and log out immediately.
+    /// Useful for scripting and automation.
+    #[arg(short = 'y', long = "yes")]
+    yes: bool,
 }
 
 /// Completion command.
@@ -368,6 +375,28 @@ struct ManCommand {
     output: Option<PathBuf>,
 }
 
+/// MCP Server command.
+#[derive(Args)]
+struct McpServerCommand {
+    /// Transport to use for MCP communication.
+    /// - stdio: Standard input/output (default, used by Claude Desktop, VS Code, etc.)
+    /// - http: HTTP JSON-RPC server (for web clients)
+    #[arg(long, default_value = "stdio")]
+    transport: String,
+
+    /// Port for HTTP transport (ignored for stdio).
+    #[arg(long, default_value_t = 3001)]
+    port: u16,
+
+    /// Host to bind for HTTP transport (ignored for stdio).
+    #[arg(long, default_value = "127.0.0.1")]
+    host: String,
+
+    /// Server name advertised to MCP clients.
+    #[arg(long, default_value = "cortex-mcp-server")]
+    name: String,
+}
+
 /// Resume command.
 #[derive(Args)]
 struct ResumeCommand {
@@ -509,12 +538,15 @@ async fn main() -> Result<()> {
     // Initialize logging only for non-TUI commands
     // TUI mode has its own file-based logging to avoid stdout pollution
     if cli.command.is_some() {
-        // Determine log level with precedence: --debug flag > --log-level > FABRIC_LOG_LEVEL env > default (info)
+        // Determine log level with precedence: --debug flag > --log-level > CORTEX_LOG_LEVEL env > default (info)
+        // Note: FABRIC_LOG_LEVEL is still supported for backward compatibility
         let log_level = if cli.interactive.debug {
             // Deprecated --debug flag takes precedence for backward compatibility
             LogLevel::Debug
-        } else if let Ok(env_level) = std::env::var("FABRIC_LOG_LEVEL") {
-            // Check environment variable
+        } else if let Ok(env_level) =
+            std::env::var("CORTEX_LOG_LEVEL").or_else(|_| std::env::var("FABRIC_LOG_LEVEL"))
+        {
+            // Check environment variable (CORTEX_LOG_LEVEL preferred, FABRIC_LOG_LEVEL for compat)
             LogLevel::from_str_loose(&env_level).unwrap_or(cli.interactive.log_level)
         } else {
             cli.interactive.log_level
@@ -578,16 +610,12 @@ async fn main() -> Result<()> {
             Ok(())
         }
         Some(Commands::Logout(logout_cli)) => {
-            run_logout(logout_cli.config_overrides).await;
+            run_logout(logout_cli.config_overrides, logout_cli.yes).await;
             Ok(())
         }
         Some(Commands::Mcp(mcp_cli)) => mcp_cli.run().await,
         Some(Commands::Agent(agent_cli)) => agent_cli.run().await,
-        Some(Commands::McpServer) => {
-            bail!(
-                "MCP server mode is not yet implemented. Use 'cortex mcp' for MCP server management."
-            );
-        }
+        Some(Commands::McpServer(mcp_server_cli)) => run_mcp_server(mcp_server_cli).await,
         Some(Commands::Completion(completion_cli)) => {
             generate_completions(completion_cli.shell);
             Ok(())
@@ -1333,6 +1361,58 @@ async fn run_serve(serve_cli: ServeCommand) -> Result<()> {
     result.map_err(Into::into)
 }
 
+/// Run the MCP server with the specified configuration.
+async fn run_mcp_server(mcp_server_cli: McpServerCommand) -> Result<()> {
+    use cortex_mcp_server::McpServerBuilder;
+
+    eprintln!("Starting Cortex MCP server...");
+    eprintln!("  Transport: {}", mcp_server_cli.transport);
+    eprintln!("  Name: {}", mcp_server_cli.name);
+
+    // Build the MCP server
+    let version = env!("CARGO_PKG_VERSION");
+    let server = McpServerBuilder::new(&mcp_server_cli.name, version).build()?;
+
+    match mcp_server_cli.transport.to_lowercase().as_str() {
+        "stdio" => {
+            eprintln!("  Mode: stdio (reading from stdin, writing to stdout)");
+            eprintln!();
+            // Run stdio transport
+            server.run_stdio().await?;
+        }
+        "http" => {
+            // HTTP transport requires the "http" feature in cortex-mcp-server
+            #[cfg(feature = "mcp-http")]
+            {
+                let addr: std::net::SocketAddr =
+                    format!("{}:{}", mcp_server_cli.host, mcp_server_cli.port)
+                        .parse()
+                        .context("Invalid host:port address")?;
+                eprintln!("  Listening: http://{}", addr);
+                eprintln!();
+                // Run HTTP transport
+                server.run_http(addr).await?;
+            }
+            #[cfg(not(feature = "mcp-http"))]
+            {
+                bail!(
+                    "HTTP transport is not available. The MCP server was built without HTTP support.\n\
+                     Use --transport stdio (default) for stdio transport, which is compatible with\n\
+                     Claude Desktop, VS Code MCP extensions, and other MCP clients."
+                );
+            }
+        }
+        other => {
+            bail!(
+                "Unknown transport '{}'. Supported transports: stdio, http",
+                other
+            );
+        }
+    }
+
+    Ok(())
+}
+
 async fn run_servers(servers_cli: ServersCommand) -> Result<()> {
     use cortex_engine::MdnsBrowser;
     use std::time::Duration;