toolkit: shell

Implemented-By: OpenCode session (model recorded in docs/implementer-log.md)

crates/toolkit/src/shell.rs

@@ -0,0 +1,93 @@
+//! The third tool, `shell`: run one command under `/bin/sh -c` in a directory and report its
+//! output (stdout and stderr together, in order) followed by how the command ended. The command's
+//! own exit status is part of the result, not `toolkit`'s.
+
+use std::io::{self, Read};
+use std::os::unix::process::ExitStatusExt;
+use std::path::Path;
+use std::process::{Command, Stdio};
+
+use proto::tools::ShellArgs;
+
+use crate::Outcome;
+
+pub const SHELL: &str = "/bin/sh";
+pub const DEFAULT_CWD: &str = "/tmp";
+pub const MAX_OUTPUT: usize = 1024 * 1024;
+
+pub fn shell(args: &ShellArgs) -> Outcome {
+    let cwd = match args.cwd.as_deref() {
+        Some(c) => c,
+        None => DEFAULT_CWD,
+    };
+    if !Path::new(cwd).is_dir() {
+        return Outcome::tool_error(format!("shell: {cwd}: no such directory"));
+    }
+
+    let (mut reader, writer) = match io::pipe() {
+        Ok(p) => p,
+        Err(e) => return Outcome::tool_error(format!("shell: cannot make a pipe: {e}")),
+    };
+    let writer2 = match writer.try_clone() {
+        Ok(w) => w,
+        Err(e) => return Outcome::tool_error(format!("shell: cannot make a pipe: {e}")),
+    };
+
+    let mut command = Command::new(SHELL);
+    command.arg("-c").arg(&args.command).current_dir(cwd);
+    command.stdin(Stdio::null());
+    command.stdout(writer);
+    command.stderr(writer2);
+    let mut child = match command.spawn() {
+        Ok(c) => c,
+        Err(e) => return Outcome::tool_error(format!("shell: cannot start {SHELL}: {e}")),
+    };
+    // The Command still owns the write ends; while they are open reading never reaches EOF.
+    drop(command);
+
+    let mut buf = [0u8; 8 * 1024];
+    let mut out: Vec<u8> = Vec::new();
+    let mut dropped = false;
+    loop {
+        let n = match reader.read(&mut buf) {
+            Ok(0) => break,
+            Ok(n) => n,
+            Err(e) if e.kind() == io::ErrorKind::Interrupted => continue,
+            Err(e) => return Outcome::tool_error(format!("shell: cannot read the command: {e}")),
+        };
+        if out.len() >= MAX_OUTPUT {
+            // Past the limit: keep draining so the command never blocks on a full pipe.
+            dropped = true;
+            continue;
+        }
+        let chunk = match buf.get(..n) {
+            Some(c) => c,
+            None => continue,
+        };
+        let room = MAX_OUTPUT - out.len();
+        if chunk.len() <= room {
+            out.extend_from_slice(chunk);
+        } else {
+            out.extend_from_slice(chunk.get(..room).unwrap_or_default());
+            dropped = true;
+        }
+    }
+
+    let status = match child.wait() {
+        Ok(s) => s,
+        Err(e) => return Outcome::tool_error(format!("shell: cannot wait for the command: {e}")),
+    };
+
+    let mut text = String::from_utf8_lossy(&out).into_owned();
+    if dropped {
+        text.push_str(&format!("\n[output after {MAX_OUTPUT} bytes dropped]"));
+    }
+    match status.code() {
+        Some(code) => text.push_str(&format!("\n[exit {code}]")),
+        None => match status.signal() {
+            Some(sig) => text.push_str(&format!("\n[killed by signal {sig}]")),
+            None => text.push_str("\n[ended without a status]"),
+        },
+    }
+    Outcome::done(text)
+}