vetto 0.2.21

Daemon-less sandbox + security layer for AI coding agents (Landlock/Seatbelt, TUI statusline, post-session audit reports)
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

//! Integration tests for the policy tooling subcommands: `policy explain`,
//! `policy lint`, and the `--limits` CLI spec merge. Every test drives the
//! compiled vetto binary as a child process.

use crate::common::*;

#[test]
fn explain_prints_tier_and_roots() {
    if !have_landlock() {
        eprintln!("SKIP: no tier");
        return;
    }
    let proj = TempProject::new("explain-text");
    let out = run_vetto_in(proj.path(), &["policy", "explain"]);
    assert!(
        out.status.success(),
        "explain must succeed; stderr: {}",
        stderr(&out)
    );
    let text = stdout(&out);
    assert!(text.contains("tier"), "tier section missing: {text}");
    assert!(
        text.contains("write roots"),
        "write roots section missing: {text}"
    );
}

#[test]
fn explain_json_parses() {
    if !have_landlock() {
        eprintln!("SKIP: no tier");
        return;
    }
    let proj = TempProject::new("explain-json");
    let out = run_vetto_in(proj.path(), &["policy", "explain", "--json"]);
    assert!(
        out.status.success(),
        "explain --json must succeed; stderr: {}",
        stderr(&out)
    );
    let value: serde_json::Value =
        serde_json::from_str(&stdout(&out)).expect("explain --json emits valid JSON");
    assert!(
        value.get("tier").is_some(),
        "JSON must carry the tier: {value}"
    );
    assert!(
        value.get("profile").is_some(),
        "JSON must carry the profile: {value}"
    );
}

#[test]
fn lint_is_clean_or_warns_on_default() {
    if !have_landlock() {
        eprintln!("SKIP: no tier");
        return;
    }
    // Credential material exists in the isolated test HOME, so the default
    // profile resolves its deny paths and lint must not fail (non-strict).
    ensure_fake_ssh_key();
    let proj = TempProject::new("lint-default");
    let out = run_vetto_in(proj.path(), &["policy", "lint"]);
    assert!(
        out.status.success(),
        "non-strict lint must always exit 0; exit={:?} stderr: {}",
        out.status.code(),
        stderr(&out)
    );
}

#[test]
fn lint_strict_fails_on_home_write_root() {
    if !have_landlock() {
        eprintln!("SKIP: no tier");
        return;
    }
    let proj = TempProject::new("lint-home-write");
    // A CLI policy layer that makes the isolated test HOME a write root.
    // The loader treats --policy paths as extra TOML layers after the
    // profile, with the same [filesystem].allow_write schema.
    let home = test_home().display().to_string();
    let layer = proj.path().join("home-write-root.toml");
    write_file(
        &layer,
        &format!(
            r#"
[metadata]
name = "lint-home-write"

[filesystem]
allow_write = ["{home}"]
"#
        ),
    );
    let out = run_vetto_in(
        proj.path(),
        &[
            "--policy",
            layer.to_str().expect("utf8 layer path"),
            "policy",
            "lint",
            "--strict",
        ],
    );
    assert_eq!(
        out.status.code(),
        Some(1),
        "strict lint must exit 1 on a $HOME write root; stderr: {}",
        stderr(&out)
    );
    let text = format!("{}{}", stdout(&out), stderr(&out));
    assert!(text.contains("home"), "output must mention home: {text}");
}

#[test]
fn limits_flag_applies_cleanly() {
    if !have_landlock() {
        eprintln!("SKIP: no tier");
        return;
    }
    let proj = TempProject::new("limits-flag");
    let out = run_vetto_in(
        proj.path(),
        &["--limits", "cpu=1", "--dry-run", "--", "true"],
    );
    assert!(
        out.status.success(),
        "--limits cpu=1 --dry-run must succeed; stderr: {}",
        stderr(&out)
    );
}