dagger-components/crates/cuddle-ci/src/cuddle_x.rs

pub struct CuddleX {
    command: String,
    args: Vec<String>,
}

impl CuddleX {
    pub fn command(command: impl Into<String>) -> Self {
        Self {
            command: command.into(),
            args: Vec::new(),
        }
    }
    pub fn arg(&mut self, arg: impl Into<String>) -> &mut Self {
        self.args.push(arg.into());

        self
    }

    pub async fn run(&mut self) -> eyre::Result<(String, String, i32)> {
        let mut cmd = tokio::process::Command::new("cuddle");

        let cmd = cmd
            .arg("x")
            .arg(&self.command)
            .args(&self.args)
            .stdout(std::process::Stdio::inherit())
            .stderr(std::process::Stdio::inherit());

        let output = cmd.output().await?;

        Ok((
            std::str::from_utf8(&output.stdout)?.to_string(),
            std::str::from_utf8(&output.stderr)?.to_string(),
            output.status.code().unwrap_or(0),
        ))
    }
}

pub mod well_known {
    use super::CuddleX;

    pub async fn render() -> eyre::Result<()> {
        tracing::info!("running render");
        let (stdout, stderr, status) = CuddleX::command("render").run().await?;

        for line in stdout.lines() {
            tracing::trace!("render: {}", line);
        }

        for line in stderr.lines() {
            tracing::trace!("render: {}", line);
        }

        if status != 0 {
            tracing::warn!("finished render with non-zero exit code: {}", status);
        }

        tracing::info!("finished running render");

        Ok(())
    }
}