impyard 0.1.1

Rent the intelligence, own the governance — a control plane for imps: software colleagues whose every action passes through a gateway you control (default-deny egress, injected credentials, budgets, approval gates, audit).
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

//! The policy schema (mirrors `src/schema.ts`) plus the runtime GovernedRequest
//! the judge evaluates and the call log records. See docs/rust-port.md (P2).

use serde::Deserialize;
use std::collections::HashMap;

/// A JSON field that may be a single value or an array of them.
#[derive(Debug, Clone, Deserialize)]
#[serde(untagged)]
pub enum OneOrMany<T> {
    One(T),
    Many(Vec<T>),
}

impl<T> OneOrMany<T> {
    pub fn values(&self) -> Vec<&T> {
        match self {
            OneOrMany::One(v) => vec![v],
            OneOrMany::Many(vs) => vs.iter().collect(),
        }
    }
}

#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum Verdict {
    Allow,
    Deny,
    Tunnel,
}

impl Verdict {
    pub fn as_str(&self) -> &'static str {
        match self {
            Verdict::Allow => "allow",
            Verdict::Deny => "deny",
            Verdict::Tunnel => "tunnel",
        }
    }
}

#[derive(Debug, Clone, Default, Deserialize)]
pub struct Match {
    pub protocol: Option<OneOrMany<String>>,
    pub host: Option<OneOrMany<String>>,
    pub port: Option<OneOrMany<u16>>,
    pub method: Option<OneOrMany<String>>,
    #[serde(rename = "pathPrefix")]
    pub path_prefix: Option<String>,
    #[serde(rename = "headerContains")]
    pub header_contains: Option<HashMap<String, String>>,
    #[serde(rename = "maxBodySize")]
    pub max_body_size: Option<u64>,
    pub mcp: Option<McpMatch>,
}

#[derive(Debug, Clone, Deserialize)]
pub struct McpMatch {
    pub method: Option<OneOrMany<String>>,
    pub tool: Option<OneOrMany<String>>,
}

#[derive(Debug, Clone, Deserialize)]
pub struct Inject {
    pub credential: String,
}

#[derive(Debug, Clone, Deserialize)]
pub struct Rule {
    pub name: String,
    #[serde(default)]
    pub r#match: Match,
    pub verdict: Verdict,
    #[serde(default)]
    pub inject: Option<Inject>,
    /// The scope this rule governs (ancestor of the subject). Defaults to "org"
    /// (fleet-wide) for hand-authored/legacy rules.
    #[serde(default = "org_scope")]
    pub scope: String,
}

fn org_scope() -> String {
    "org".to_string()
}

#[derive(Debug, Clone, Default, Deserialize)]
pub struct Policy {
    pub rules: Vec<Rule>,
}

impl Policy {
    pub fn empty() -> Policy {
        Policy { rules: Vec::new() }
    }
    pub fn rule(&self, name: &str) -> Option<&Rule> {
        self.rules.iter().find(|r| r.name == name)
    }
}

/// Lifted MCP terms from a JSON-RPC body.
#[derive(Debug, Clone)]
pub struct Mcp {
    pub method: String,
    pub tool: Option<String>,
}

/// What the gateway saw, phrased as the judge's question.
#[derive(Debug, Clone)]
pub struct GovernedRequest {
    pub imp: Option<String>,
    pub protocol: String,
    pub method: String,
    pub host: String,
    pub port: u16,
    pub path: String,
    pub query: String,
    pub headers: HashMap<String, String>,
    pub body_size: u64,
    pub mcp: Option<Mcp>,
}