Skip to main content

rigspark_runtime/
tool_policy.rs

1use serde::Serialize;
2use serde_json::Value;
3use std::collections::HashSet;
4
5#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
6#[serde(rename_all = "kebab-case")]
7pub enum ToolRisk {
8    ReadOnly,
9    ProcessNetwork,
10    WorkspaceMutation,
11    Unknown,
12}
13
14pub fn classify(name: &str, description: &str) -> ToolRisk {
15    let mut expanded = String::new();
16    let mut lower = false;
17    for character in format!("{name} {description}").chars() {
18        if lower && character.is_ascii_uppercase() {
19            expanded.push(' ');
20        }
21        lower = character.is_ascii_lowercase();
22        expanded.push(character.to_ascii_lowercase());
23    }
24    let tokens: HashSet<_> = expanded
25        .split(|character: char| !character.is_ascii_alphanumeric())
26        .collect();
27    for (risk, words) in [
28        (
29            ToolRisk::WorkspaceMutation,
30            "write create delete remove edit apply patch move rename mkdir rmdir chmod put update insert drop",
31        ),
32        (
33            ToolRisk::ProcessNetwork,
34            "exec execute run shell command spawn fetch http https request curl wget download upload network socket ssh",
35        ),
36        (
37            ToolRisk::ReadOnly,
38            "read get list search find show view cat status diff log query describe inspect lookup",
39        ),
40    ] {
41        if words.split(' ').any(|word| tokens.contains(word)) {
42            return risk;
43        }
44    }
45    ToolRisk::Unknown
46}
47pub fn redact_arguments(value: &Value) -> Value {
48    fn redact(value: &Value, depth: usize) -> Value {
49        if depth > 4 {
50            return Value::String("[...]".into());
51        }
52        match value {
53            Value::String(text) if text.encode_utf16().count() > 256 => Value::String(format!(
54                "{}... [{} chars]",
55                text.chars().take(64).collect::<String>(),
56                text.encode_utf16().count()
57            )),
58            Value::Array(values) => Value::Array(
59                values
60                    .iter()
61                    .take(20)
62                    .map(|value| redact(value, depth + 1))
63                    .collect(),
64            ),
65            Value::Object(values) => Value::Object(
66                values
67                    .iter()
68                    .take(128)
69                    .map(|(key, value)| {
70                        let lower = key.to_lowercase();
71                        let secret = [
72                            "token",
73                            "secret",
74                            "key",
75                            "password",
76                            "passwd",
77                            "pwd",
78                            "auth",
79                            "credential",
80                            "cookie",
81                            "session",
82                            "bearer",
83                        ]
84                        .iter()
85                        .any(|word| lower.contains(word));
86                        (
87                            key.clone(),
88                            if secret {
89                                Value::String("[redacted]".into())
90                            } else {
91                                redact(value, depth + 1)
92                            },
93                        )
94                    })
95                    .collect(),
96            ),
97            _ => value.clone(),
98        }
99    }
100    redact(value, 0)
101}
102pub(crate) fn serialize_arguments<Serializer: serde::Serializer>(
103    value: &Value,
104    serializer: Serializer,
105) -> Result<Serializer::Ok, Serializer::Error> {
106    redact_arguments(value).serialize(serializer)
107}
108#[derive(Debug, Serialize)]
109pub struct ResultPreview {
110    pub text: String,
111    pub truncated: bool,
112}
113pub fn redact_result(text: &str) -> ResultPreview {
114    let mut masked = String::new();
115    for part in text.split_inclusive(|character: char| {
116        !character.is_ascii_alphanumeric() && !['_', '-'].contains(&character)
117    }) {
118        let token = part.trim_end_matches(|character: char| {
119            !character.is_ascii_alphanumeric() && !['_', '-'].contains(&character)
120        });
121        if token.len() >= 24
122            && token.bytes().any(|byte| byte.is_ascii_alphabetic())
123            && token.bytes().any(|byte| byte.is_ascii_digit())
124        {
125            masked.push_str("[redacted]");
126            masked.push_str(&part[token.len()..]);
127        } else {
128            masked.push_str(part);
129        }
130        if masked.encode_utf16().count() > 2048 {
131            return ResultPreview {
132                text: format!("{}...", crate::sessions::cap(&masked, 2048)),
133                truncated: true,
134            };
135        }
136    }
137    ResultPreview {
138        text: masked,
139        truncated: false,
140    }
141}
142
143#[derive(Default)]
144pub struct SessionGrants {
145    session: String,
146    workspace: Option<String>,
147    grants: HashSet<String>,
148}
149impl SessionGrants {
150    pub fn select(&mut self, session: &str, workspace: Option<&str>) {
151        if self.session != session || self.workspace.as_deref() != workspace {
152            self.grants.clear();
153            self.session = session.into();
154            self.workspace = workspace.map(str::to_owned);
155        }
156    }
157    pub fn clear(&mut self) {
158        self.grants.clear();
159    }
160    pub(crate) fn grant(&mut self, key: String) -> bool {
161        if self.session.is_empty() || self.grants.len() >= 1024 {
162            return false;
163        }
164        self.grants.insert(key);
165        true
166    }
167    pub(crate) fn allows(&self, key: &str) -> bool {
168        !self.session.is_empty() && self.grants.contains(key)
169    }
170}