agent-first-http 0.12.0

Give your AI agent its own private browser — so it reads the real page, past logins and bot walls, without ever touching yours.
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

#![cfg(feature = "cli")]
#![allow(
    clippy::unwrap_used,
    clippy::expect_used,
    clippy::panic,
    clippy::disallowed_methods,
    clippy::disallowed_macros
)]

use std::{fs, process::Command};

#[test]
fn stdout_file_redirects_version_output() {
    let tempdir = tempfile::tempdir().expect("tempdir");
    let stdout_file = tempdir.path().join("afhttp.stdout");
    let stderr_file = tempdir.path().join("afhttp.stderr");

    let output = Command::new(env!("CARGO_BIN_EXE_afhttp"))
        .arg("--stdout-file")
        .arg(&stdout_file)
        .arg("--stderr-file")
        .arg(&stderr_file)
        .arg("--version")
        .output()
        .expect("run afhttp --version");

    assert!(output.status.success(), "status = {}", output.status);
    assert!(output.stdout.is_empty(), "stdout was not redirected");
    assert!(output.stderr.is_empty(), "stderr = {:?}", output.stderr);

    let redirected_stdout = fs::read_to_string(&stdout_file).expect("read stdout file");
    // Bare `--version` is a protocol-v1 event by default now, not conventional
    // `<name> <version>` text.
    let parsed: serde_json::Value =
        serde_json::from_str(redirected_stdout.trim()).expect("version output must be JSON");
    assert_eq!(parsed["kind"], "result");
    assert_eq!(parsed["result"]["code"], "version");
    assert_eq!(parsed["result"]["name"], "afhttp");
    assert_eq!(parsed["result"]["version"], env!("CARGO_PKG_VERSION"));
    assert_eq!(
        fs::read_to_string(&stderr_file).expect("read stderr file"),
        ""
    );
}

#[test]
fn stderr_file_redirects_a_command_failure_in_split_mode() {
    let tempdir = tempfile::tempdir().expect("tempdir");
    let stdout_file = tempdir.path().join("afhttp.stdout");
    let stderr_file = tempdir.path().join("afhttp.stderr");

    let output = Command::new(env!("CARGO_BIN_EXE_afhttp"))
        .arg("fetch")
        .arg("http://127.0.0.1:1/will-fail")
        .arg("--render")
        .arg("none")
        .arg("--timeout-ms")
        .arg("1000")
        .arg("--out")
        .arg(tempdir.path())
        .arg("--stdout-file")
        .arg(&stdout_file)
        .arg("--stderr-file")
        .arg(&stderr_file)
        .output()
        .expect("run afhttp fetch");

    assert!(!output.status.success(), "status = {}", output.status);
    assert!(output.stdout.is_empty(), "stdout = {:?}", output.stdout);
    assert!(output.stderr.is_empty(), "stderr = {:?}", output.stderr);

    assert_eq!(
        fs::read_to_string(&stdout_file).expect("read stdout file"),
        ""
    );
    let redirected_stderr = fs::read_to_string(&stderr_file).expect("read stderr file");
    assert!(
        redirected_stderr.contains("\"kind\":\"error\""),
        "stderr file = {redirected_stderr}"
    );
}

/// An argv the registry rejects has no output plan, and therefore no file
/// sinks: the rejection is reported on the process's own diagnostic stream and
/// the named files are never touched.
#[test]
fn a_rejected_argv_reports_before_any_file_sink_exists() {
    let tempdir = tempfile::tempdir().expect("tempdir");
    let stdout_file = tempdir.path().join("afhttp.stdout");
    let stderr_file = tempdir.path().join("afhttp.stderr");

    let output = Command::new(env!("CARGO_BIN_EXE_afhttp"))
        .arg("--stdout-file")
        .arg(&stdout_file)
        .arg("--stderr-file")
        .arg(&stderr_file)
        .arg("--not-a-real-afhttp-flag")
        .output()
        .expect("run afhttp invalid args");

    assert!(!output.status.success(), "status = {}", output.status);
    assert!(output.stdout.is_empty(), "stdout = {:?}", output.stdout);
    let stderr = String::from_utf8_lossy(&output.stderr);
    let parsed: serde_json::Value =
        serde_json::from_str(stderr.trim()).expect("rejection must be JSON on stderr");
    assert_eq!(parsed["error"]["code"], "cli_unknown_argument");
    assert!(
        parsed["error"]["message"]
            .as_str()
            .is_some_and(|message| message.contains("--not-a-real-afhttp-flag")),
        "{parsed}"
    );
    assert!(!stdout_file.exists(), "stdout sink was created anyway");
    assert!(!stderr_file.exists(), "stderr sink was created anyway");
}