Merge PR #260: fix: batch fixes for issues #2485-#2496

Author: factorydroid

Cargo.lock

@@ -66,8 +66,9 @@ zip = { workspace = true }
 flate2 = "1.0"
 tar = "0.4"
 
-# For scrape command (HTML parsing)
+# For scrape command (HTML parsing and URL handling)
 scraper = "0.22"
+url = "2.5"
 
 # For agent reference extraction from messages
 regex = { workspace = true }

cortex-cli/Cargo.toml

@@ -723,6 +723,10 @@ pub struct LspArgs {
     #[arg(long)]
     pub server: Option<String>,
 
+    /// Filter by programming language (e.g., python, rust, go).
+    #[arg(long, short = 'l')]
+    pub language: Option<String>,
+
     /// Test LSP connection for a specific file.
     #[arg(long)]
     pub file: Option<PathBuf>,
@@ -807,6 +811,11 @@ async fn run_lsp(args: LspArgs) -> Result<()> {
         servers.retain(|s| s.name.to_lowercase().contains(&server_name.to_lowercase()));
     }
 
+    // Filter by language if specified
+    if let Some(ref lang) = args.language {
+        servers.retain(|s| s.language.to_lowercase().contains(&lang.to_lowercase()));
+    }
+
     // Connection test placeholder (actual implementation would require LSP client)
     let connection_test = if args.server.is_some() || args.file.is_some() {
         let server = args.server.as_deref().unwrap_or("auto-detect");
@@ -918,6 +927,10 @@ pub struct RipgrepArgs {
     #[arg(long)]
     pub dir: Option<PathBuf>,
 
+    /// Offer to install ripgrep if not found.
+    #[arg(long)]
+    pub install: bool,
+
     /// Output as JSON.
     #[arg(long)]
     pub json: bool,
@@ -955,6 +968,123 @@ fn get_path_directories() -> Vec<PathBuf> {
         .unwrap_or_default()
 }
 
+/// Attempt to install ripgrep using the system package manager.
+async fn install_ripgrep() -> Result<()> {
+    #[cfg(target_os = "macos")]
+    {
+        // Try Homebrew first
+        let output = tokio::process::Command::new("brew")
+            .args(["install", "ripgrep"])
+            .status()
+            .await;
+
+        match output {
+            Ok(status) if status.success() => {
+                println!("ripgrep installed successfully via Homebrew!");
+                return Ok(());
+            }
+            _ => {
+                bail!("Failed to install via Homebrew. Is Homebrew installed?");
+            }
+        }
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+        // Try apt first (Debian/Ubuntu)
+        if tokio::process::Command::new("which")
+            .arg("apt")
+            .output()
+            .await
+            .map(|o| o.status.success())
+            .unwrap_or(false)
+        {
+            let output = tokio::process::Command::new("sudo")
+                .args(["apt", "install", "-y", "ripgrep"])
+                .status()
+                .await;
+
+            match output {
+                Ok(status) if status.success() => {
+                    println!("ripgrep installed successfully via apt!");
+                    return Ok(());
+                }
+                _ => {}
+            }
+        }
+
+        // Try dnf (Fedora/RHEL)
+        if tokio::process::Command::new("which")
+            .arg("dnf")
+            .output()
+            .await
+            .map(|o| o.status.success())
+            .unwrap_or(false)
+        {
+            let output = tokio::process::Command::new("sudo")
+                .args(["dnf", "install", "-y", "ripgrep"])
+                .status()
+                .await;
+
+            match output {
+                Ok(status) if status.success() => {
+                    println!("ripgrep installed successfully via dnf!");
+                    return Ok(());
+                }
+                _ => {}
+            }
+        }
+
+        // Try pacman (Arch)
+        if tokio::process::Command::new("which")
+            .arg("pacman")
+            .output()
+            .await
+            .map(|o| o.status.success())
+            .unwrap_or(false)
+        {
+            let output = tokio::process::Command::new("sudo")
+                .args(["pacman", "-S", "--noconfirm", "ripgrep"])
+                .status()
+                .await;
+
+            match output {
+                Ok(status) if status.success() => {
+                    println!("ripgrep installed successfully via pacman!");
+                    return Ok(());
+                }
+                _ => {}
+            }
+        }
+
+        bail!("Could not detect a supported package manager (apt, dnf, pacman)");
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+        // Try winget
+        let output = tokio::process::Command::new("winget")
+            .args(["install", "-e", "--id", "BurntSushi.ripgrep.MSVC"])
+            .status()
+            .await;
+
+        match output {
+            Ok(status) if status.success() => {
+                println!("ripgrep installed successfully via winget!");
+                return Ok(());
+            }
+            _ => {
+                bail!("Failed to install via winget. Is winget available?");
+            }
+        }
+    }
+
+    #[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
+    {
+        bail!("Automatic installation not supported on this platform");
+    }
+}
+
 async fn run_ripgrep(args: RipgrepArgs) -> Result<()> {
     let (available, path, version) = check_command_installed("rg").await;
 
@@ -1076,6 +1206,16 @@ async fn run_ripgrep(args: RipgrepArgs) -> Result<()> {
             println!("  macOS:   brew install ripgrep");
             println!("  Linux:   apt install ripgrep / dnf install ripgrep");
             println!("  Windows: winget install BurntSushi.ripgrep.MSVC");
+
+            // Offer to install if --install flag was provided
+            if args.install {
+                println!();
+                println!("Attempting to install ripgrep...");
+                if let Err(e) = install_ripgrep().await {
+                    eprintln!("Failed to install ripgrep: {e}");
+                    eprintln!("Please install manually using the commands above.");
+                }
+            }
         }
     }
 

cortex-cli/src/debug_cmd.rs

@@ -531,9 +531,11 @@ struct LogoutCommand {
 /// Completion command.
 #[derive(Args)]
 struct CompletionCommand {
-    /// Shell to generate completions for
-    #[arg(value_enum, default_value_t = Shell::Bash)]
-    shell: Shell,
+    /// Shell to generate completions for.
+    /// If not specified, attempts to detect from $SHELL environment variable.
+    /// Falls back to bash if detection fails.
+    #[arg(value_enum)]
+    shell: Option<Shell>,
 }
 
 /// Resume command.
@@ -699,6 +701,17 @@ struct ServeCommand {
     #[arg(long = "auth-token")]
     auth_token: Option<String>,
 
+    /// Enable CORS (Cross-Origin Resource Sharing) for all origins.
+    /// This allows web browsers to make requests from any domain.
+    #[arg(long)]
+    cors: bool,
+
+    /// Allowed CORS origin(s). Can be specified multiple times.
+    /// Example: --cors-origin "https://myapp.com" --cors-origin "https://localhost:3000"
+    /// If not specified but --cors is used, allows all origins (*).
+    #[arg(long = "cors-origin", value_name = "ORIGIN")]
+    cors_origins: Vec<String>,
+
     /// Enable mDNS service discovery (advertise on local network)
     #[arg(long = "mdns", default_value_t = false)]
     mdns: bool,
@@ -899,7 +912,8 @@ async fn main() -> Result<()> {
             );
         }
         Some(Commands::Completion(completion_cli)) => {
-            generate_completions(completion_cli.shell);
+            let shell = completion_cli.shell.unwrap_or_else(detect_shell_from_env);
+            generate_completions(shell);
             Ok(())
         }
         Some(Commands::Sandbox(sandbox_args)) => match sandbox_args.cmd {
@@ -1006,6 +1020,44 @@ async fn run_tui(initial_prompt: Option<String>, args: &InteractiveArgs) -> Resu
 // - Session continuation (--session-id)
 // - Timeout and max-turns controls
 
+/// Detect the shell from the SHELL environment variable.
+/// Falls back to Bash if detection fails.
+fn detect_shell_from_env() -> Shell {
+    if let Ok(shell_path) = std::env::var("SHELL") {
+        let shell_name = std::path::Path::new(&shell_path)
+            .file_name()
+            .and_then(|n| n.to_str())
+            .unwrap_or("")
+            .to_lowercase();
+
+        match shell_name.as_str() {
+            "bash" => Shell::Bash,
+            "zsh" => Shell::Zsh,
+            "fish" => Shell::Fish,
+            "powershell" | "pwsh" => Shell::PowerShell,
+            "elvish" => Shell::Elvish,
+            _ => {
+                eprintln!(
+                    "Warning: Unknown shell '{}' from $SHELL. Defaulting to bash.",
+                    shell_name
+                );
+                Shell::Bash
+            }
+        }
+    } else {
+        // No SHELL env var, try to detect from other sources
+        #[cfg(windows)]
+        {
+            // On Windows, default to PowerShell
+            Shell::PowerShell
+        }
+        #[cfg(not(windows))]
+        {
+            Shell::Bash
+        }
+    }
+}
+
 fn generate_completions(shell: Shell) {
     use std::io::Write;
 
@@ -1704,9 +1756,21 @@ async fn run_serve(serve_cli: ServeCommand) -> Result<()> {
         cortex_app_server::config::AuthConfig::default()
     };
 
+    // Configure CORS origins
+    let cors_origins = if !serve_cli.cors_origins.is_empty() {
+        serve_cli.cors_origins.clone()
+    } else if serve_cli.cors {
+        // --cors without specific origins means allow all (empty vec = permissive)
+        vec![]
+    } else {
+        // Default: no CORS (will use permissive by default in the server)
+        vec![]
+    };
+
     let config = cortex_app_server::ServerConfig {
         listen_addr: format!("{}:{}", serve_cli.host, serve_cli.port),
         auth: auth_config,
+        cors_origins,
         ..Default::default()
     };
 
@@ -1721,6 +1785,14 @@ async fn run_serve(serve_cli: ServeCommand) -> Result<()> {
         serve_cli.host, serve_cli.port, auth_status
     ));
 
+    if serve_cli.cors || !serve_cli.cors_origins.is_empty() {
+        if serve_cli.cors_origins.is_empty() {
+            println!("CORS: Allowing all origins (*)");
+        } else {
+            println!("CORS: Allowing origins: {:?}", serve_cli.cors_origins);
+        }
+    }
+
     // Setup mDNS advertising if enabled
     let mut mdns_service = if serve_cli.mdns && !serve_cli.no_mdns {
         let mut mdns = MdnsService::new();