Add command execution to the coding-human CLI

Co-authored-by: tknkaa <145080781+tknkaa@users.noreply.github.com>

Author: Copilot

cli/src/ask.rs

@@ -6,7 +6,7 @@ use reqwest::Client;
 use std::io::{self, Write};
 use tokio_tungstenite::{connect_async, tungstenite::Message};
 
-pub async fn run() -> Result<()> {
+pub async fn run(yes: bool) -> Result<()> {
     dotenvy::dotenv().ok();
     let server_url =
         std::env::var("SERVER_URL").unwrap_or_else(|_| "http://localhost:8787".to_string());
@@ -86,6 +86,54 @@ pub async fn run() -> Result<()> {
                         println!();
                         break;
                     }
+                    // Check if this is a JSON command message
+                    if let Ok(json) = serde_json::from_str::<serde_json::Value>(&msg) {
+                        if json["type"].as_str() == Some("cmd") {
+                            let command = json["command"].as_str().unwrap_or("").to_string();
+                            println!("\nRun: {}?", command);
+
+                            let execute = if yes {
+                                true
+                            } else {
+                                print!("[y/n]: ");
+                                io::stdout().flush()?;
+                                let mut answer = String::new();
+                                io::stdin().read_line(&mut answer)?;
+                                answer.trim().eq_ignore_ascii_case("y")
+                            };
+
+                            let output = if execute {
+                                let result = tokio::process::Command::new("sh")
+                                    .arg("-c")
+                                    .arg(&command)
+                                    .output()
+                                    .await?;
+                                let stdout = String::from_utf8_lossy(&result.stdout).to_string();
+                                let stderr = String::from_utf8_lossy(&result.stderr).to_string();
+                                match (stdout.is_empty(), stderr.is_empty()) {
+                                    (false, false) => format!("{}\n[stderr]\n{}", stdout, stderr),
+                                    (false, true) => stdout,
+                                    (true, false) => stderr,
+                                    (true, true) => String::new(),
+                                }
+                            } else {
+                                "(skipped)".to_string()
+                            };
+
+                            let result_msg = serde_json::json!({
+                                "type": "cmd_result",
+                                "command": command,
+                                "output": output,
+                            })
+                            .to_string();
+                            write.send(Message::text(result_msg)).await?;
+                            // Reset spinner for next chunk
+                            first_chunk = true;
+                            spinner.reset();
+                            spinner.set_message("Waiting for answer");
+                            continue;
+                        }
+                    }
                     print!("{}", msg);
                     io::stdout().flush()?;
                 }

cli/src/main.rs

@@ -14,7 +14,11 @@ struct Cli {
 #[derive(Subcommand)]
 enum Commands {
     /// Ask a question to an available programmer
-    Ask,
+    Ask {
+        /// Automatically execute commands sent by the programmer without prompting
+        #[arg(long)]
+        yes: bool,
+    },
     /// Register as a programmer and wait for questions
     Serve {
         /// Your display name shown to clients
@@ -27,8 +31,8 @@ async fn main() {
     let cli = Cli::parse();
 
     match cli.command {
-        Commands::Ask => {
-            if let Err(e) = ask::run().await {
+        Commands::Ask { yes } => {
+            if let Err(e) = ask::run(yes).await {
                 eprintln!("Error: {}", e);
                 std::process::exit(1);
             }

cli/src/serve.rs

@@ -55,18 +55,51 @@ pub async fn run(label: String) -> Result<()> {
         };
 
         println!("\nQuestion: {}\n", question);
-        println!("Answer (Ctrl+D to finish):\n");
+        println!("Answer (Ctrl+D to finish, prefix a line with $ to run a command on client):\n");
 
         loop {
             let mut line = String::new();
-            if async_stdin.read_line(&mut line).await? == 0 {
-                write.send(Message::Text("[DONE]".to_string())).await?;
-                println!();
-                break;
+            tokio::select! {
+                n = async_stdin.read_line(&mut line) => {
+                    if n? == 0 {
+                        write.send(Message::Text("[DONE]".to_string())).await?;
+                        println!();
+                        break;
+                    }
+                    let trimmed = line.trim_end_matches('\n');
+                    if let Some(cmd) = trimmed.strip_prefix('$') {
+                        let command = cmd.trim().to_string();
+                        let msg = serde_json::json!({"type": "cmd", "command": command}).to_string();
+                        write.send(Message::text(msg)).await?;
+                    } else {
+                        write.send(Message::text(trimmed)).await?;
+                    }
+                }
+                ws_msg = read.next() => {
+                    match ws_msg {
+                        Some(Ok(Message::Text(msg))) => {
+                            if let Ok(json) = serde_json::from_str::<serde_json::Value>(&msg) {
+                                if json["type"].as_str() == Some("cmd_result") {
+                                    let command = json["command"].as_str().unwrap_or("");
+                                    let output = json["output"].as_str().unwrap_or("");
+                                    println!("\n[cmd result] $ {}\n{}", command, output);
+                                }
+                            }
+                        }
+                        Some(Ok(Message::Close(_))) => {
+                            println!("Client disconnected.");
+                            let _ = client
+                                .delete(format!("{}/queue/{}", server_url, room_id))
+                                .send()
+                                .await;
+                            return Ok(());
+                        }
+                        Some(Err(e)) => return Err(e.into()),
+                        None => return Err(anyhow::anyhow!("Connection lost")),
+                        _ => {}
+                    }
+                }
             }
-            write
-                .send(Message::text(line.trim_end_matches('\n')))
-                .await?;
         }
     }
 }