file size check; http request timeout; fix error handling

Author: alexylon

src/api/client.rs

@@ -3,13 +3,14 @@ use super::types::*;
 use futures::stream::{Stream, StreamExt};
 use reqwest::header::{HeaderMap, HeaderValue, CONTENT_TYPE};
 use std::pin::Pin;
+use std::time::Duration;
 
 const API_BASE: &str = "https://api.anthropic.com/v1";
 const API_VERSION: &str = "2023-06-01";
+const REQUEST_TIMEOUT: Duration = Duration::from_secs(60);
 
 pub struct AnthropicClient {
     client: reqwest::Client,
-    _api_key: String,
 }
 
 impl AnthropicClient {
@@ -28,10 +29,11 @@ impl AnthropicClient {
 
         let client = reqwest::Client::builder()
             .default_headers(headers)
+            .timeout(REQUEST_TIMEOUT)
             .build()
             .map_err(|e| SofosError::Config(format!("Failed to create HTTP client: {}", e)))?;
 
-        Ok(Self { client, _api_key: api_key })
+        Ok(Self { client })
     }
 
     pub async fn create_message(

src/repl.rs

@@ -2,7 +2,7 @@ use crate::api::{AnthropicClient, ContentBlock, CreateMessageRequest, MorphClien
 use crate::conversation::ConversationHistory;
 use crate::error::{Result, SofosError};
 use crate::tools::{add_code_search_tool, get_tools, get_tools_with_morph, ToolExecutor};
-use colored::Colorize;
+use colored::{Colorize};
 use rustyline::error::ReadlineError;
 use rustyline::DefaultEditor;
 use std::path::PathBuf;
@@ -313,7 +313,7 @@ impl Repl {
                 let mut frame_idx = 0;
 
                 while thinking_clone.load(Ordering::Relaxed) {
-                    print!("\r{} {}", frames[frame_idx].bright_cyan(), "Thinking...".bright_cyan());
+                    print!("\r{} {}", frames[frame_idx].truecolor(0xFF, 0x99, 0x33), "Thinking...".truecolor(0xFF, 0x99, 0x33));
                     let _ = io::stdout().flush();
                     frame_idx = (frame_idx + 1) % frames.len();
                     thread::sleep(Duration::from_millis(80));
@@ -350,13 +350,17 @@ impl Repl {
                 Ok(resp) => {
                     // Stop animation
                     thinking.store(false, Ordering::Relaxed);
-                    let _ = animation_handle.join();
+                    if let Err(e) = animation_handle.join() {
+                        eprintln!("{} Animation thread panicked: {:?}", "Warning:".bright_yellow().bold(), e);
+                    }
                     resp
                 },
                 Err(e) => {
                     // Stop animation on error
                     thinking.store(false, Ordering::Relaxed);
-                    let _ = animation_handle.join();
+                    if let Err(panic_err) = animation_handle.join() {
+                        eprintln!("{} Animation thread panicked: {:?}", "Warning:".bright_yellow().bold(), panic_err);
+                    }
                     eprintln!("{} Failed to get response after tool execution: {}", "Error:".bright_red().bold(), e);
                     return Err(e);
                 }

src/tools/filesystem.rs

@@ -2,6 +2,8 @@ use crate::error::{Result, SofosError};
 use std::fs;
 use std::path::{Path, PathBuf};
 
+const MAX_FILE_SIZE: u64 = 50 * 1024 * 1024; // 50MB limit
+
 /// FileSystemTool provides secure file operations sandboxed to a workspace directory
 pub struct FileSystemTool {
     workspace: PathBuf,
@@ -82,6 +84,17 @@ impl FileSystemTool {
             )));
         }
 
+        // Check file size before reading to prevent OOM
+        let metadata = fs::metadata(&full_path).map_err(SofosError::Io)?;
+        if metadata.len() > MAX_FILE_SIZE {
+            return Err(SofosError::InvalidPath(format!(
+                "File '{}' is too large ({} bytes). Maximum size is {} MB",
+                path,
+                metadata.len(),
+                MAX_FILE_SIZE / (1024 * 1024)
+            )));
+        }
+
         fs::read_to_string(&full_path).map_err(|e| {
             SofosError::Io(e)
         })

src/tools/search.rs

@@ -130,12 +130,6 @@ impl WebSearchTool {
     }
 }
 
-impl Default for WebSearchTool {
-    fn default() -> Self {
-        Self::new().expect("Failed to create WebSearchTool")
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;