xbp 0.9.1

XBP is a zero-config build pack that can also interact with proxies, kafka, sockets, synthetic monitors.
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

use std::time::Instant;
use tokio::process::Command;
use tracing::{debug, info, warn};

/// Clean and canonicalize the URL:
/// - If it starts with "https://https://", deduplicate
/// - If it starts with just "domain.tld" (likely no protocol), add "https://"
/// - If it starts with "http://", keep as-is
fn canonicalize_url(raw: &str) -> String {
    let raw = raw.trim();
    if raw.starts_with("https://https://") {
        // Deduplicate
        let dedup = &raw["https://".len()..];
        format!("https://{}", dedup)
    } else if raw.starts_with("https://") || raw.starts_with("http://") {
        raw.to_string()
    } else {
        // If there's a protocol (ftp://, etc), don't mangle, but for this context, only check http/https
        format!("https://{}", raw)
    }
}

/// Run a curl command to fetch https://example.com/api and pretty-print with jq,
/// displaying HTTP status, headers, response time, and output in colored ANSI.
pub async fn run_curl(raw_url: &str, debug: bool) -> Result<(), String> {
    let url = canonicalize_url(raw_url);

    // Use curl to fetch headers and body
    let mut curl_cmd = Command::new("curl");
    curl_cmd
        .arg("-sS") // silent but show errors
        .arg("-D")
        .arg("-") // dump headers to stdout (before body)
        .arg("-w")
        .arg("%{http_code}") // output the status code at end (after body)
        .arg(&url);

    if debug {
        debug!("running curl command for '{}'", url);
    }

    let start = Instant::now();
    let output = curl_cmd
        .output()
        .await
        .map_err(|e| format!("failed to run curl: {}", e))?;
    let duration = start.elapsed();

    if !output.status.success() {
        return Err(format!(
            "\x1b[91mCurl failed with status: {}\nStderr: {}\x1b[0m",
            output.status,
            String::from_utf8_lossy(&output.stderr)
        ));
    }

    // Split headers, body, and grab status code at end
    let all_output = output.stdout;
    let all_str = String::from_utf8_lossy(&all_output);
    let mut lines = all_str.lines();

    // Read headers
    let mut headers = Vec::new();
    let mut body = String::new();
    let mut in_headers = true;
    for line in lines.by_ref() {
        if in_headers && line.trim() == "" {
            // End of headers
            in_headers = false;
            continue;
        }
        if in_headers {
            headers.push(line.to_string());
        } else {
            // Accumulate body
            body.push_str(line);
            body.push('\n');
        }
    }

    // Sometimes curl prints the status code after the body (due to -w)
    let mut status_code = None;
    if !body.is_empty() && body.trim().chars().all(|c| c.is_ascii_digit()) {
        status_code = Some(body.trim().to_string());
        body.clear();
    } else if let Some(code_line) = lines.last() {
        if code_line.chars().all(|c| c.is_ascii_digit()) {
            status_code = Some(code_line.to_string());
        }
    }

    info!("=== Curl to {}", url);
    info!("--- Response Headers ---");
    for h in &headers {
        info!("{}", h);
    }
    if let Some(status) = &status_code {
        info!("--- Status --- {}", status);
    }

    info!("--- Response Time --- {:.2?}", duration);

    let mut jq_cmd = Command::new("jq");
    jq_cmd.arg("-C").arg(".");
    if debug {
        debug!("piping response body to jq for colored pretty-print");
    }
    let mut jq_child = jq_cmd
        .stdin(std::process::Stdio::piped())
        .stdout(std::process::Stdio::piped())
        .spawn()
        .map_err(|e| format!("failed to spawn jq: {}", e))?;

    if let Some(mut stdin) = jq_child.stdin.take() {
        use tokio::io::AsyncWriteExt;
        stdin
            .write_all(body.as_bytes())
            .await
            .map_err(|e| format!("failed to write to jq stdin: {}", e))?;
    }

    let jq_output = jq_child
        .wait_with_output()
        .await
        .map_err(|e| format!("failed to collect jq output: {}", e))?;

    info!("--- Body (pretty JSON) ---");
    info!("{}", String::from_utf8_lossy(&jq_output.stdout));

    if !jq_output.status.success() {
        warn!("jq encountered an error (body may not be JSON)");
        if !body.trim().is_empty() {
            info!("--- Raw Body ---");
            info!("{}", body);
        }
    }

    Ok(())
}