xtui 0.2.0

TUI for discovering and running project commands (xtask, cargo, just, nu, npm, make, mise)
Documentation 
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
133
134
135
136
137
138
139
140

use anyhow::Result;
use futures_util::StreamExt;
use std::path::Path;
use std::process::Stdio;
use tokio::process::{Child, Command};
use tokio::sync::mpsc;
use tokio_util::codec::{FramedRead, LinesCodec};

/// Encapsulates a running child process and its line-output channel.
pub struct RunningTask {
    child: Child,
    rx: mpsc::Receiver<String>,
}

impl Drop for RunningTask {
    fn drop(&mut self) {
        // Best-effort sync kill to avoid orphaned processes on quit
        let _ = self.child.start_kill();
    }
}

impl RunningTask {
    /// Drain any buffered lines from the output channel.
    pub fn poll_lines(&mut self, buf: &mut Vec<String>) {
        while let Ok(line) = self.rx.try_recv() {
            buf.push(line);
        }
    }

    /// Check if the child has exited; return exit code if so.
    pub fn try_exit_code(&mut self) -> Option<i32> {
        match self.child.try_wait() {
            Ok(Some(status)) => status.code(),
            _ => None,
        }
    }

    /// Kill the child process.
    pub async fn cancel(&mut self) {
        let _ = self.child.kill().await;
    }
}

pub async fn spawn_command(program: &str, args: &[&str], cwd: &Path) -> Result<RunningTask> {
    let mut child = Command::new(program)
        .args(args)
        .current_dir(cwd)
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()?;

    let stdout = child.stdout.take().unwrap();
    let stderr = child.stderr.take().unwrap();

    let (tx, rx) = mpsc::channel(1024);
    let tx2 = tx.clone();

    tokio::spawn(async move {
        let mut reader = FramedRead::new(stdout, LinesCodec::new());
        while let Some(Ok(line)) = reader.next().await {
            if tx.send(line).await.is_err() {
                break;
            }
        }
    });

    tokio::spawn(async move {
        let mut reader = FramedRead::new(stderr, LinesCodec::new());
        while let Some(Ok(line)) = reader.next().await {
            if tx2.send(line).await.is_err() {
                break;
            }
        }
    });

    Ok(RunningTask { child, rx })
}

pub async fn run_xtask(workspace: &Path, command: &str) -> Result<RunningTask> {
    let manifest = workspace.join("xtask/Cargo.toml");
    let manifest_str = manifest.to_string_lossy().to_string();
    let parts: Vec<&str> = command.split_whitespace().collect();
    let mut args = vec!["run", "--quiet", "--manifest-path", &manifest_str, "--"];
    args.extend(parts);
    spawn_command("cargo", &args, workspace).await
}

pub async fn run_source_command(
    workspace: &Path,
    cmd: &crate::source::SourceCommand,
) -> Result<RunningTask> {
    match cmd.source.as_str() {
        "xtask" => run_xtask(workspace, &cmd.name).await,
        "cargo" => {
            let parts: Vec<&str> = cmd.name.split_whitespace().collect();
            spawn_command("cargo", &parts, workspace).await
        }
        "just" => spawn_command("just", &[cmd.name.as_str()], workspace).await,
        "nu" => {
            let script = format!("scripts/{}.nu", cmd.name);
            spawn_command("nu", &[script.as_str()], workspace).await
        }
        "npm" => spawn_command("npm", &["run", &cmd.name], workspace).await,
        "make" => spawn_command("make", &[cmd.name.as_str()], workspace).await,
        "mise" => spawn_command("mise", &["run", &cmd.name], workspace).await,
        "cargo-bin" => {
            let parts: Vec<&str> = cmd.name.split_whitespace().collect();
            let (bin, args) = parts.split_first().unwrap_or((&"", &[]));
            let bin_path = dirs::home_dir()
                .ok_or_else(|| anyhow::anyhow!("no home directory"))?
                .join(".cargo")
                .join("bin")
                .join(bin);
            spawn_command(&bin_path.to_string_lossy(), args, workspace).await
        }
        other => anyhow::bail!("unknown source: {other}"),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_run_captures_output() {
        let mut task = spawn_command("echo", &["hello"], std::path::Path::new("."))
            .await
            .unwrap();

        // Wait for process to finish
        tokio::time::sleep(std::time::Duration::from_millis(100)).await;

        let mut lines = Vec::new();
        task.poll_lines(&mut lines);
        assert!(
            lines.iter().any(|l| l.contains("hello")),
            "expected 'hello' in output, got: {lines:?}"
        );
    }
}