bashkit 0.20.1

Awesomely fast virtual sandbox with bash and file system
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

// Prompt reparses must share runtime limits; each parsed expression is shallow.
use bashkit::{Bash, Error, ExecutionBudgetExceeded, ExecutionLimits, LimitExceeded};

fn assert_depth(result: bashkit::Result<bashkit::ExecResult>, depth: usize) {
    assert!(
        matches!(result, Err(Error::ResourceLimit(LimitExceeded::MaxPromptDepth(d))) if d == depth),
        "expected prompt depth {depth}, got {result:?}"
    );
}

fn prompt_chain(depth: usize, limits: ExecutionLimits) -> Bash {
    let mut bash = Bash::builder().limits(limits).build();
    bash.set_env("p0", "done");
    for i in 1..depth {
        bash.set_env(&format!("p{i}"), &format!("${{p{}@P}}", i - 1));
    }
    bash
}

#[tokio::test]
async fn finite_prompt_chain_respects_depth_limit() {
    // Finite six-level chain: safe to execute against the unfixed interpreter.
    let mut bash = prompt_chain(6, ExecutionLimits::new().max_ast_depth(5));
    let result = bash.exec("echo \"${p5@P}\"").await;
    assert_depth(result, 5);
}

#[tokio::test]
async fn prompt_cycles_stop_and_session_recovers() {
    // Run cycles only with the guard installed; depth tests above are finite.
    for script in [
        r#"x='${x@P}'; echo "${x@P}""#,
        r#"x='${y@P}'; y='${x@P}'; echo "${x@P}""#,
        r#"x='$(echo "${x@P}")'; echo "${x@P}""#,
        r#"x='$(echo "${x@P}" | cat)'; echo "${x@P}""#,
    ] {
        let mut bash = Bash::new();
        assert_depth(bash.exec(script).await, 8);
        assert_eq!(
            bash.exec(r#"x=ok; echo "${x@P}""#).await.unwrap().stdout,
            "ok\n"
        );
    }
}

#[tokio::test]
async fn background_prompt_cycle_is_contained() {
    let mut bash = Bash::new();
    let result = bash
        .exec(r#"x='${x@P}'; echo "${x@P}" & wait"#)
        .await
        .unwrap();
    assert!(
        result
            .stderr
            .contains("maximum prompt expansion depth exceeded (8)")
    );
    assert_eq!(
        bash.exec("echo recovered").await.unwrap().stdout,
        "recovered\n"
    );
}

#[tokio::test]
async fn prompt_depth_boundary_and_siblings() {
    let mut bash = prompt_chain(8, ExecutionLimits::new());
    let result = bash.exec(r#"echo "${p7@P}|${p7@P}""#).await.unwrap();
    assert_eq!(result.stdout, "done|done\n");
    bash.set_env("p8", "${p7@P}");
    assert_depth(bash.exec(r#"echo "${p8@P}""#).await, 8);
    // Raising AST depth cannot remove the native-stack ceiling.
    let mut bash = prompt_chain(9, ExecutionLimits::new().max_ast_depth(usize::MAX));
    assert_depth(bash.exec(r#"echo "${p8@P}""#).await, 8);
}

#[tokio::test]
async fn promptvars_disabled_keeps_cycle_literal() {
    let mut bash = Bash::new();
    let result = bash
        .exec(r#"shopt -u promptvars; x='${x@P}'; echo "${x@P}""#)
        .await
        .unwrap();
    assert_eq!(result.stdout, "${x@P}\n");
}

#[tokio::test]
async fn prompt_reparses_share_work_budget() {
    let mut bash = prompt_chain(6, ExecutionLimits::new().max_work_units(20));
    let result = bash.exec(r#"echo "${p5@P}""#).await;
    assert!(
        matches!(
            result,
            Err(Error::ResourceLimit(LimitExceeded::ExecutionBudget(
                ExecutionBudgetExceeded::WorkUnits { .. }
            )))
        ),
        "expected shared work budget: {result:?}"
    );
}

#[tokio::test]
async fn prompt_siblings_share_input_budget() {
    let mut bash = Bash::builder()
        .limits(ExecutionLimits::new().max_aggregate_input_bytes(80))
        .env("x", "a".repeat(40))
        .build();
    let result = bash.exec(r#"echo "${x@P}${x@P}""#).await;
    assert!(
        matches!(
            result,
            Err(Error::ResourceLimit(LimitExceeded::ExecutionBudget(
                ExecutionBudgetExceeded::InputBytes { .. }
            )))
        ),
        "expected shared input budget: {result:?}"
    );
}