Merge PR #268: fix: batch fixes for issues #2469-#2486

Author: factorydroid

Cargo.lock

@@ -48,10 +48,16 @@ pub struct ServerConfig {
     #[serde(default = "default_max_body_size")]
     pub max_body_size: usize,
 
-    /// Request timeout in seconds.
+    /// Request timeout in seconds (applies to full request lifecycle).
     #[serde(default = "default_request_timeout")]
     pub request_timeout: u64,
 
+    /// Read timeout for individual chunks in seconds.
+    /// Applies to chunked transfer encoding to prevent indefinite hangs
+    /// when clients disconnect without sending the terminal chunk.
+    #[serde(default = "default_read_timeout")]
+    pub read_timeout: u64,
+
     /// Enable metrics endpoint.
     #[serde(default = "default_true")]
     pub metrics_enabled: bool,
@@ -63,16 +69,6 @@ pub struct ServerConfig {
     /// CORS origins (empty = allow all).
     #[serde(default)]
     pub cors_origins: Vec<String>,
-
-    /// Graceful shutdown timeout in seconds.
-    /// When the server receives SIGTERM, it will wait this long for in-flight
-    /// requests to complete before forcefully terminating.
-    #[serde(default = "default_shutdown_timeout")]
-    pub shutdown_timeout: u64,
-}
-
-fn default_shutdown_timeout() -> u64 {
-    30 // 30 seconds
 }
 
 fn default_listen_addr() -> String {
@@ -87,6 +83,10 @@ fn default_request_timeout() -> u64 {
     300 // 5 minutes
 }
 
+fn default_read_timeout() -> u64 {
+    30 // 30 seconds for individual chunk reads
+}
+
 fn default_true() -> bool {
     true
 }
@@ -105,10 +105,10 @@ impl Default for ServerConfig {
             mdns: MdnsConfig::default(),
             max_body_size: default_max_body_size(),
             request_timeout: default_request_timeout(),
+            read_timeout: default_read_timeout(),
             metrics_enabled: true,
             health_enabled: true,
             cors_origins: vec![],
-            shutdown_timeout: default_shutdown_timeout(),
         }
     }
 }
@@ -162,9 +162,9 @@ impl ServerConfig {
         Duration::from_secs(self.request_timeout)
     }
 
-    /// Get shutdown timeout as Duration.
-    pub fn shutdown_timeout_duration(&self) -> Duration {
-        Duration::from_secs(self.shutdown_timeout)
+    /// Get read timeout as Duration (for chunked transfers).
+    pub fn read_timeout_duration(&self) -> Duration {
+        Duration::from_secs(self.read_timeout)
     }
 }
 
@@ -266,12 +266,6 @@ pub struct RateLimitConfig {
     /// Exempt paths from rate limiting.
     #[serde(default)]
     pub exempt_paths: Vec<String>,
-    /// Trust proxy headers (X-Forwarded-For, X-Real-IP) for client IP detection.
-    /// Enable this when running behind a reverse proxy (nginx, etc.).
-    /// When enabled, the server will use X-Forwarded-For or X-Real-IP headers
-    /// to determine the real client IP for logging and rate limiting.
-    #[serde(default)]
-    pub trust_proxy: bool,
 }
 
 fn default_rpm() -> u32 {
@@ -292,7 +286,6 @@ impl Default for RateLimitConfig {
             by_api_key: false,
             by_user: false,
             exempt_paths: vec!["/health".to_string()],
-            trust_proxy: false,
         }
     }
 }

cortex-app-server/src/config.rs

@@ -29,6 +29,7 @@ cortex-protocol = { workspace = true }
 cortex-tui = { workspace = true, optional = true }
 cortex-exec = { workspace = true }
 cortex-common = { workspace = true, features = ["cli"] }
+cortex-commands = { workspace = true }
 cortex-login = { workspace = true }
 cortex-process-hardening = { workspace = true }
 cortex-app-server = { workspace = true }

cortex-cli/Cargo.toml

@@ -335,6 +335,10 @@ const CAT_ADVANCED: &str = "Advanced";
 
 #[derive(Subcommand)]
 enum Commands {
+    /// Initialize AGENTS.md in the current directory.
+    /// Creates a project-specific configuration file for AI agents.
+    Init(InitCommand),
+
     // ═══════════════════════════════════════════════════════════════════════════
     // Execution Modes
     // ═══════════════════════════════════════════════════════════════════════════
@@ -575,6 +579,25 @@ struct CompletionCommand {
     /// Falls back to bash if detection fails.
     #[arg(value_enum)]
     shell: Option<Shell>,
+
+    /// Install completions to your shell configuration file.
+    /// This will append an eval command to your shell's rc file
+    /// (e.g., ~/.bashrc, ~/.zshrc) to enable tab completion.
+    #[arg(long = "install")]
+    install: bool,
+}
+
+/// Init command - initialize AGENTS.md.
+#[derive(Args)]
+struct InitCommand {
+    /// Force overwrite if AGENTS.md already exists.
+    #[arg(short = 'f', long = "force")]
+    force: bool,
+
+    /// Accept defaults without prompting (non-interactive mode).
+    /// Useful for scripting and automation.
+    #[arg(short = 'y', long = "yes")]
+    yes: bool,
 }
 
 /// Resume command.
@@ -903,6 +926,7 @@ async fn main() -> Result<()> {
             };
             run_tui(initial_prompt, &cli.interactive).await
         }
+        Some(Commands::Init(init_cli)) => run_init(init_cli).await,
         Some(Commands::Run(run_cli)) => run_cli.run().await,
         Some(Commands::Exec(exec_cli)) => exec_cli.run().await,
         Some(Commands::Login(login_cli)) => {
@@ -966,8 +990,12 @@ async fn main() -> Result<()> {
         }
         Some(Commands::Completion(completion_cli)) => {
             let shell = completion_cli.shell.unwrap_or_else(detect_shell_from_env);
-            generate_completions(shell);
-            Ok(())
+            if completion_cli.install {
+                install_completions(shell)
+            } else {
+                generate_completions(shell);
+                Ok(())
+            }
         }
         Some(Commands::Sandbox(sandbox_args)) => match sandbox_args.cmd {
             SandboxCommand::Macos(cmd) => {
@@ -1204,6 +1232,133 @@ _cortex_quote_path() {
     let _ = writer.write_all(output.as_bytes());
 }
 
+/// Install shell completions to the user's shell configuration file.
+fn install_completions(shell: Shell) -> Result<()> {
+    use std::fs::OpenOptions;
+    use std::io::Write;
+
+    let home =
+        dirs::home_dir().ok_or_else(|| anyhow::anyhow!("Could not determine home directory"))?;
+
+    let (rc_file, eval_cmd) = match shell {
+        Shell::Bash => (home.join(".bashrc"), r#"eval "$(cortex completion bash)""#),
+        Shell::Zsh => (home.join(".zshrc"), r#"eval "$(cortex completion zsh)""#),
+        Shell::Fish => {
+            // Fish uses a different approach - write completion file directly
+            let fish_dir = home.join(".config/fish/completions");
+            std::fs::create_dir_all(&fish_dir)?;
+            let fish_file = fish_dir.join("cortex.fish");
+
+            let mut cmd = Cli::command();
+            let mut output = Vec::new();
+            generate(shell, &mut cmd, "cortex", &mut output);
+            std::fs::write(&fish_file, output)?;
+
+            println!("Completions installed to: {}", fish_file.display());
+            println!(
+                "Restart your shell or run 'source {}' to activate.",
+                fish_file.display()
+            );
+            return Ok(());
+        }
+        Shell::PowerShell => {
+            // PowerShell uses profile
+            let profile_dir = if cfg!(windows) {
+                home.join("Documents/PowerShell")
+            } else {
+                home.join(".config/powershell")
+            };
+            std::fs::create_dir_all(&profile_dir)?;
+
+            (
+                profile_dir.join("Microsoft.PowerShell_profile.ps1"),
+                "cortex completion powershell | Out-String | Invoke-Expression",
+            )
+        }
+        Shell::Elvish => {
+            // Elvish uses lib directory
+            let elvish_dir = home.join(".elvish/lib");
+            std::fs::create_dir_all(&elvish_dir)?;
+            let elvish_file = elvish_dir.join("cortex.elv");
+
+            let mut cmd = Cli::command();
+            let mut output = Vec::new();
+            generate(shell, &mut cmd, "cortex", &mut output);
+            std::fs::write(&elvish_file, output)?;
+
+            println!("Completions installed to: {}", elvish_file.display());
+            println!("Add 'use cortex' to your rc.elv to activate.");
+            return Ok(());
+        }
+        _ => {
+            bail!(
+                "Shell {:?} is not supported for automatic installation. Use 'cortex completion {:?}' to generate the script manually.",
+                shell,
+                shell
+            );
+        }
+    };
+
+    // Check if already installed
+    if rc_file.exists() {
+        let content = std::fs::read_to_string(&rc_file)?;
+        if content.contains("cortex completion") {
+            println!("Completions already installed in {}", rc_file.display());
+            println!("If completions aren't working, restart your shell.");
+            return Ok(());
+        }
+    }
+
+    // Append the eval command to the rc file
+    let mut file = OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(&rc_file)?;
+
+    writeln!(file)?;
+    writeln!(file, "# Cortex CLI completions")?;
+    writeln!(file, "{}", eval_cmd)?;
+
+    println!("Completions installed to: {}", rc_file.display());
+    println!(
+        "Restart your shell or run 'source {}' to activate.",
+        rc_file.display()
+    );
+
+    Ok(())
+}
+
+/// Run the init command to create AGENTS.md.
+async fn run_init(init_cli: InitCommand) -> Result<()> {
+    use cortex_commands::builtin::InitCommand as InitCmd;
+    use std::io::IsTerminal;
+
+    let cwd = std::env::current_dir()?;
+
+    // Check if we're in a TTY and --yes wasn't provided
+    let is_tty = std::io::stdin().is_terminal() && std::io::stdout().is_terminal();
+
+    // If not TTY and --yes not provided, fail gracefully instead of crashing
+    if !is_tty && !init_cli.yes {
+        bail!(
+            "Non-interactive mode detected but --yes flag not provided.\n\
+             Use 'cortex init --yes' to run non-interactively with default settings."
+        );
+    }
+
+    let cmd = InitCmd::new().force(init_cli.force);
+
+    match cmd.execute(&cwd) {
+        Ok(result) => {
+            println!("{}", result.message());
+            Ok(())
+        }
+        Err(e) => {
+            bail!("Failed to initialize: {}", e);
+        }
+    }
+}
+
 async fn run_resume(resume_cli: ResumeCommand) -> Result<()> {
     use cortex_protocol::ConversationId;
 

cortex-cli/src/main.rs

@@ -63,10 +63,15 @@ pub struct PrCli {
     #[arg(short, long)]
     pub path: Option<PathBuf>,
 
+    /// Custom local branch name for the PR checkout.
+    /// If not specified, defaults to "pr-{number}".
+    #[arg(short, long)]
+    pub branch: Option<String>,
+
     /// Force checkout even if there are uncommitted changes.
     /// WARNING: This may result in data loss! Uncommitted changes in your working
     /// directory may be overwritten. Consider using 'git stash' first to save your work.
-    #[arg(short, long)]
+    #[arg(short = 'F', long)]
     pub force: bool,
 
     /// Show PR details without checking out.
@@ -305,12 +310,18 @@ async fn run_pr_checkout(args: PrCli) -> Result<()> {
     }
 
     // Fetch the PR
-    // SECURITY: Branch name and refspec are constructed from validated numeric PR number
-    let branch_name = format!("pr-{}", pr_number);
-    let refspec = format!("pull/{}/head:{}", pr_number, branch_name);
+    // Use custom branch name if provided, otherwise default to "pr-{number}"
+    let branch_name = args
+        .branch
+        .clone()
+        .unwrap_or_else(|| format!("pr-{}", pr_number));
 
-    // Validate constructed names to ensure no injection is possible
+    // SECURITY: Validate the branch name to prevent injection
     validate_branch_name(&branch_name)?;
+
+    let refspec = format!("pull/{}/head:{}", pr_number, branch_name);
+
+    // Validate refspec to ensure no injection is possible
     validate_refspec(&refspec)?;
 
     println!("Fetching PR #{}...", pr_number);

cortex-cli/src/pr_cmd.rs

@@ -32,6 +32,7 @@ const MAX_FILE_SIZE: u64 = 10 * 1024 * 1024;
 
 use crate::styled_output::{print_success, print_warning};
 use cortex_common::resolve_model_alias;
+use cortex_common::{resolve_model_with_info, warn_if_ambiguous_model};
 use cortex_engine::rollout::get_rollout_path;
 use cortex_engine::{Session, list_sessions};
 use cortex_protocol::{ConversationId, EventMsg, Op, Submission, UserInput};
@@ -630,8 +631,11 @@ impl RunCli {
         }
 
         // Resolve model alias if provided (e.g., "sonnet" -> "anthropic/claude-sonnet-4-20250514")
+        // Also warn if the model name was ambiguous and multiple models matched
         if let Some(ref model) = self.model {
-            config.model = resolve_model_alias(model).to_string();
+            let resolution = resolve_model_with_info(model);
+            warn_if_ambiguous_model(&resolution, model);
+            config.model = resolution.model;
         }
 
         // Apply temperature override if provided