rigspark_runtime/
tool_policy.rs1use 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}