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
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

//! Signal handlers share the function/source depth ceiling (TM-DOS-020).
//! Small command budgets keep pre-fix recursion probes safe.

use bashkit::{Bash, ExecutionLimits};

#[tokio::test]
async fn recursive_signal_traps_share_function_depth() {
    for script in [
        "trap 'kill -USR1 $$' USR1; kill -USR1 $$",
        "trap 'kill -USR2 $$' USR1; trap 'kill -USR1 $$' USR2; kill -USR1 $$",
        "f() { kill -USR1 $$; }; trap 'f' USR1; kill -USR1 $$",
        "echo 'kill -USR1 $$' > /handler; trap 'source /handler' USR1; kill -USR1 $$",
    ] {
        for depth in [2, 3] {
            let mut bash = Bash::builder()
                .limits(
                    ExecutionLimits::new()
                        .max_function_depth(depth)
                        .max_commands(12),
                )
                .build();
            let err = bash.exec(script).await.unwrap_err().to_string();
            assert!(err.contains("depth exceeded"), "{script}: {err}");
            assert!(!err.contains("command limit"), "{script}: {err}");
            let next = bash.exec("echo recovered").await.unwrap();
            assert_eq!(next.stdout, "recovered\n");
            assert_eq!(next.exit_code, 0);
        }
    }
}

#[tokio::test]
async fn signal_depth_is_released_after_each_handler() {
    let mut bash = Bash::builder()
        .limits(ExecutionLimits::new().max_function_depth(2))
        .build();
    let result = bash.exec("trap 'echo first; kill -USR2 $$; echo last' USR1; trap 'echo second' USR2; kill -USR1 $$; kill -USR1 $$; echo done").await.unwrap();
    assert_eq!(result.exit_code, 0);
    assert_eq!(
        result.stdout,
        "first\nsecond\nlast\nfirst\nsecond\nlast\ndone\n"
    );
    assert!(result.stderr.is_empty(), "{}", result.stderr);
}

#[tokio::test]
async fn ignored_signal_needs_no_handler_depth() {
    let mut bash = Bash::builder()
        .limits(ExecutionLimits::new().max_function_depth(0))
        .build();
    let result = bash
        .exec("trap '' USR1; kill -USR1 $$; echo ignored")
        .await
        .unwrap();
    assert_eq!(result.exit_code, 0);
    assert_eq!(result.stdout, "ignored\n");
}

#[tokio::test]
async fn signal_handler_command_limit_reaches_host() {
    let mut bash = Bash::builder()
        .limits(ExecutionLimits::new().max_commands(3))
        .build();
    let err = bash
        .exec("trap 'echo first; echo second' USR1; kill -USR1 $$")
        .await
        .unwrap_err()
        .to_string();
    assert!(err.contains("maximum command count exceeded"), "{err}");
}

#[tokio::test]
async fn signal_handler_parse_error_is_swallowed() {
    // TM-DOS-030 (merged main semantics): an unparsable handler never
    // disturbs the interrupted command; the kill completes and the shell
    // stays usable.
    let mut bash = Bash::builder().build();
    let result = bash
        .exec("trap 'if' USR1; kill -USR1 $$; echo done")
        .await
        .unwrap();
    assert_eq!(result.stdout, "done\n");
    assert_eq!(result.exit_code, 0);
    let next = bash.exec("echo recovered").await.unwrap();
    assert_eq!(next.stdout, "recovered\n");
}

#[tokio::test]
async fn finite_three_level_nesting_succeeds_with_recovery() {
    // Terminates by construction (acyclic signal chain USR1 -> USR2 -> USR3):
    // three nested handler entries are admitted, with exact output.
    let mut bash = Bash::builder().build();
    let result = bash
        .exec("trap 'echo one; kill -USR2 $$' USR1; trap 'echo two; kill -TERM $$' USR2; trap 'echo three' TERM; kill -USR1 $$; echo done")
        .await
        .unwrap();
    assert_eq!(result.stdout, "one\ntwo\nthree\ndone\n");
    assert_eq!(result.exit_code, 0);
    let next = bash.exec("echo recovered").await.unwrap();
    assert_eq!(next.stdout, "recovered\n");
}

#[tokio::test]
async fn shared_depth_zero_admits_no_handlers() {
    // Bounded by construction: the first trap entry already exceeds a zero
    // budget, so no handler body runs and the trip surfaces.
    let mut bash = Bash::builder()
        .limits(ExecutionLimits::new().max_function_depth(0))
        .build();
    let err = bash
        .exec("trap 'echo ENTRY >> /log; kill -USR1 $$' USR1; kill -USR1 $$")
        .await
        .unwrap_err()
        .to_string();
    assert!(err.contains("depth exceeded"), "{err}");
    let log = bash
        .exec("cat /log 2>/dev/null || echo none")
        .await
        .unwrap();
    assert!(
        log.stdout.contains("none"),
        "no handler may run: {}",
        log.stdout
    );
}

#[tokio::test]
async fn shared_depth_one_admits_exactly_one_handler() {
    // Bounded by construction: each cycle consumes depth; the second entry
    // trips, so exactly one handler body runs.
    let mut bash = Bash::builder()
        .limits(ExecutionLimits::new().max_function_depth(1))
        .build();
    let err = bash
        .exec("trap 'echo ENTRY >> /log; kill -USR1 $$' USR1; kill -USR1 $$")
        .await
        .unwrap_err()
        .to_string();
    assert!(err.contains("depth exceeded"), "{err}");
    let log = bash.exec("cat /log").await.unwrap();
    assert_eq!(log.stdout.lines().count(), 1, "{}", log.stdout);
}