agent-team-mail-core 0.17.0

Core library for agent-team-mail: file-based messaging for AI agent teams
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

//! Permissions schema for Claude Code settings

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Permissions configuration
///
/// Controls tool access and file reads in Claude Code settings.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Permissions {
    /// Allowed operations (e.g., "Bash(npm run lint)", "Read(~/.zshrc)")
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub allow: Vec<String>,

    /// Denied operations
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub deny: Vec<String>,

    /// Operations requiring user confirmation
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub ask: Vec<String>,

    /// Unknown fields for forward compatibility
    #[serde(flatten)]
    pub unknown_fields: HashMap<String, serde_json::Value>,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_permissions_roundtrip_minimal() {
        let json = r#"{}"#;

        let perms: Permissions = serde_json::from_str(json).unwrap();
        assert!(perms.allow.is_empty());
        assert!(perms.deny.is_empty());
        assert!(perms.ask.is_empty());

        let serialized = serde_json::to_string(&perms).unwrap();
        let reparsed: Permissions = serde_json::from_str(&serialized).unwrap();
        assert!(reparsed.allow.is_empty());
    }

    #[test]
    fn test_permissions_roundtrip_complete() {
        let json = r#"{
            "allow": ["Bash(npm run lint)", "Read(~/.zshrc)"],
            "deny": ["Bash(curl *)", "Read(./secrets/**)"],
            "ask": ["Bash(rm -rf *)"]
        }"#;

        let perms: Permissions = serde_json::from_str(json).unwrap();
        assert_eq!(perms.allow.len(), 2);
        assert_eq!(perms.allow[0], "Bash(npm run lint)");
        assert_eq!(perms.deny.len(), 2);
        assert_eq!(perms.deny[0], "Bash(curl *)");
        assert_eq!(perms.ask.len(), 1);
        assert_eq!(perms.ask[0], "Bash(rm -rf *)");

        let serialized = serde_json::to_string(&perms).unwrap();
        let reparsed: Permissions = serde_json::from_str(&serialized).unwrap();
        assert_eq!(perms.allow.len(), reparsed.allow.len());
        assert_eq!(perms.deny.len(), reparsed.deny.len());
        assert_eq!(perms.ask.len(), reparsed.ask.len());
    }

    #[test]
    fn test_permissions_roundtrip_with_unknown_fields() {
        let json = r#"{
            "allow": ["Bash(npm test)"],
            "unknownField": "value",
            "futureFeature": {"nested": "data"}
        }"#;

        let perms: Permissions = serde_json::from_str(json).unwrap();
        assert_eq!(perms.allow.len(), 1);
        assert_eq!(perms.unknown_fields.len(), 2);
        assert!(perms.unknown_fields.contains_key("unknownField"));
        assert!(perms.unknown_fields.contains_key("futureFeature"));

        let serialized = serde_json::to_string(&perms).unwrap();
        let reparsed: Permissions = serde_json::from_str(&serialized).unwrap();
        assert_eq!(perms.unknown_fields.len(), reparsed.unknown_fields.len());
        assert_eq!(
            perms.unknown_fields.get("unknownField"),
            reparsed.unknown_fields.get("unknownField")
        );
    }

    #[test]
    fn test_permissions_missing_optional_fields() {
        let json = r#"{"allow": ["Bash(test)"]}"#;

        let perms: Permissions = serde_json::from_str(json).unwrap();
        assert_eq!(perms.allow.len(), 1);
        assert!(perms.deny.is_empty());
        assert!(perms.ask.is_empty());
    }
}