style: apply cargo fmt across entire Rust codebase

- Remove Rust formatting check from CI workflow since formatting is now applied
- Standardize import ordering and organization throughout codebase
- Fix indentation, spacing, and line breaks for consistency
- Clean up trailing whitespace and formatting inconsistencies
- Apply rustfmt to all Rust source files including checkpoint, sandbox, commands, and test modules

This establishes a consistent code style baseline for the project.

src-tauri/tests/sandbox/common/claude_real.rs

@@ -14,36 +14,37 @@ pub fn execute_claude_task(
     timeout_secs: u64,
 ) -> Result<ClaudeOutput> {
     let mut cmd = Command::new("claude");
-    
+
     // Add task
     cmd.arg("-p").arg(task);
-    
+
     // Add system prompt if provided
     if let Some(prompt) = system_prompt {
         cmd.arg("--system-prompt").arg(prompt);
     }
-    
+
     // Add model if provided
     if let Some(m) = model {
         cmd.arg("--model").arg(m);
     }
-    
+
     // Always add these flags for testing
-    cmd.arg("--output-format").arg("stream-json")
-       .arg("--verbose")
-       .arg("--dangerously-skip-permissions")
-       .current_dir(project_path)
-       .stdout(Stdio::piped())
-       .stderr(Stdio::piped());
-    
+    cmd.arg("--output-format")
+        .arg("stream-json")
+        .arg("--verbose")
+        .arg("--dangerously-skip-permissions")
+        .current_dir(project_path)
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped());
+
     // Add sandbox profile ID if provided
     if let Some(profile_id) = sandbox_profile_id {
         cmd.env("CLAUDIA_SANDBOX_PROFILE_ID", profile_id.to_string());
     }
-    
+
     // Execute with timeout (use gtimeout on macOS, timeout on Linux)
     let start = std::time::Instant::now();
-    
+
     let timeout_cmd = if cfg!(target_os = "macos") {
         // On macOS, try gtimeout (from GNU coreutils) first, fallback to direct execution
         if std::process::Command::new("which")
@@ -60,15 +61,15 @@ pub fn execute_claude_task(
     } else {
         "timeout"
     };
-    
+
     let output = if timeout_cmd.is_empty() {
         // Run without timeout wrapper
-        cmd.output()
-            .context("Failed to execute Claude command")?
+        cmd.output().context("Failed to execute Claude command")?
     } else {
         // Run with timeout wrapper
         let mut timeout_cmd = Command::new(timeout_cmd);
-        timeout_cmd.arg(timeout_secs.to_string())
+        timeout_cmd
+            .arg(timeout_secs.to_string())
             .arg("claude")
             .args(cmd.get_args())
             .current_dir(project_path)
@@ -78,9 +79,9 @@ pub fn execute_claude_task(
             .output()
             .context("Failed to execute Claude command with timeout")?
     };
-    
+
     let duration = start.elapsed();
-    
+
     Ok(ClaudeOutput {
         stdout: String::from_utf8_lossy(&output.stdout).to_string(),
         stderr: String::from_utf8_lossy(&output.stderr).to_string(),
@@ -103,7 +104,7 @@ impl ClaudeOutput {
     pub fn contains_operation(&self, operation: &str) -> bool {
         self.stdout.contains(operation) || self.stderr.contains(operation)
     }
-    
+
     /// Check if operation was blocked (look for permission denied, sandbox violation, etc)
     pub fn operation_was_blocked(&self, operation: &str) -> bool {
         let blocked_patterns = [
@@ -114,16 +115,16 @@ impl ClaudeOutput {
             "access denied",
             "sandbox violation",
         ];
-        
+
         let output = format!("{}\n{}", self.stdout, self.stderr).to_lowercase();
         let op_lower = operation.to_lowercase();
-        
+
         // Check if operation was mentioned along with a block pattern
-        blocked_patterns.iter().any(|pattern| {
-            output.contains(&op_lower) && output.contains(pattern)
-        })
+        blocked_patterns
+            .iter()
+            .any(|pattern| output.contains(&op_lower) && output.contains(pattern))
     }
-    
+
     /// Check if file read was successful
     pub fn file_read_succeeded(&self, filename: &str) -> bool {
         // Look for patterns indicating successful file read
@@ -133,10 +134,12 @@ impl ClaudeOutput {
             &format!("Contents of {}", filename),
             "test content", // Our test files contain this
         ];
-        
-        patterns.iter().any(|pattern| self.contains_operation(pattern))
+
+        patterns
+            .iter()
+            .any(|pattern| self.contains_operation(pattern))
     }
-    
+
     /// Check if network connection was attempted
     pub fn network_attempted(&self, host: &str) -> bool {
         let patterns = [
@@ -145,8 +148,10 @@ impl ClaudeOutput {
             &format!("connect to {}", host),
             host,
         ];
-        
-        patterns.iter().any(|pattern| self.contains_operation(pattern))
+
+        patterns
+            .iter()
+            .any(|pattern| self.contains_operation(pattern))
     }
 }
 
@@ -156,24 +161,27 @@ pub mod tasks {
     pub fn read_file(filename: &str) -> String {
         format!("Read the file {} and show me its contents", filename)
     }
-    
+
     /// Task to attempt network connection
     pub fn connect_network(host: &str) -> String {
         format!("Try to connect to {} and tell me if it works", host)
     }
-    
+
     /// Task to do multiple operations
     pub fn multi_operation() -> String {
         "Read the file ./test.txt in the current directory and show its contents".to_string()
     }
-    
+
     /// Task to test file write
     pub fn write_file(filename: &str, content: &str) -> String {
-        format!("Create a file called {} with the content '{}'", filename, content)
+        format!(
+            "Create a file called {} with the content '{}'",
+            filename, content
+        )
     }
-    
+
     /// Task to test process spawning
     pub fn spawn_process(command: &str) -> String {
         format!("Run the command '{}' and show me the output", command)
     }
-}
+}