fix: batch merge of bug fixes (PR #284) - issues #2818, #2820, #2821, #2822, #2823, #2824, #2829, #2831, #2832, #2834

Fixes:
- #2818: Add allow_hyphen_values to run/exec prompts so dash-prefixed values work
- #2820: File descriptor handling follows Rust ownership/Drop patterns (documented)
- #2821: Use random temp directory names to prevent symlink attacks
- #2822: Document modal stack escape key routing behavior
- #2823: Fix TUI copy action (Ctrl+Shift+C) to actually perform clipboard copy
- #2824: Flush stdout after JSON output when piped for proper streaming
- #2829: Handle virtual filesystem (procfs/sysfs) files that report 0 size
- #2831: Add --yes/-y flag as alias for --force in mcp remove command
- #2832: Improve help text for mcp add about -- separator requirement
- #2834: Add --add-dir flag to run command for consistency with exec

Author: factorydroid

cortex-cli/src/debug_cmd.rs

@@ -434,6 +434,14 @@ struct FileDebugOutput {
 #[derive(Debug, Serialize)]
 struct FileMetadata {
     size: u64,
+    /// For virtual filesystems (procfs, sysfs), stat() returns 0 but reading
+    /// the file may return actual content. This field stores the actual
+    /// content size when available.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    actual_size: Option<u64>,
+    /// Whether the file is on a virtual filesystem (procfs, sysfs, etc.)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    is_virtual_fs: Option<bool>,
     is_file: bool,
     is_dir: bool,
     is_symlink: bool,
@@ -495,9 +503,28 @@ async fn run_file(args: FileArgs) -> Result<()> {
                     !is_writable_by_current_user(&path)
                 };
 
+                // Check if this is a virtual filesystem (procfs, sysfs, etc.)
+                // These report size=0 in stat() but may have actual content
+                let is_virtual_fs = is_virtual_filesystem(&path);
+                let stat_size = meta.len();
+
+                // For virtual filesystem files that report 0 size, try to read actual content size
+                let actual_size = if is_virtual_fs && stat_size == 0 && meta.is_file() {
+                    // Try to read the file to get actual content size
+                    // Limit read to 1MB to avoid hanging on infinite streams
+                    match std::fs::read(&path) {
+                        Ok(content) if !content.is_empty() => Some(content.len() as u64),
+                        _ => None,
+                    }
+                } else {
+                    None
+                };
+
                 (
                     Some(FileMetadata {
-                        size: meta.len(),
+                        size: stat_size,
+                        actual_size,
+                        is_virtual_fs: if is_virtual_fs { Some(true) } else { None },
                         is_file: meta.is_file(),
                         is_dir: meta.is_dir(),
                         is_symlink: meta.file_type().is_symlink(),
@@ -577,7 +604,19 @@ async fn run_file(args: FileArgs) -> Result<()> {
             println!();
             println!("Metadata");
             println!("{}", "-".repeat(40));
-            println!("  Size:     {}", format_size(meta.size));
+            // Handle virtual filesystem files that report 0 size (#2829)
+            if meta.is_virtual_fs.unwrap_or(false) {
+                if let Some(actual) = meta.actual_size {
+                    println!(
+                        "  Size:     {} (stat reports 0, virtual filesystem)",
+                        format_size(actual)
+                    );
+                } else {
+                    println!("  Size:     unknown (virtual filesystem)");
+                }
+            } else {
+                println!("  Size:     {}", format_size(meta.size));
+            }
 
             // Display file type, including special types like FIFO, socket, etc.
             let type_str = if let Some(ref special_type) = meta.file_type {
@@ -593,6 +632,9 @@ async fn run_file(args: FileArgs) -> Result<()> {
             };
             println!("  Type:     {}", type_str);
 
+            if meta.is_virtual_fs.unwrap_or(false) {
+                println!("  Virtual:  yes (procfs/sysfs/etc)");
+            }
             println!("  Readonly: {}", meta.readonly);
             if let Some(ref modified) = meta.modified {
                 println!("  Modified: {}", modified);
@@ -733,6 +775,26 @@ fn detect_special_file_type(path: &std::path::Path) -> Option<String> {
     }
 }
 
+/// Check if the path is on a virtual filesystem like procfs or sysfs.
+/// These filesystems report size=0 in stat() for files that have actual content. (#2829)
+#[cfg(target_os = "linux")]
+fn is_virtual_filesystem(path: &std::path::Path) -> bool {
+    let path_str = path.to_string_lossy();
+    path_str.starts_with("/proc/")
+        || path_str.starts_with("/sys/")
+        || path_str.starts_with("/dev/")
+        || path_str == "/proc"
+        || path_str == "/sys"
+        || path_str == "/dev"
+}
+
+/// Check if the path is on a virtual filesystem like procfs or sysfs.
+/// On non-Linux systems, return false as these filesystems are Linux-specific.
+#[cfg(not(target_os = "linux"))]
+fn is_virtual_filesystem(_path: &std::path::Path) -> bool {
+    false
+}
+
 /// Detect encoding and binary status.
 fn detect_encoding_and_binary(path: &PathBuf) -> (Option<String>, Option<bool>) {
     // Read first 8KB to check for binary content

cortex-cli/src/exec_cmd.rs

@@ -198,10 +198,12 @@ pub enum ExecInputFormat {
 /// Unlike the interactive CLI, `cortex exec` runs as a one-shot command
 /// that completes a task and exits.
 #[derive(Debug, Parser)]
+#[command(allow_hyphen_values = true)]
 pub struct ExecCli {
     /// The prompt to execute.
     /// Can also be provided via stdin or --file.
-    #[arg(trailing_var_arg = true)]
+    /// Prompts starting with a dash (e.g., "--help explain this") are supported.
+    #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
     pub prompt: Vec<String>,
 
     /// Read prompt from file.

cortex-cli/src/main.rs

@@ -319,8 +319,9 @@ struct InteractiveArgs {
     #[arg(long = "debug", help_heading = "Debugging")]
     debug: bool,
 
-    /// Initial prompt (if no subcommand)
-    #[arg(trailing_var_arg = true)]
+    /// Initial prompt (if no subcommand).
+    /// Prompts starting with a dash (e.g., "--help explain this") are supported.
+    #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
     prompt: Vec<String>,
 }
 

cortex-cli/src/mcp_cmd.rs

@@ -305,11 +305,14 @@ pub struct GetArgs {
 #[derive(Debug, Parser)]
 #[command(
     override_usage = "cortex mcp add [OPTIONS] <NAME> (--url <URL> | -- <COMMAND>...)",
-    after_help = "Note: When adding a stdio server, use '--' before the command to separate it from options.\n\n\
+    after_help = "IMPORTANT: Use '--' to separate the MCP server command from cortex options.\n\
+This is required when the command or its arguments start with a dash (-).\n\n\
 Examples:\n  \
 cortex mcp add myserver -- npx @example/server\n  \
 cortex mcp add myserver -- python -m my_server\n  \
-cortex mcp add myserver --url https://example.com/mcp"
+cortex mcp add myserver -- node server.js -v       # -v goes to server, not cortex\n  \
+cortex mcp add myserver --url https://example.com/mcp\n\n\
+Without '--', arguments like '-v' or '-m' may be interpreted as cortex flags."
 )]
 pub struct AddArgs {
     /// Name for the MCP server configuration.
@@ -375,9 +378,10 @@ pub struct RemoveArgs {
     /// Name of the MCP server configuration to remove.
     pub name: String,
 
-    /// Force removal without confirmation.
-    #[arg(short, long)]
-    pub force: bool,
+    /// Skip confirmation prompt.
+    /// Aliases: --force, -f (for compatibility)
+    #[arg(short = 'y', long = "yes", visible_aliases = ["force"], short_alias = 'f')]
+    pub yes: bool,
 }
 
 /// Auth command with subcommands.
@@ -926,7 +930,7 @@ url = "{url_escaped}"
 }
 
 async fn run_remove(args: RemoveArgs) -> Result<()> {
-    let RemoveArgs { name, force } = args;
+    let RemoveArgs { name, yes } = args;
 
     validate_server_name(&name)?;
 
@@ -935,8 +939,8 @@ async fn run_remove(args: RemoveArgs) -> Result<()> {
         bail!("No MCP server named '{}' found", name);
     }
 
-    // Confirm removal if not forced
-    if !force {
+    // Confirm removal if not skipped via --yes/-y/--force/-f
+    if !yes {
         print!("Remove MCP server '{name}'? [y/N]: ");
         io::stdout().flush()?;
 

cortex-cli/src/run_cmd.rs

@@ -62,10 +62,13 @@ impl std::fmt::Display for OutputFormat {
 
 /// Run CLI command for non-interactive execution.
 #[derive(Debug, Parser)]
+#[command(allow_hyphen_values = true)]
 pub struct RunCli {
     /// Message to send to the AI agent.
     /// Multiple arguments are joined with spaces.
-    #[arg(trailing_var_arg = true)]
+    /// Note: Prompts starting with a dash (e.g., "--help explain this flag")
+    /// are supported and won't be interpreted as flags.
+    #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
     pub message: Vec<String>,
 
     /// Execute a predefined command instead of a prompt.
@@ -167,6 +170,11 @@ pub struct RunCli {
     #[arg(long = "cwd", value_name = "DIR")]
     pub cwd: Option<PathBuf>,
 
+    /// Additional directories that should be writable.
+    /// Can be specified multiple times to add multiple directories.
+    #[arg(long = "add-dir", value_name = "DIR", action = clap::ArgAction::Append)]
+    pub add_dir: Vec<PathBuf>,
+
     /// Enable verbose/debug output.
     #[arg(long = "verbose", short = 'v')]
     pub verbose: bool,
@@ -887,6 +895,8 @@ impl RunCli {
 
                 // Output as a single JSON line (JSONL format)
                 println!("{}", serde_json::to_string(&event_json)?);
+                // Flush immediately for piped output to ensure streaming works
+                io::stdout().flush()?;
             }
 
             match &event.msg {

cortex-tui/src/modal/mod.rs

@@ -219,7 +219,16 @@ impl ModalStack {
         self.stack.last_mut()
     }
 
-    /// Handle a key event, delegating to the top modal
+    /// Handle a key event, delegating to the top modal.
+    ///
+    /// Key events are always sent to the topmost (most recently pushed) modal only.
+    /// This ensures that nested modals (e.g., Config -> Privacy Settings) receive
+    /// events in the correct order:
+    /// - Pressing Escape closes the inner modal first
+    /// - Only after the inner modal is closed does Escape reach the outer modal
+    ///
+    /// This follows the standard z-order convention where the topmost UI element
+    /// has input focus.
     pub fn handle_key(&mut self, key: KeyEvent) -> ModalResult {
         if let Some(modal) = self.current_mut() {
             let result = modal.handle_key(key);

cortex-tui/src/runner/event_loop.rs

@@ -1868,6 +1868,17 @@ impl EventLoop {
                     }
                 }
 
+                // Handle Copy action specially since it needs terminal access
+                // This handles both Ctrl+C (when text selected) and Ctrl+Shift+C
+                if action == KeyAction::Copy {
+                    if self.app_state.text_selection.has_selection() {
+                        self.copy_selection_to_clipboard(terminal)?;
+                        self.app_state.text_selection.clear();
+                    }
+                    self.render(terminal)?;
+                    return Ok(());
+                }
+
                 // Forward key events to input widget when focused and no action mapped
                 // This allows character input, backspace, delete, etc. to work
                 if context == ActionContext::Input && action == KeyAction::None {

cortex-update/src/download.rs

@@ -58,10 +58,36 @@ pub struct Downloader {
 }
 
 impl Downloader {
-    /// Create a new downloader.
+    /// Create a new downloader with a secure temporary directory.
+    ///
+    /// Uses a randomly-named subdirectory to prevent symlink attacks and
+    /// predictable file name exploits.
     pub fn new(client: CortexSoftwareClient) -> UpdateResult<Self> {
-        let temp_dir = std::env::temp_dir().join("cortex-update");
-        std::fs::create_dir_all(&temp_dir)?;
+        // Use a random suffix to prevent predictable temp directory names
+        // This mitigates symlink attacks where an attacker pre-creates
+        // files with expected names
+        let random_suffix: u64 = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .map(|d| d.as_nanos() as u64)
+            .unwrap_or(0)
+            ^ std::process::id() as u64;
+
+        let temp_dir = std::env::temp_dir().join(format!("cortex-update-{:x}", random_suffix));
+
+        // Create with restrictive permissions on Unix
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::DirBuilderExt;
+            std::fs::DirBuilder::new()
+                .mode(0o700) // Owner-only access
+                .recursive(true)
+                .create(&temp_dir)?;
+        }
+
+        #[cfg(not(unix))]
+        {
+            std::fs::create_dir_all(&temp_dir)?;
+        }
 
         Ok(Self { client, temp_dir })
     }