malvin 0.2.6

Non-interactive research and coding agent
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

#[cfg(unix)]
use std::io::Read;
#[cfg(unix)]
use std::os::unix::process::CommandExt;
#[cfg(unix)]
use std::path::Path;
#[cfg(unix)]
use std::process::{Child, Command, Stdio};
#[cfg(unix)]
use std::thread::{self, JoinHandle};
#[cfg(unix)]
use std::time::{Duration, Instant};

#[cfg(unix)]
pub type PipedChildHandles = (Child, JoinHandle<Vec<u8>>, JoinHandle<Vec<u8>>);

#[cfg(unix)]
fn kill_bin() -> &'static Path {
    if Path::new("/bin/kill").is_file() {
        Path::new("/bin/kill")
    } else {
        Path::new("/usr/bin/kill")
    }
}

#[cfg(unix)]
fn kill_process_group(pid: u32) {
    let _ = Command::new(kill_bin())
        .args(["-KILL", &format!("-{pid}")])
        .status();
}

#[cfg(unix)]
fn join_stdio_reader(jh: JoinHandle<Vec<u8>>) -> std::io::Result<Vec<u8>> {
    jh.join()
        .map_err(|_| std::io::Error::other("malvin subprocess reader panicked"))
}

#[cfg(unix)]
fn subprocess_wait_poll_interval() -> Duration {
    if std::env::var_os("MALVIN_TEST_NO_REAL_AGENT").is_some() {
        Duration::from_millis(1)
    } else {
        Duration::from_millis(20)
    }
}

#[cfg(unix)]
fn wait_for_subprocess_tick(spin_budget: &mut u32) {
    if std::env::var_os("MALVIN_TEST_NO_REAL_AGENT").is_some() && *spin_budget > 0 {
        *spin_budget -= 1;
        std::hint::spin_loop();
        return;
    }
    std::thread::sleep(subprocess_wait_poll_interval());
}

#[cfg(unix)]
fn output_joined(
    status: std::process::ExitStatus,
    stdout_jh: JoinHandle<Vec<u8>>,
    stderr_jh: JoinHandle<Vec<u8>>,
) -> std::io::Result<std::process::Output> {
    Ok(std::process::Output {
        status,
        stdout: join_stdio_reader(stdout_jh)?,
        stderr: join_stdio_reader(stderr_jh)?,
    })
}

#[cfg(unix)]
pub fn spawn_piped_process_group(cmd: &mut Command) -> std::io::Result<PipedChildHandles> {
    cmd.stdout(Stdio::piped()).stderr(Stdio::piped());
    cmd.process_group(0);
    let mut child = cmd.spawn()?;
    let stdout = child.stdout.take().expect("stdout piped");
    let stderr = child.stderr.take().expect("stderr piped");
    let stdout_jh = thread::spawn(move || {
        let mut stdout = stdout;
        let mut v = Vec::new();
        let _ = stdout.read_to_end(&mut v);
        v
    });
    let stderr_jh = thread::spawn(move || {
        let mut stderr = stderr;
        let mut v = Vec::new();
        let _ = stderr.read_to_end(&mut v);
        v
    });
    Ok((child, stdout_jh, stderr_jh))
}

#[cfg(unix)]
pub fn wait_child_with_timeout(
    mut child: Child,
    stdout_jh: JoinHandle<Vec<u8>>,
    stderr_jh: JoinHandle<Vec<u8>>,
    deadline: Instant,
) -> std::io::Result<std::process::Output> {
    let mut spin_budget = if std::env::var_os("MALVIN_TEST_NO_REAL_AGENT").is_some() {
        500
    } else {
        0
    };
    loop {
        match child.try_wait() {
            Ok(Some(status)) => return output_joined(status, stdout_jh, stderr_jh),
            Ok(None) => {
                if Instant::now() > deadline {
                    kill_process_group(child.id());
                    let _ = child.wait();
                    let stdout = join_stdio_reader(stdout_jh)?;
                    let stderr = join_stdio_reader(stderr_jh)?;
                    let stdout_text = String::from_utf8_lossy(&stdout);
                    let stderr_text = String::from_utf8_lossy(&stderr);
                    return Err(std::io::Error::new(
                        std::io::ErrorKind::TimedOut,
                        format!(
                            "malvin subprocess timed out; stdout={stdout_text:?}; stderr={stderr_text:?}"
                        ),
                    ));
                }
                wait_for_subprocess_tick(&mut spin_budget);
            }
            Err(e) => {
                let _ = stdout_jh.join();
                let _ = stderr_jh.join();
                return Err(e);
            }
        }
    }
}