fix: batch fixes for issues #1958, #1959, #1960, #1961, #1962, #1965, #1966, #1968, #1969, #1970 [skip ci] (#372)

echobt · Bounty Bot · web-flow · commit e81cee1dce0d · 2026-01-27T22:00:35.000+01:00
Fixes:
- #1958: Add early validation for --agent flag in acp command
- #1959: Add --cookie flag to scrape command
- #1960: Extend --method flag to support POST in scrape command
- #1961: Add --no-follow-redirects flag to scrape command
- #1962: Improve --attach help documentation in run command
- #1965: Show version comparison in upgrade --check output
- #1966: Fix pipe crash in upgrade --changelog by handling SIGPIPE gracefully
- #1968: Handle 'upgrade VERSION' when VERSION matches current version
- #1969: Improve error messages for login --with-api-key in headless environments
- #1970: Clarify error message when git repo has no origin remote

Co-authored-by: Bounty Bot &lt;bounty-bot@factory.ai&gt;
diff --git a/cortex-cli/src/acp_cmd.rs b/cortex-cli/src/acp_cmd.rs
@@ -3,7 +3,7 @@
 //! The ACP protocol enables IDE integration (like Zed) with Cortex.
 //! Supports both stdio and HTTP transports for flexible integration.
 
-use anyhow::Result;
+use anyhow::{Result, bail};
 use clap::Parser;
 use cortex_common::resolve_model_alias;
 use std::net::SocketAddr;
@@ -56,6 +56,19 @@ pub struct AcpCli {
 impl AcpCli {
     /// Run the ACP server command.
     pub async fn run(self) -> Result<()> {
+        // Validate agent exists early if specified (Issue #1958)
+        if let Some(ref agent_name) = self.agent {
+            let registry = cortex_engine::AgentRegistry::new();
+            // Scan for agents in standard locations
+            let _ = registry.scan().await;
+            if !registry.exists(agent_name).await {
+                bail!(
+                    "Agent not found: '{}'. Use 'cortex agent list' to see available agents.",
+                    agent_name
+                );
+            }
+        }
+
         // Build configuration
         let mut config = cortex_engine::Config::default();
 
diff --git a/cortex-cli/src/login.rs b/cortex-cli/src/login.rs
@@ -46,6 +46,17 @@ pub async fn run_login_with_api_key(config_overrides: CliConfigOverrides, api_ke
     check_duplicate_config_overrides(&config_overrides);
     let cortex_home = get_cortex_home();
 
+    // Ensure cortex home directory exists for encrypted file fallback
+    if let Err(e) = std::fs::create_dir_all(&cortex_home) {
+        print_error(&format!(
+            "Failed to create cortex home directory at {}: {e}\n\n\
+             For headless/CI environments, set CORTEX_API_KEY environment variable instead:\n  \
+             export CORTEX_API_KEY=your-api-key",
+            cortex_home.display()
+        ));
+        std::process::exit(1);
+    }
+
     // Create secure auth data
     let data = SecureAuthData::with_api_key(api_key);
 
@@ -67,7 +78,18 @@ pub async fn run_login_with_api_key(config_overrides: CliConfigOverrides, api_ke
             std::process::exit(0);
         }
         Err(e) => {
-            print_error(&format!("Login failed: {e}"));
+            // Provide helpful error message for headless environments (Issue #1969)
+            let error_str = e.to_string();
+            if error_str.contains("keyring") || error_str.contains("secret service") {
+                print_error(&format!(
+                    "Login failed in headless environment: {e}\n\n\
+                     For headless/CI environments, use the CORTEX_API_KEY environment variable:\n  \
+                     export CORTEX_API_KEY=your-api-key\n\n\
+                     Or on Linux, install a secret service like gnome-keyring or kwallet."
+                ));
+            } else {
+                print_error(&format!("Login failed: {e}"));
+            }
             std::process::exit(1);
         }
     }
diff --git a/cortex-cli/src/pr_cmd.rs b/cortex-cli/src/pr_cmd.rs
@@ -431,7 +431,15 @@ fn get_git_remote_url() -> Result<String> {
         .context("Failed to get git remote URL")?;
 
     if !output.status.success() {
-        bail!("No 'origin' remote found. Is this a git repository?");
+        // Provide clearer error message (Issue #1970)
+        bail!(
+            "No 'origin' remote found.\n\n\
+             This is a git repository, but it doesn't have an 'origin' remote configured.\n\
+             Add one with:\n  \
+             git remote add origin <repository-url>\n\n\
+             Example:\n  \
+             git remote add origin https://github.com/username/repo.git"
+        );
     }
 
     let url = String::from_utf8_lossy(&output.stdout).trim().to_string();
diff --git a/cortex-cli/src/run_cmd.rs b/cortex-cli/src/run_cmd.rs
@@ -115,8 +115,11 @@ pub struct RunCli {
     #[arg(long = "title")]
     pub title: Option<String>,
 
-    /// Attach to a running Cortex server (e.g., http://localhost:3000).
-    #[arg(long = "attach")]
+    /// Attach to a running Cortex server instead of starting locally.
+    /// Value should be the server URL (e.g., "http://localhost:3000").
+    /// Use this to connect to a remote Cortex instance or an existing
+    /// local server started with 'cortex serve'.
+    #[arg(long = "attach", value_name = "URL")]
     pub attach: Option<String>,
 
     /// Port for the local server (defaults to random port).
diff --git a/cortex-cli/src/scrape_cmd.rs b/cortex-cli/src/scrape_cmd.rs
@@ -58,7 +58,7 @@ pub struct ScrapeCommand {
 
     /// HTTP method to use for the request.
     /// Use HEAD to check headers without downloading content.
-    /// Supported values: GET (default), HEAD.
+    /// Supported values: GET (default), HEAD, POST.
     #[arg(long, default_value = "GET", value_name = "METHOD")]
     pub method: String,
 
@@ -80,6 +80,17 @@ pub struct ScrapeCommand {
     #[arg(long = "header", short = 'H', value_name = "HEADER")]
     pub headers: Vec<String>,
 
+    /// Cookie to send with the request (format: "name=value").
+    /// Can be specified multiple times for multiple cookies.
+    /// Example: --cookie "session=abc123" --cookie "user=john"
+    #[arg(long = "cookie", value_name = "COOKIE")]
+    pub cookies: Vec<String>,
+
+    /// Disable following HTTP redirects.
+    /// By default, up to 10 redirects are followed.
+    #[arg(long)]
+    pub no_follow_redirects: bool,
+
     /// Strip images from output.
     #[arg(long)]
     pub no_images: bool,
@@ -227,8 +238,13 @@ impl ScrapeCommand {
         // Build HTTP client with redirect policy and cookie store
         // Cookie store is enabled to persist cookies across redirects, which is
         // required for auth-gated pages that set cookies then redirect.
+        let redirect_policy = if self.no_follow_redirects {
+            reqwest::redirect::Policy::none()
+        } else {
+            reqwest::redirect::Policy::limited(10)
+        };
         let mut client_builder = create_client_builder()
-            .redirect(reqwest::redirect::Policy::limited(10))
+            .redirect(redirect_policy)
             .cookie_store(true);
 
         // Override timeout if specified (0 means no timeout)
@@ -249,33 +265,46 @@ impl ScrapeCommand {
 
         // Parse the HTTP method
         let method_upper = self.method.to_uppercase();
-        let use_head = match method_upper.as_str() {
-            "GET" => false,
-            "HEAD" => true,
-            _ => bail!("Unsupported HTTP method: {}. Use GET or HEAD.", self.method),
-        };
 
         // Add custom headers
         let parsed_headers = parse_headers(&self.headers)?;
 
+        // Build cookie header from --cookie flags
+        let cookie_header = if !self.cookies.is_empty() {
+            Some(self.cookies.join("; "))
+        } else {
+            None
+        };
+
         if self.verbose {
-            eprintln!(
-                "Fetching: {} (method: {})",
-                self.url,
-                if use_head { "HEAD" } else { "GET" }
-            );
+            eprintln!("Fetching: {} (method: {})", self.url, method_upper);
         }
 
-        // Handle HEAD and GET requests separately for proper type inference
-        if use_head {
-            // HEAD request - just return headers
-            let mut request = client.head(&self.url);
-            for (name, value) in &parsed_headers {
-                request = request.header(name.as_str(), value.as_str());
-            }
+        // Build request based on HTTP method
+        let mut request = match method_upper.as_str() {
+            "GET" => client.get(&self.url),
+            "HEAD" => client.head(&self.url),
+            "POST" => client.post(&self.url),
+            _ => bail!(
+                "Unsupported HTTP method: {}. Use GET, HEAD, or POST.",
+                self.method
+            ),
+        };
 
-            let response = request.send().await.context("Failed to fetch URL")?;
+        // Add custom headers
+        for (name, value) in &parsed_headers {
+            request = request.header(name.as_str(), value.as_str());
+        }
+
+        // Add cookies if specified
+        if let Some(ref cookies) = cookie_header {
+            request = request.header("Cookie", cookies.as_str());
+        }
+
+        let response = request.send().await.context("Failed to fetch URL")?;
 
+        // For HEAD requests, just show headers and return
+        if method_upper == "HEAD" {
             if !response.status().is_success() {
                 bail!(
                     "HTTP error: {} {}",
@@ -307,27 +336,7 @@ impl ScrapeCommand {
             return Ok(());
         }
 
-        // GET request - fetch content
-        let mut request = client.get(&self.url);
-        for (name, value) in &parsed_headers {
-            request = request.header(name.as_str(), value.as_str());
-        }
-
-        // Send request with improved timeout error message (Issue #1985)
-        let timeout_secs = self.timeout;
-        let response = request.send().await.map_err(|e| {
-            if e.is_timeout() {
-                anyhow::anyhow!(
-                    "Request timed out after {} second{}. Use --timeout to increase the timeout.",
-                    timeout_secs,
-                    if timeout_secs == 1 { "" } else { "s" }
-                )
-            } else if e.is_connect() {
-                anyhow::anyhow!("Failed to connect to URL: {}", e)
-            } else {
-                anyhow::anyhow!("Failed to fetch URL: {}", e)
-            }
-        })?;
+        // For GET/POST, check response status
 
         if !response.status().is_success() {
             bail!(
@@ -1420,9 +1429,12 @@ mod tests {
             url: String::new(),
             output: None,
             format: "markdown".to_string(),
+            method: "GET".to_string(),
             timeout: 30,
             user_agent: None,
             headers: vec![],
+            cookies: vec![],
+            no_follow_redirects: false,
             no_images: false,
             no_links: false,
             selector: None,
@@ -1445,9 +1457,12 @@ mod tests {
             url: "   ".to_string(),
             output: None,
             format: "markdown".to_string(),
+            method: "GET".to_string(),
             timeout: 30,
             user_agent: None,
             headers: vec![],
+            cookies: vec![],
+            no_follow_redirects: false,
             no_images: false,
             no_links: false,
             selector: None,
@@ -1472,9 +1487,12 @@ mod tests {
             url: "https://example.com".to_string(),
             output: None,
             format: "markdown".to_string(),
+            method: "GET".to_string(),
             timeout: 0,
             user_agent: None,
             headers: vec![],
+            cookies: vec![],
+            no_follow_redirects: false,
             no_images: false,
             no_links: false,
             selector: None,
diff --git a/cortex-cli/src/upgrade_cmd.rs b/cortex-cli/src/upgrade_cmd.rs
