fix: batch fixes for issues #1979, 1980, 1981, 1983, 1985, 1987, 1988, 1989, 1991, 1993 [skip ci] (#370)

Fixes:
- #1979: Add --pretty flag to format JSON responses in scrape command
- #1980: Add XML formatting support with --pretty flag in scrape command
- #1981: Add description length validation (max 1000 chars) in agent create
- #1983: Improve panic hook to detect and show helpful messages for resource limit errors
- #1985: Improve timeout error messages to clearly state the timeout duration
- #1987: Validate header values don't exceed 8KB HTTP spec limit
- #1988: Warn about duplicate headers in scrape command
- #1989: Use safe_println! in mcp debug to handle broken pipe gracefully
- #1991: Add --full flag to show full model IDs without truncation
- #1993: Add --sort flag (id, name, provider) to models list command

Co-authored-by: Bounty Bot <bounty-bot@factory.ai>

Author: echobt

cortex-cli/src/agent_cmd.rs

@@ -1283,6 +1283,18 @@ async fn run_create(args: CreateArgs) -> Result<()> {
         )?
     };
 
+    // Validate description length (Issue #1981)
+    // Maximum description length: 1000 characters (reasonable for display and storage)
+    const MAX_DESCRIPTION_LENGTH: usize = 1000;
+    if description.len() > MAX_DESCRIPTION_LENGTH {
+        bail!(
+            "Description exceeds maximum length of {} characters ({} provided). \
+            Please use a shorter description.",
+            MAX_DESCRIPTION_LENGTH,
+            description.len()
+        );
+    }
+
     // Get mode
     let mode = if let Some(ref m) = args.mode {
         m.parse::<AgentMode>().map_err(|e| anyhow::anyhow!(e))?

cortex-cli/src/lib.rs

@@ -155,6 +155,41 @@ fn install_panic_hook() {
         // Restore terminal state before printing panic message
         restore_terminal();
 
+        // Extract panic message to check for resource limit issues (Issue #1983)
+        let panic_message = if let Some(s) = panic_info.payload().downcast_ref::<&str>() {
+            s.to_string()
+        } else if let Some(s) = panic_info.payload().downcast_ref::<String>() {
+            s.clone()
+        } else {
+            String::new()
+        };
+
+        // Check for common resource limit error patterns
+        let is_resource_limit = panic_message.contains("Resource temporarily unavailable")
+            || panic_message.contains("EAGAIN")
+            || panic_message.contains("Cannot allocate memory")
+            || panic_message.contains("ENOMEM")
+            || panic_message.contains("Too many open files")
+            || panic_message.contains("EMFILE")
+            || panic_message.contains("No space left on device")
+            || panic_message.contains("ENOSPC")
+            || panic_message.contains("cannot spawn")
+            || panic_message.contains("thread 'main' panicked")
+                && panic_message.contains("Os { code: 11");
+
+        if is_resource_limit {
+            eprintln!("\nError: System resource limit reached.");
+            eprintln!("This can happen when:");
+            eprintln!("  - Process limit (ulimit -u) is too low");
+            eprintln!("  - File descriptor limit (ulimit -n) is too low");
+            eprintln!("  - System memory is exhausted");
+            eprintln!("\nTry increasing limits:");
+            eprintln!("  ulimit -u 4096   # Increase process limit");
+            eprintln!("  ulimit -n 4096   # Increase file descriptor limit");
+            eprintln!("\nOr run with fewer concurrent operations.");
+            return;
+        }
+
         // Log the panic location for debugging
         if let Some(location) = panic_info.location() {
             eprintln!(

cortex-cli/src/mcp_cmd.rs

@@ -6,6 +6,28 @@ use cortex_common::CliConfigOverrides;
 use cortex_engine::{config::find_cortex_home, create_default_client};
 use std::io::{self, BufRead, Write};
 
+// ============================================================================
+// Safe Print Utilities (Issue #1989 - Handle broken pipe gracefully)
+// ============================================================================
+
+/// Safely prints to stdout, ignoring broken pipe errors.
+/// This prevents crashes when output is piped to commands like `head` that close early.
+macro_rules! safe_println {
+    () => {
+        let _ = writeln!(std::io::stdout());
+    };
+    ($($arg:tt)*) => {
+        let _ = writeln!(std::io::stdout(), $($arg)*);
+    };
+}
+
+/// Safely prints to stdout without newline, ignoring broken pipe errors.
+macro_rules! safe_print {
+    ($($arg:tt)*) => {
+        let _ = write!(std::io::stdout(), $($arg)*);
+    };
+}
+
 // ============================================================================
 // Input Validation Constants and Utilities
 // ============================================================================
@@ -1397,14 +1419,15 @@ async fn run_debug(args: DebugArgs) -> Result<()> {
 
     let mut errors: Vec<String> = Vec::new();
 
+    // Use safe_println! to avoid SIGPIPE crashes when output is piped (Issue #1989)
     if !json {
-        println!("Debugging MCP Server: {name}");
-        println!("{}", "=".repeat(50));
-        println!("Checked at: {} (fresh)", check_timestamp);
-        println!();
-        println!("Configuration:");
-        println!("  Enabled: {enabled}");
-        println!("  Transport: {transport_type}");
+        safe_println!("Debugging MCP Server: {name}");
+        safe_println!("{}", "=".repeat(50));
+        safe_println!("Checked at: {} (fresh)", check_timestamp);
+        safe_println!();
+        safe_println!("Configuration:");
+        safe_println!("  Enabled: {enabled}");
+        safe_println!("  Transport: {transport_type}");
     }
 
     // Transport-specific info
@@ -1429,9 +1452,9 @@ async fn run_debug(args: DebugArgs) -> Result<()> {
             debug_result["args"] = serde_json::json!(args);
 
             if !json {
-                println!("  Command: {cmd}");
+                safe_println!("  Command: {cmd}");
                 if !args.is_empty() {
-                    println!("  Args: {args}");
+                    safe_println!("  Args: {args}");
                 }
             }
 
@@ -1445,20 +1468,20 @@ async fn run_debug(args: DebugArgs) -> Result<()> {
             debug_result["command_exists"] = serde_json::json!(cmd_exists);
 
             if !json {
-                println!();
-                println!("Command Check:");
+                safe_println!();
+                safe_println!("Command Check:");
                 if cmd_exists {
-                    println!("  ✓ Command '{cmd}' found in PATH");
+                    safe_println!("  ✓ Command '{cmd}' found in PATH");
                 } else {
-                    println!("  ✗ Command '{cmd}' not found in PATH");
+                    safe_println!("  ✗ Command '{cmd}' not found in PATH");
                     errors.push(format!("Command '{}' not found in PATH", cmd));
                 }
             }
 
             // Try to connect and get capabilities
             if !json {
-                println!();
-                println!("Connection Test:");
+                safe_println!();
+                safe_println!("Connection Test:");
             }
 
             match test_stdio_connection(&name, cmd, &args, timeout).await {
@@ -1472,18 +1495,18 @@ async fn run_debug(args: DebugArgs) -> Result<()> {
                     debug_result["prompts"] = info.prompts.clone();
 
                     if !json {
-                        println!("  ✓ Connected successfully");
-                        println!();
-                        println!("Server Capabilities:");
+                        safe_println!("  ✓ Connected successfully");
+                        safe_println!();
+                        safe_println!("Server Capabilities:");
                         if let Some(caps) = info.capabilities.as_object() {
                             for (key, value) in caps {
-                                println!("  • {key}: {value}");
+                                safe_println!("  • {key}: {value}");
                             }
                         } else {
-                            println!("  (none reported)");
+                            safe_println!("  (none reported)");
                         }
-                        println!();
-                        println!(
+                        safe_println!();
+                        safe_println!(
                             "Available Tools: {}",
                             info.tools.as_array().map(|a| a.len()).unwrap_or(0)
                         );
@@ -1499,18 +1522,18 @@ async fn run_debug(args: DebugArgs) -> Result<()> {
                                     } else {
                                         desc.to_string()
                                     };
-                                    println!("  • {name}: {desc_short}");
+                                    safe_println!("  • {name}: {desc_short}");
                                 }
                             }
                             if tools.len() > 10 {
-                                println!("  ... and {} more", tools.len() - 10);
+                                safe_println!("  ... and {} more", tools.len() - 10);
                             }
                         }
-                        println!();
+                        safe_println!();
                         let resources_count =
                             info.resources.as_array().map(|a| a.len()).unwrap_or(0);
                         let prompts_count = info.prompts.as_array().map(|a| a.len()).unwrap_or(0);
-                        println!(
+                        safe_println!(
                             "Available Resources: {}{}",
                             resources_count,
                             if resources_count == 0 {
@@ -1519,7 +1542,7 @@ async fn run_debug(args: DebugArgs) -> Result<()> {
                                 ""
                             }
                         );
-                        println!(
+                        safe_println!(
                             "Available Prompts: {}{}",
                             prompts_count,
                             if prompts_count == 0 {
@@ -1539,7 +1562,7 @@ async fn run_debug(args: DebugArgs) -> Result<()> {
                     errors.push(error_msg);
 
                     if !json {
-                        println!("  ✗ Connection failed: {e}");
+                        safe_println!("  ✗ Connection failed: {e}");
                     }
                 }
             }
@@ -1550,13 +1573,13 @@ async fn run_debug(args: DebugArgs) -> Result<()> {
             debug_result["url"] = serde_json::json!(url);
 
             if !json {
-                println!("  URL: {url}");
+                safe_println!("  URL: {url}");
             }
 
             // Test HTTP connection
             if !json {
-                println!();
-                println!("Connection Test:");
+                safe_println!();
+                safe_println!("Connection Test:");
             }
 
             match test_http_connection(&name, url, timeout).await {
@@ -1570,18 +1593,18 @@ async fn run_debug(args: DebugArgs) -> Result<()> {
                     debug_result["prompts"] = info.prompts.clone();
 
                     if !json {
-                        println!("  ✓ Connected successfully");
-                        println!();
-                        println!("Server Capabilities:");
+                        safe_println!("  ✓ Connected successfully");
+                        safe_println!();
+                        safe_println!("Server Capabilities:");
                         if let Some(caps) = info.capabilities.as_object() {
                             for (key, value) in caps {
-                                println!("  • {key}: {value}");
+                                safe_println!("  • {key}: {value}");
                             }
                         } else {
-                            println!("  (none reported)");
+                            safe_println!("  (none reported)");
                         }
-                        println!();
-                        println!(
+                        safe_println!();
+                        safe_println!(
                             "Available Tools: {}",
                             info.tools.as_array().map(|a| a.len()).unwrap_or(0)
                         );
@@ -1597,18 +1620,18 @@ async fn run_debug(args: DebugArgs) -> Result<()> {
                                     } else {
                                         desc.to_string()
                                     };
-                                    println!("  • {name}: {desc_short}");
+                                    safe_println!("  • {name}: {desc_short}");
                                 }
                             }
                             if tools.len() > 10 {
-                                println!("  ... and {} more", tools.len() - 10);
+                                safe_println!("  ... and {} more", tools.len() - 10);
                             }
                         }
-                        println!();
+                        safe_println!();
                         let resources_count =
                             info.resources.as_array().map(|a| a.len()).unwrap_or(0);
                         let prompts_count = info.prompts.as_array().map(|a| a.len()).unwrap_or(0);
-                        println!(
+                        safe_println!(
                             "Available Resources: {}{}",
                             resources_count,
                             if resources_count == 0 {
@@ -1617,7 +1640,7 @@ async fn run_debug(args: DebugArgs) -> Result<()> {
                                 ""
                             }
                         );
-                        println!(
+                        safe_println!(
                             "Available Prompts: {}{}",
                             prompts_count,
                             if prompts_count == 0 {
@@ -1637,16 +1660,16 @@ async fn run_debug(args: DebugArgs) -> Result<()> {
                     errors.push(error_msg);
 
                     if !json {
-                        println!("  ✗ Connection failed: {e}");
+                        safe_println!("  ✗ Connection failed: {e}");
                     }
                 }
             }
 
             // Check OAuth status
             if test_auth {
                 if !json {
-                    println!();
-                    println!("OAuth Status:");
+                    safe_println!();
+                    safe_println!("OAuth Status:");
                 }
 
                 let auth_status = get_auth_status_for_display(&name, url)
@@ -1655,18 +1678,18 @@ async fn run_debug(args: DebugArgs) -> Result<()> {
                 debug_result["auth_status"] = serde_json::json!(auth_status);
 
                 if !json {
-                    println!("  {auth_status}");
+                    safe_println!("  {auth_status}");
 
                     if auth_status == "Not Authenticated" {
-                        println!("\n  Use 'cortex mcp auth {name}' to authenticate.");
+                        safe_println!("\n  Use 'cortex mcp auth {name}' to authenticate.");
                     }
                 }
             }
         }
         _ => {
             errors.push(format!("Unknown transport type: {}", transport_type));
             if !json {
-                println!("  ✗ Unknown transport type: {transport_type}");
+                safe_println!("  ✗ Unknown transport type: {transport_type}");
             }
         }
     }
@@ -1678,12 +1701,12 @@ async fn run_debug(args: DebugArgs) -> Result<()> {
 
     if json {
         let output = serde_json::to_string_pretty(&debug_result)?;
-        println!("{output}");
+        safe_println!("{output}");
     } else if !errors.is_empty() {
-        println!();
-        println!("Errors:");
+        safe_println!();
+        safe_println!("Errors:");
         for err in &errors {
-            println!("  ✗ {err}");
+            safe_println!("  ✗ {err}");
         }
     }