njfio · njfio · Jul 13, 2025 · Jul 13, 2025 · coderabbitai · Jul 13, 2025
diff --git a/crates/fluent-agent/src/action.rs b/crates/fluent-agent/src/action.rs
@@ -1,5 +1,6 @@
 use anyhow::{anyhow, Result};
 use async_trait::async_trait;
+use log::info;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::time::{Duration, SystemTime};
@@ -621,8 +622,8 @@ impl ComprehensiveActionExecutor {
             .and_then(|v| v.as_str())
             .ok_or_else(|| anyhow!("Message not specified for communication"))?;
 
-        // For now, just log the communication
-        println!("Agent Communication: {}", message);
+        // Log the communication using structured logging
+        info!("Agent communication: {}", message);
 
         let mut metadata = HashMap::new();
         metadata.insert(

diff --git a/crates/fluent-agent/src/config.rs b/crates/fluent-agent/src/config.rs
@@ -2,6 +2,7 @@ use anyhow::{anyhow, Result};
 use fluent_core::config::load_engine_config;
 use fluent_core::traits::Engine;
 use fluent_engines::create_engine;
+use log::warn;
-use log::warn;
+        info!(
+            "🔧 Creating default {} engine with model {}",
+            engine_name, model_id
+        );
-use log::warn;
+        info!(
+            "🔧 Creating default {} engine with model {}",
+            engine_name, model_id
+        );
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::path::Path;
@@ -132,17 +133,17 @@ impl AgentEngineConfig {
                 match create_engine(&engine_config).await {
                     Ok(engine) => Ok(engine),
                     Err(e) => {
-                        eprintln!(
-                            "Warning: Failed to create engine '{}' with config: {}",
+                        warn!(
+                            "Failed to create engine '{}' with config: {}",
                             engine_name, e
                         );
                         self.create_default_engine(engine_name, credentials).await
                     }
                 }
             }
             Err(e) => {
-                eprintln!(
-                    "Warning: Engine '{}' not found in config: {}",
+                warn!(
+                    "Engine '{}' not found in config: {}",
                     engine_name, e
                 );
                 self.create_default_engine(engine_name, credentials).await

diff --git a/crates/fluent-agent/src/lib.rs b/crates/fluent-agent/src/lib.rs
@@ -89,12 +89,17 @@ impl Agent {
         fs::write(path, content).await.map_err(Into::into)
     }
 
-    /// Run a shell command and capture stdout and stderr.
+    /// Run a shell command and capture stdout and stderr with security validation.
     pub async fn run_command(&self, cmd: &str, args: &[&str]) -> Result<String> {
+        // Validate command against security policies
+        Self::validate_command_security(cmd, args)?;
+
         let output = Command::new(cmd)
             .args(args)
             .stdout(Stdio::piped())
             .stderr(Stdio::piped())
+            .env_clear() // Clear environment for security
+            .env("PATH", "/usr/bin:/bin:/usr/local/bin") // Minimal PATH
             .output()
             .await?;
         let mut result = String::from_utf8_lossy(&output.stdout).to_string();
@@ -104,6 +109,60 @@ impl Agent {
         Ok(result)
     }
 
+    /// Validate command and arguments against security policies
+    fn validate_command_security(cmd: &str, args: &[&str]) -> Result<()> {
+        // Get allowed commands from environment or use defaults
+        let allowed_commands = Self::get_allowed_commands();
+
+        // Check if command is in whitelist
+        if !allowed_commands.contains(&cmd) {
+            return Err(anyhow!("Command '{}' not in allowed list", cmd));
+        }
+
+        // Validate command name
+        if cmd.len() > 100 {
+            return Err(anyhow!("Command name too long"));
+        }
+
+        // Check for dangerous patterns in command
+        let dangerous_patterns = ["../", "./", "/", "~", "$", "`", ";", "&", "|", ">", "<"];
+        for pattern in &dangerous_patterns {
+            if cmd.contains(pattern) {
+                return Err(anyhow!("Command contains dangerous pattern: {}", pattern));
+            }
+        }
+
+        // Validate arguments
+        for arg in args {
+            if arg.len() > 1000 {
+                return Err(anyhow!("Argument too long"));
+            }
+
+            // Check for dangerous patterns in arguments
+            for pattern in &dangerous_patterns {
+                if arg.contains(pattern) {
+                    return Err(anyhow!("Argument contains dangerous pattern: {}", pattern));
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Get allowed commands from environment or defaults
+    fn get_allowed_commands() -> Vec<&'static str> {
+        // Check environment variable for custom allowed commands
+        if let Ok(custom_commands) = std::env::var("FLUENT_ALLOWED_COMMANDS") {
+            log::info!("Custom allowed commands: {}", custom_commands);
+            // TODO: Parse and return custom commands with proper lifetime management
+        }
+
+        // Default allowed commands for agent operations
+        vec![
+            "cargo", "rustc", "git", "ls", "cat", "echo", "pwd", "which", "find"
+        ]
+    }
+
     /// Commit changes in the current git repository.
     pub async fn git_commit(&self, message: &str) -> Result<()> {
         self.run_command("git", &["add", "."]).await?;

diff --git a/crates/fluent-agent/src/mcp_adapter.rs b/crates/fluent-agent/src/mcp_adapter.rs
@@ -364,7 +364,7 @@ impl ServerHandler for FluentMcpAdapter {
         let result = match params.name.as_ref() {
             "read_file" => {
                 if let Some(path) = tool_args.get("path") {
-                    match std::fs::read_to_string(path.as_str().unwrap_or("")) {
+                    match tokio::fs::read_to_string(path.as_str().unwrap_or("")).await {
                         Ok(content) => format!("File content: {}", content),
                         Err(e) => format!("Error reading file: {}", e),
                     }
@@ -375,7 +375,7 @@ impl ServerHandler for FluentMcpAdapter {
             "write_file" => {
                 if let Some(path) = tool_args.get("path") {
                     if let Some(content) = tool_args.get("content") {
-                        match std::fs::write(path.as_str().unwrap_or(""), content.as_str().unwrap_or("")) {
+                        match tokio::fs::write(path.as_str().unwrap_or(""), content.as_str().unwrap_or("")).await {
                             Ok(_) => "File written successfully".to_string(),
                             Err(e) => format!("Error writing file: {}", e),
                         }

diff --git a/crates/fluent-agent/src/mcp_client.rs b/crates/fluent-agent/src/mcp_client.rs
@@ -1,4 +1,5 @@
 use anyhow::{anyhow, Result};
+use log::warn;
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
 use std::collections::HashMap;
@@ -209,7 +210,7 @@ impl McpClient {
                 Err(e) => {
                     last_error = Some(e);
                     if attempt < self.config.retry_attempts {
-                        eprintln!(
+                        warn!(
                             "MCP connection attempt {} failed, retrying in {:?}...",
                             attempt, self.config.retry_delay
                         );

diff --git a/crates/fluent-agent/src/performance/utils.rs b/crates/fluent-agent/src/performance/utils.rs
@@ -1,3 +1,4 @@
+use log::{debug, info};
 use std::time::{Duration, Instant};
 use std::sync::{Arc, Mutex};
 use tokio::sync::Semaphore;
@@ -218,17 +219,17 @@ impl PerformanceTestUtils {
         let memory_tracker = MemoryTracker::new();
         let start_time = Instant::now();
 
-        println!("Running performance test: {}", name);
-        
+        info!("Running performance test: {}", name);
+
         for i in 0..num_operations {
             let op_start = Instant::now();
             let result = operation(i).await;
             let op_duration = op_start.elapsed();
-            
+
             counter.record_request(op_duration, result.is_err());
-            
+
             if i % (num_operations / 10).max(1) == 0 {
-                println!("  Progress: {}/{}", i + 1, num_operations);
+                debug!("  Progress: {}/{}", i + 1, num_operations);
             }
         }
 
@@ -314,15 +315,15 @@ pub struct PerformanceTestResult {
 
 impl PerformanceTestResult {
     pub fn print_summary(&self) {
-        println!("=== Performance Test Results: {} ===", self.test_name);
-        println!("  Total Duration: {:?}", self.total_duration);
-        println!("  Total Operations: {}", self.stats.total_requests);
-        println!("  Successful Operations: {}", self.stats.total_requests - self.stats.total_errors);
-        println!("  Failed Operations: {}", self.stats.total_errors);
-        println!("  Success Rate: {:.2}%", (1.0 - self.stats.error_rate) * 100.0);
-        println!("  Operations per Second: {:.2}", self.operations_per_second);
-        println!("  Average Operation Time: {:?}", self.stats.average_duration);
-        println!("  Min Operation Time: {:?}", self.stats.min_duration.unwrap_or_default());
+        info!("=== Performance Test Results: {} ===", self.test_name);
+        info!("  Total Duration: {:?}", self.total_duration);
+        info!("  Total Operations: {}", self.stats.total_requests);
+        info!("  Successful Operations: {}", self.stats.total_requests - self.stats.total_errors);
+        info!("  Failed Operations: {}", self.stats.total_errors);
+        info!("  Success Rate: {:.2}%", (1.0 - self.stats.error_rate) * 100.0);
+        info!("  Operations per Second: {:.2}", self.operations_per_second);
+        info!("  Average Operation Time: {:?}", self.stats.average_duration);
+        info!("  Min Operation Time: {:?}", self.stats.min_duration.unwrap_or_default());
         println!("  Max Operation Time: {:?}", self.stats.max_duration.unwrap_or_default());
         println!("  Peak Memory Usage: {} bytes ({:.2} MB)", 
                  self.peak_memory_usage, 

diff --git a/crates/fluent-agent/src/tools/mod.rs b/crates/fluent-agent/src/tools/mod.rs
@@ -303,19 +303,61 @@ pub mod validation {
         ))
     }
 
-    /// Validate that a command is in the allowed list
+    /// Validate that a command is in the allowed list with enhanced security checks
     pub fn validate_command(command: &str, allowed_commands: &[String]) -> Result<()> {
+        // Basic input validation
+        if command.is_empty() {
+            return Err(anyhow::anyhow!("Command cannot be empty"));
+        }
+
+        if command.len() > 1000 {
+            return Err(anyhow::anyhow!("Command too long (max 1000 characters)"));
+        }
+
+        // Check for null bytes and dangerous control characters
+        if command.contains('\0') || command.chars().any(|c| c.is_control() && c != '\n' && c != '\t' && c != '\r') {
+            return Err(anyhow::anyhow!("Command contains invalid control characters"));
+        }
+
+        // Enhanced dangerous pattern detection
+        let dangerous_patterns = [
+            // Command injection patterns
+            "$(", "`", ";", "&&", "||", "|", ">", ">>", "<", "<<",
+            // Path traversal
+            "../", "./", "~", "/etc/", "/proc/", "/sys/", "/dev/",
+            // Privilege escalation
+            "sudo", "su ", "doas", "pkexec",
+            // Network operations
+            "curl", "wget", "nc ", "netcat", "telnet", "ssh", "scp",
+            // File operations
+            "rm ", "rmdir", "del ", "format", "mkfs", "dd ",
+            // Process control
+            "kill", "killall", "pkill", "&", "nohup",
+            // Script execution
+            "bash", "sh ", "zsh", "python", "perl", "ruby", "node",
+            "eval", "exec", "source", ".",
-            "eval", "exec", "source", ".",
+            "eval", "exec", "source ", ". ",
-            "eval", "exec", "source", ".",
+            "eval", "exec", "source ", ". ",
+        ];
+
         let command_lower = command.to_lowercase();
+        for pattern in &dangerous_patterns {
+            if command_lower.contains(pattern) {
+                return Err(anyhow::anyhow!(
+                    "Command contains dangerous pattern '{}': {}",
+                    pattern, command
+                ));
+            }
+        }
 
+        // Check against allowed commands list
         for allowed in allowed_commands {
             if command_lower.starts_with(&allowed.to_lowercase()) {
                 return Ok(());
             }
         }
 
         Err(anyhow::anyhow!(
-            "Command '{}' is not in the allowed commands list",
-            command
+            "Command '{}' is not in the allowed commands list: {:?}",
+            command, allowed_commands
         ))
     }