Merge PR #251: fix: batch fixes for issues #2380-#2395

Author: factorydroid

cortex-cli/src/mcp_cmd.rs

@@ -503,7 +503,14 @@ async fn run_list(args: ListArgs) -> Result<()> {
     let servers = get_mcp_servers()?;
 
     if args.json {
-        let json = serde_json::to_string_pretty(&servers)?;
+        // Sort servers by name for consistent JSON output
+        let mut sorted_servers: Vec<_> = servers.iter().collect();
+        sorted_servers.sort_by(|a, b| a.0.cmp(b.0));
+        let sorted_map: toml::map::Map<String, toml::Value> = sorted_servers
+            .into_iter()
+            .map(|(k, v)| (k.clone(), v.clone()))
+            .collect();
+        let json = serde_json::to_string_pretty(&sorted_map)?;
         println!("{json}");
         return Ok(());
     }
@@ -522,7 +529,11 @@ async fn run_list(args: ListArgs) -> Result<()> {
     );
     println!("{}", "-".repeat(90));
 
-    for (name, server) in &servers {
+    // Sort servers alphabetically by name for deterministic output
+    let mut sorted_servers: Vec<_> = servers.iter().collect();
+    sorted_servers.sort_by(|a, b| a.0.cmp(b.0));
+
+    for (name, server) in sorted_servers {
         let enabled = server
             .get("enabled")
             .and_then(toml::Value::as_bool)

cortex-cli/src/scrape_cmd.rs

@@ -37,6 +37,31 @@ impl std::str::FromStr for OutputFormat {
     }
 }
 
+/// Image resolution selection for srcset handling.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub enum ImageResolution {
+    /// Get the smallest image variant (default browser behavior).
+    Smallest,
+    /// Get the highest resolution image available.
+    #[default]
+    Highest,
+    /// Get all image variants.
+    All,
+}
+
+impl std::str::FromStr for ImageResolution {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "smallest" | "small" | "low" => Ok(Self::Smallest),
+            "highest" | "high" | "large" | "best" => Ok(Self::Highest),
+            "all" => Ok(Self::All),
+            _ => bail!("Invalid image resolution: {s}. Use smallest, highest, or all"),
+        }
+    }
+}
+
 /// Scrape web content and convert to clean formats.
 #[derive(Debug, Parser)]
 pub struct ScrapeCommand {
@@ -91,6 +116,14 @@ pub struct ScrapeCommand {
     #[arg(long, value_name = "SELECTOR")]
     pub selector: Option<String>,
 
+    /// Image resolution selection for srcset attributes.
+    /// Options: smallest, highest (default), all
+    /// - smallest: Get the lowest resolution variant
+    /// - highest: Get the highest resolution variant (best for AI vision)
+    /// - all: Include all variants
+    #[arg(long, default_value = "highest", value_name = "RESOLUTION")]
+    pub image_resolution: String,
+
     /// Show verbose output (includes fetching info).
     #[arg(short, long)]
     pub verbose: bool,
@@ -257,6 +290,62 @@ fn parse_headers(headers: &[String]) -> Result<HashMap<String, String>> {
     Ok(result)
 }
 
+/// Parse srcset attribute and extract image URL based on resolution preference.
+/// srcset format: "small.jpg 480w, medium.jpg 800w, large.jpg 1200w"
+fn select_image_from_srcset(srcset: &str, resolution: ImageResolution) -> Vec<String> {
+    if srcset.trim().is_empty() {
+        return Vec::new();
+    }
+
+    // Parse srcset entries
+    let mut entries: Vec<(String, u32)> = Vec::new();
+
+    for entry in srcset.split(',') {
+        let parts: Vec<&str> = entry.trim().split_whitespace().collect();
+        if !parts.is_empty() {
+            let url = parts[0].to_string();
+            // Parse width descriptor (e.g., "800w") or pixel density (e.g., "2x")
+            let width = if parts.len() > 1 {
+                let descriptor = parts[1];
+                if descriptor.ends_with('w') {
+                    descriptor.trim_end_matches('w').parse::<u32>().unwrap_or(0)
+                } else if descriptor.ends_with('x') {
+                    // Convert pixel density to approximate width
+                    let density = descriptor
+                        .trim_end_matches('x')
+                        .parse::<f32>()
+                        .unwrap_or(1.0);
+                    (density * 1000.0) as u32
+                } else {
+                    0
+                }
+            } else {
+                0
+            };
+            entries.push((url, width));
+        }
+    }
+
+    if entries.is_empty() {
+        return Vec::new();
+    }
+
+    // Sort by width
+    entries.sort_by(|a, b| a.1.cmp(&b.1));
+
+    match resolution {
+        ImageResolution::Smallest => entries
+            .first()
+            .map(|(url, _)| vec![url.clone()])
+            .unwrap_or_default(),
+        ImageResolution::Highest => entries
+            .last()
+            .map(|(url, _)| vec![url.clone()])
+            .unwrap_or_default(),
+        ImageResolution::All => entries.into_iter().map(|(url, _)| url).collect(),
+    }
+}
+
 /// Extract main content from HTML, skipping navigation, footers, ads, etc.
 fn extract_main_content(document: &Html) -> String {
     // Try to find main content areas

cortex-engine/src/agent/profile.rs

@@ -48,6 +48,52 @@ pub struct AgentProfile {
     pub system_prompt: Option<String>,
 }
 
+/// State that can accumulate during a session and needs to be reset on profile switch.
+#[derive(Debug, Clone, Default)]
+pub struct ProfileSessionState {
+    /// Cached tool registrations from previous profile.
+    pub tool_cache_dirty: bool,
+    /// Indicates MCP connections need to be refreshed.
+    pub mcp_connections_dirty: bool,
+    /// Previous profile name (for detecting switches).
+    pub previous_profile: Option<String>,
+}
+
+impl ProfileSessionState {
+    /// Create new session state.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Check if a profile switch occurred and mark state dirty.
+    pub fn on_profile_switch(&mut self, new_profile: &str) -> bool {
+        let switched = self
+            .previous_profile
+            .as_ref()
+            .map(|p| p != new_profile)
+            .unwrap_or(true);
+
+        if switched {
+            self.tool_cache_dirty = true;
+            self.mcp_connections_dirty = true;
+            self.previous_profile = Some(new_profile.to_string());
+        }
+
+        switched
+    }
+
+    /// Clear all dirty flags after reset is complete.
+    pub fn mark_clean(&mut self) {
+        self.tool_cache_dirty = false;
+        self.mcp_connections_dirty = false;
+    }
+
+    /// Check if any state needs to be refreshed.
+    pub fn needs_refresh(&self) -> bool {
+        self.tool_cache_dirty || self.mcp_connections_dirty
+    }
+}
+
 impl AgentProfile {
     /// Load all profiles from the project and user configuration.
     pub fn load_all() -> Result<HashMap<String, AgentProfile>> {

cortex-engine/src/api_client.rs

@@ -36,6 +36,9 @@ pub const STREAMING_TIMEOUT: Duration = Duration::from_secs(300);
 /// Short timeout for health checks (5 seconds)
 pub const HEALTH_CHECK_TIMEOUT: Duration = Duration::from_secs(5);
 
+/// Default connection timeout (10 seconds)
+pub const DEFAULT_CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
+
 // ============================================================================
 // Global HTTP Client Factory Functions
 // ============================================================================
@@ -81,6 +84,28 @@ pub fn create_client_with_timeout(timeout: Duration) -> Result<Client> {
     Client::builder()
         .user_agent(USER_AGENT)
         .timeout(timeout)
+        .connect_timeout(DEFAULT_CONNECT_TIMEOUT)
+        .tcp_nodelay(true)
+        .build()
+        .map_err(|e| CortexError::Internal(format!("Failed to build HTTP client: {e}")))
+}
+
+/// Creates an HTTP client with separate connect and response timeouts.
+///
+/// This allows distinguishing between connection establishment and response waiting.
+/// Use this when you need different timeouts for initial connection vs response.
+///
+/// # Arguments
+/// * `connect_timeout` - Timeout for establishing TCP connection
+/// * `response_timeout` - Total timeout for the entire request/response cycle
+pub fn create_client_with_timeouts(
+    connect_timeout: Duration,
+    response_timeout: Duration,
+) -> Result<Client> {
+    Client::builder()
+        .user_agent(USER_AGENT)
+        .connect_timeout(connect_timeout)
+        .timeout(response_timeout)
         .tcp_nodelay(true)
         .build()
         .map_err(|e| CortexError::Internal(format!("Failed to build HTTP client: {e}")))

cortex-engine/src/error.rs

@@ -66,6 +66,9 @@ pub enum CortexError {
     #[error("Model not found: {model}")]
     ModelNotFound { model: String },
 
+    #[error("Model deprecated: {model}. {suggestion}")]
+    ModelDeprecated { model: String, suggestion: String },
+
     #[error("Provider not found: {provider}")]
     ProviderNotFound { provider: String },
 
@@ -105,6 +108,9 @@ pub enum CortexError {
     #[error("Permission denied: {path}")]
     PermissionDenied { path: PathBuf },
 
+    #[error("Permission denied (possible SELinux denial): {path}. {hint}")]
+    PermissionDeniedSelinux { path: PathBuf, hint: String },
+
     // Serialization errors
     #[error("JSON error: {0}")]
     Json(#[from] serde_json::Error),
@@ -210,6 +216,13 @@ impl CortexError {
         Self::MdnsError(message.into())
     }
 
+    /// Create a deprecated model error with a helpful suggestion.
+    pub fn model_deprecated(model: impl Into<String>, raw_error: &str) -> Self {
+        let model = model.into();
+        let suggestion = suggest_model_replacement(&model, raw_error);
+        Self::ModelDeprecated { model, suggestion }
+    }
+
     /// Check if this error is retriable.
     pub fn is_retriable(&self) -> bool {
         matches!(
@@ -232,6 +245,80 @@ impl CortexError {
     }
 }
 
+/// Suggest a replacement model for deprecated models.
+fn suggest_model_replacement(model: &str, _raw_error: &str) -> String {
+    // Common deprecated model replacements
+    let suggestion = match model {
+        // OpenAI deprecated models
+        m if m.contains("gpt-3.5-turbo-0301") => "Try 'gpt-3.5-turbo' or 'gpt-4o-mini' instead.",
+        m if m.contains("gpt-3.5-turbo-0613") => "Try 'gpt-3.5-turbo' or 'gpt-4o-mini' instead.",
+        m if m.contains("gpt-4-0314") => "Try 'gpt-4' or 'gpt-4-turbo' instead.",
+        m if m.contains("gpt-4-0613") => "Try 'gpt-4' or 'gpt-4-turbo' instead.",
+        m if m.contains("gpt-4-32k") => "Try 'gpt-4-turbo' (128K context) instead.",
+        m if m.contains("text-davinci") => "Try 'gpt-3.5-turbo' or 'gpt-4o-mini' instead.",
+        m if m.contains("code-davinci") => "Try 'gpt-4' or 'gpt-4-turbo' instead.",
+        // Anthropic deprecated models
+        m if m.contains("claude-instant") => "Try 'claude-3-haiku' instead.",
+        m if m.contains("claude-2.0") => "Try 'claude-3-sonnet' or 'claude-3-opus' instead.",
+        m if m.contains("claude-2.1") => "Try 'claude-3-sonnet' or 'claude-3-opus' instead.",
+        // Generic suggestion
+        _ => "Run 'cortex models list' to see available models.",
+    };
+
+    format!(
+        "{} {}",
+        suggestion, "Run 'cortex models list' for all available models."
+    )
+}
+
+/// Check if an API error message indicates a deprecated model.
+pub fn is_deprecated_model_error(error_message: &str) -> bool {
+    let lower = error_message.to_lowercase();
+    lower.contains("deprecated")
+        || lower.contains("decommissioned")
+        || lower.contains("no longer available")
+        || lower.contains("model has been removed")
+        || lower.contains("model is retired")
+        || (lower.contains("model") && lower.contains("not found") && lower.contains("has been"))
+}
+
+/// Check if SELinux is enabled and enforcing on the system.
+#[cfg(target_os = "linux")]
+pub fn is_selinux_enforcing() -> bool {
+    // Check /sys/fs/selinux/enforce (reads "1" if enforcing)
+    if let Ok(content) = std::fs::read_to_string("/sys/fs/selinux/enforce") {
+        return content.trim() == "1";
+    }
+    // Alternative: check getenforce command
+    if let Ok(output) = std::process::Command::new("getenforce").output() {
+        if let Ok(status) = String::from_utf8(output.stdout) {
+            return status.trim().eq_ignore_ascii_case("enforcing");
+        }
+    }
+    false
+}
+
+#[cfg(not(target_os = "linux"))]
+pub fn is_selinux_enforcing() -> bool {
+    false
+}
+
+/// Create a permission denied error with SELinux hint if applicable.
+pub fn permission_denied_with_selinux_check(path: PathBuf) -> CortexError {
+    if is_selinux_enforcing() {
+        CortexError::PermissionDeniedSelinux {
+            path: path.clone(),
+            hint: format!(
+                "SELinux may be blocking access. Check 'ausearch -m avc -ts recent' for denials. \
+                 Try 'restorecon -Rv {}' to fix SELinux contexts.",
+                path.display()
+            ),
+        }
+    } else {
+        CortexError::PermissionDenied { path }
+    }
+}
+
 /// Convert protocol error info to CortexError.
 impl From<cortex_protocol::CortexErrorInfo> for CortexError {
     fn from(info: cortex_protocol::CortexErrorInfo) -> Self {