aleoflow 0.1.1

A developer CLI for Aleo — scaffold, build, test, audit, deploy, and generate TypeScript bindings for Leo programs.
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
141
142
143
144
145

use anyhow::{Context, Result, bail};
use std::io::{self, Write};
use std::path::{Path, PathBuf};
use std::process::Command;

/// Run a `leo` subcommand, optionally inside a specific project directory.
///
/// Inherits stdout/stderr so the user sees Leo's real output directly.
/// Returns a descriptive error if `leo` is not found or the subcommand fails.
pub fn run_leo(subcommand: &str, dir: Option<&Path>) -> Result<()> {
    run_leo_with(subcommand, &[], dir)
}

/// Run a `leo` subcommand with extra flags, optionally in a project directory.
pub fn run_leo_with(subcommand: &str, extra_flags: &[String], dir: Option<&Path>) -> Result<()> {
    let mut cmd = Command::new("leo");
    cmd.arg(subcommand);
    for flag in extra_flags {
        cmd.arg(flag);
    }

    if let Some(path) = dir {
        cmd.current_dir(path);
    }

    let status = cmd.status().with_context(|| {
        format!(
            "Failed to execute 'leo {}'. \
             Make sure leo is installed and on your PATH.\n\
             Install it with: cargo binstall leo-lang",
            subcommand
        )
    })?;

    if !status.success() {
        let code = status.code().unwrap_or(-1);
        bail!("'leo {}' failed with exit code {}", subcommand, code);
    }

    Ok(())
}

/// Check whether `leo` is available on PATH.
pub fn leo_is_installed() -> bool {
    Command::new("leo")
        .arg("--version")
        .output()
        .map(|o| o.status.success())
        .unwrap_or(false)
}

/// Check whether `snarkos` is available on PATH.
pub fn snarkos_is_installed() -> bool {
    Command::new("snarkos")
        .arg("--version")
        .output()
        .map(|o| o.status.success())
        .unwrap_or(false)
}

/// Check whether `leo-fmt` (the leo fmt plugin) is available on PATH.
pub fn leo_fmt_is_installed() -> bool {
    Command::new("leo-fmt")
        .arg("--version")
        .output()
        .map(|o| o.status.success())
        .unwrap_or(false)
}

/// Run a `leo` subcommand, capturing stdout and stderr for error analysis.
///
/// Prints leo's raw stdout and stderr to the terminal (so the user sees
/// the real output live), then returns a (result, captured_stderr) tuple.
/// The captured stderr is always returned (empty string on success) so the
/// caller can pass it directly to error translation without anyohw chaining.
///
/// This is designed for `run` and `execute` where leo errors have known
/// patterns that AleoFlow can translate into friendlier summaries.
/// Other commands (build, test, deploy) should use the simpler `run_leo_with`
/// which inherits stdio directly.
pub fn run_leo_captured(
    subcommand: &str,
    extra_flags: &[String],
    dir: Option<&Path>,
) -> (Result<()>, String) {
    let mut cmd = Command::new("leo");
    cmd.arg(subcommand);
    for flag in extra_flags {
        cmd.arg(flag);
    }

    if let Some(path) = dir {
        cmd.current_dir(path);
    }

    let output = match cmd.output() {
        Ok(o) => o,
        Err(e) => {
            return (
                Err(anyhow::Error::from(e).context(format!(
                    "Failed to execute 'leo {}'. \
                     Make sure leo is installed and on your PATH.\n\
                     Install it with: cargo binstall leo-lang",
                    subcommand
                ))),
                String::new(),
            );
        }
    };

    // Print leo's raw output to the terminal (stdout first, then stderr)
    if !output.stdout.is_empty() {
        let _ = io::stdout().write_all(&output.stdout);
    }
    if !output.stderr.is_empty() {
        let _ = io::stderr().write_all(&output.stderr);
    }

    let stderr = String::from_utf8_lossy(&output.stderr).to_string();

    if !output.status.success() {
        let code = output.status.code().unwrap_or(-1);
        (
            Err(anyhow::anyhow!(
                "'leo {}' failed with exit code {}",
                subcommand, code
            )),
            stderr,
        )
    } else {
        (Ok(()), stderr)
    }
}

/// Build the `--json-output[=<PATH>]` flags based on the user's setting.
/// Returns an empty vec if the flag was not passed.
pub fn json_output_flag(json_output: &Option<Option<PathBuf>>) -> Vec<String> {
    match json_output {
        Some(None) => vec!["--json-output".to_string()],
        Some(Some(path)) => {
            vec![format!("--json-output={}", path.to_string_lossy())]
        }
        None => vec![],
    }
}