openmoat 0.10.0

Policy checks for AI coding agents: decides allow, defer, ask or deny for every tool call from Claude Code, Codex, Cursor, OpenClaw, GitHub Copilot CLI, pi and Gemini CLI, configures Claude Code's, Codex's and Cursor's own OS sandboxes from the same policy, and keeps a local audit log.
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

use serde_json::json;

use super::parse;

#[test]
fn plain_json_reads_as_serde_json_does() {
    let text = r#"{"a": [1, -2, 3.5, 1e3, true, null], "b": {"c": "dé\n"}}"#;
    let parsed = parse(text).unwrap();
    assert_eq!(
        parsed.value,
        serde_json::from_str::<serde_json::Value>(text).unwrap()
    );
    assert!(!parsed.comments);
}

#[test]
fn json5_syntax_reads_as_its_json_value() {
    let text = "\u{feff}// OpenClaw\n{\n  gateway: { port: 18789, },\n  /* plugins */\n  \
                plugins: { allow: ['a', \"b\",], $x_1: .5, y: 5., z: +1, h: 0xFF, n: -0x10 },\n  \
                'quoted key': 'it\\'s \\x41\\u00e9 \\\n done',\n}\n";
    let parsed = parse(text).unwrap();
    assert!(parsed.comments);
    assert_eq!(
        parsed.value,
        json!({
            "gateway": {"port": 18789},
            "plugins": {"allow": ["a", "b"], "$x_1": 0.5, "y": 5.0, "z": 1, "h": 255, "n": -16},
            "quoted key": "it's A\u{e9}  done",
        })
    );
}

#[test]
fn comment_marks_inside_strings_are_text() {
    let parsed = parse(r#"{"url": "https://x/*y*/", 'p': '//not'}"#).unwrap();
    assert!(!parsed.comments);
    assert_eq!(parsed.value["url"], "https://x/*y*/");
}

#[test]
fn the_last_of_duplicate_keys_wins() {
    assert_eq!(parse("{a: 1, a: 2}").unwrap().value, json!({"a": 2}));
}

#[test]
fn escapes_in_keys_and_surrogate_pairs() {
    let parsed = parse(r#"{ab: "😀"}"#).unwrap();
    assert_eq!(parsed.value, json!({"ab": "\u{1F600}"}));
    assert!(parse(r#"{"x": "\uD83D"}"#).is_err());
}

#[test]
fn what_json_cannot_hold_or_json5_does_not_allow_is_refused() {
    for text in [
        "{a: Infinity}",
        "{a: -Infinity}",
        "{a: NaN}",
        "{a: 01}",
        "{a: 1,,}",
        "{,}",
        "[1 2]",
        "{a 1}",
        "{a: undefined}",
        "{a: 'x\ny'}",
        "{a: '\\1'}",
        "{a: 1} x",
        "/* open",
        "{a: 0x}",
        "{a: 1e}",
        "{a: .}",
        "{a: 12abc}",
        "",
    ] {
        assert!(parse(text).is_err(), "{text:?} should be refused");
    }
}

#[test]
fn deep_nesting_is_refused_not_recursed() {
    let deep = "[".repeat(10_000);
    assert!(parse(&deep).is_err());
    let fine = format!("{}{}", "[".repeat(100), "]".repeat(100));
    assert!(parse(&fine).is_ok());
}

#[test]
fn errors_name_the_line() {
    let error = parse("{\n  a: 1,\n  b: ?\n}").unwrap_err().to_string();
    assert!(error.contains("line 3"), "{error}");
}