lets just keep trying to get ai to fix this command

src/commands/system/deploy.rs

@@ -7,7 +7,7 @@ use crate::commands::argument::{ArgumentSpec, ParsedArguments};
 use async_trait::async_trait;
 use std::io::{BufRead, BufReader, Read};
 use std::process::{Child, Command as SysCommand, Stdio};
-use std::sync::Arc;
+use std::sync::Arc;  
 use tokio::sync::Mutex;
 use tokio::task;
 
@@ -96,61 +96,81 @@ impl Command for DeployCommand {
         }
 
         client.message("Running `cargo run --release`...").await;
-        let mut cargo_child = match SysCommand::new("cargo")
-            .arg("run")
-            .arg("--release")
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .spawn()
-        {
-            Ok(child) => child,
-            Err(e) => {
-                client
-                    .message(format!("Failed to start cargo run: {}", e))
-                    .await;
-                return;
-            }
-        };
-
-        let cargo_stdout = cargo_child.stdout.take().unwrap();
-        let cargo_stderr = cargo_child.stderr.take().unwrap();
 
         let client_clone = client.clone();
+        let client_clone2 = client.clone();
         let found_connected = Arc::new(Mutex::new(false));
         let found_connected_cargo = found_connected.clone();
 
-        task::spawn_blocking(async move || {
+        // Spawn cargo run --release in a separate blocking task
-            let reader = BufReader::new(cargo_stdout);
+        let running_arc = self.running.clone();
-            for line in reader.lines() {
+        let cargo_task = task::spawn_blocking(move || {
-                match line {
+            let mut cargo_child = match SysCommand::new("cargo")
-                    Ok(l) => {
+                .arg("run")
-                        let msg = format!("cargo: {}", l);
+                .arg("--release")
-                        let _ = client_clone.message(msg.clone()).await;
+                .stdout(Stdio::piped())
-                        if l.contains("[CONNECTED]") {
+                .stderr(Stdio::piped())
-                            let mut found = found_connected_cargo.blocking_lock();
+                .spawn()
-                            *found = true;
+            {
-                            break;
+                Ok(child) => child,
+                Err(e) => {
+                    let _ = client_clone.message(format!("Failed to start cargo run: {}", e));
+                    return;
+                }
+            };
+
+            // Save the child handle for later killing
+            {
+                let mut running = running_arc.blocking_lock();
+                *running = Some(cargo_child.try_clone().unwrap());
+            }
+
+            let cargo_stdout = cargo_child.stdout.take().unwrap();
+            let cargo_stderr = cargo_child.stderr.take().unwrap();
+
+            // stdout handler
+            let client_clone_stdout = client_clone.clone();
+            let found_connected_cargo_stdout = found_connected_cargo.clone();
+            let stdout_handle = std::thread::spawn(move || {
+                let reader = BufReader::new(cargo_stdout);
+                for line in reader.lines() {
+                    match line {
+                        Ok(l) => {
+                            let msg = format!("cargo: {}", l);
+                            let _ = client_clone_stdout.message(msg);
+                            if l.contains("[CONNECTED]") {
+                                let mut found = found_connected_cargo_stdout.blocking_lock();
+                                *found = true;
+                                break;
+                            }
                         }
+                        Err(_) => break,
                     }
-                    Err(_) => break,
                 }
-            }
+            });
-        });
+
-
+            // stderr handler
-        let client_clone2 = client.clone();
+            let client_clone_stderr = client_clone2.clone();
-        task::spawn_blocking(async move || {
+            let stderr_handle = std::thread::spawn(move || {
-            let reader = BufReader::new(cargo_stderr);
+                let reader = BufReader::new(cargo_stderr);
-            for line in reader.lines() {
+                for line in reader.lines() {
-                match line {
+                    match line {
-                    Ok(l) => {
+                        Ok(l) => {
-                        let msg = format!("cargo stderr: {}", l);
+                            let msg = format!("cargo stderr: {}", l);
-                        let _ = client_clone2.message(msg.clone()).await;
+                            let _ = client_clone_stderr.message(msg);
-                    }
+                        }
-                    Err(_) => break,
+                        Err(_) => break,
-                }
+                    }
-            }
+                }
+            });
+
+            let _ = stdout_handle.join();
+            let _ = stderr_handle.join();
+
+            let _ = cargo_child.wait();
         });
 
+        // Wait for [CONNECTED] from cargo run --release
         loop {
             {
                 let found = found_connected.lock().await;
@@ -260,6 +280,7 @@ impl Command for DeployCommand {
             }
         }
 
+        // Step 5: Wait for [CONNECTED] from systemctl copper
         client
             .message("Waiting for [CONNECTED] from systemctl copper...")
             .await;