1use crate::*;
2use rmcp::{
3 ErrorData, RoleServer, ServerHandler,
4 model::{
5 CacheScope, CallToolRequestParams, CallToolResponse, CallToolResult, ContentBlock,
6 ListToolsResult, PaginatedRequestParams, ServerCapabilities, ServerConfig, Tool,
7 },
8 service::RequestContext,
9};
10
11pub async fn resources(owner: &Value) -> Result<Vec<Value>> {
12 let domains = host::call(json!({"operation":"vm.computers"})).await?;
13 Ok(array(&domains)
14 .iter()
15 .filter(|vm| {
16 vm["owner"] == owner["id"] && array(&vm["capabilities"]).iter().any(|c| c == "computer")
17 })
18 .map(|vm| json!({"id":vm["name"],"name":vm["name"],"platform":vm["platform"],"os":vm["os"],"arch":vm["arch"],"state":vm["state"],"aiOwned":vm["aiOwned"] == true,"expiresAt":vm["expiresAt"]}))
19 .collect())
20}
21
22fn permitted(grant: &Value, vm: &str, scope: &str, owner: &Value) -> Result<()> {
23 if !array(&grant["scopes"]).iter().any(|s| s == scope)
24 || !array(&grant["resources"]).iter().any(|id| id == vm)
25 || owner["owner"].as_str().is_none()
26 || owner["owner"] != grant["user"]
27 {
28 return Err(Error::new(
29 403,
30 "This VM is outside the connection's access. Update access in MCP settings.",
31 ));
32 }
33 Ok(())
34}
35
36struct Transfer {
37 headers: HeaderMap,
38 vm: String,
39 path: String,
40 size: u64,
41 upload: bool,
42 overwrite: bool,
43 expires: std::time::Instant,
44}
45
46struct UploadCleanup {
47 vm: String,
48 path: Option<String>,
49}
50
51impl Drop for UploadCleanup {
52 fn drop(&mut self) {
53 if let Some(path) = self.path.take() {
54 let vm = self.vm.clone();
55 tokio::spawn(async move {
56 let deadline = tokio::time::Instant::now() + Duration::from_secs(240);
57 loop {
58 match dispatch(&vm, json!({"action":"file","operation":"remove","path":path})).await {
59 Err(error) if error.status == 409 && tokio::time::Instant::now() < deadline => {
60 tokio::time::sleep(Duration::from_secs(1)).await;
61 }
62 _ => break,
63 }
64 }
65 });
66 }
67 }
68}
69
70#[derive(Clone)]
71struct Computer {
72 app: Arc<App>,
73 transfers: Arc<Mutex<HashMap<String, Transfer>>>,
74 transfer_slots: Arc<Semaphore>,
75}
76
77fn scope(action: &str, arguments: &serde_json::Map<String, Value>) -> &'static str {
78 if matches!(action, "status" | "shot" | "ui")
79 || (action == "process"
80 && arguments.get("operation").and_then(Value::as_str) == Some("status"))
81 {
82 "computer:read"
83 } else {
84 "computer:control"
85 }
86}
87
88async fn dispatch(vm: &str, operation: Value) -> Result<Value> {
89 let value =
90 host::call(json!({"operation":"vm.computer","payload":{"name":vm,"request":operation}}))
91 .await?;
92 if let Some(error) = value["error"].as_str() {
93 return Err(Error::new(400, error));
94 }
95 Ok(value)
96}
97
98impl ServerHandler for Computer {
99 fn get_info(&self) -> ServerConfig {
100 ServerConfig::new(ServerCapabilities::builder().enable_tools().build())
101 }
102 async fn list_tools(
103 &self,
104 _: Option<PaginatedRequestParams>,
105 _: RequestContext<RoleServer>,
106 ) -> std::result::Result<ListToolsResult, ErrorData> {
107 let tools: Vec<Tool> = serde_json::from_str(include_str!("computer-tools.json"))
108 .expect("computer tool schema");
109 Ok(ListToolsResult {
110 tools,
111 ttl_ms: Some(0),
112 cache_scope: Some(CacheScope::Private),
113 ..Default::default()
114 })
115 }
116 async fn call_tool(
117 &self,
118 request: CallToolRequestParams,
119 context: RequestContext<RoleServer>,
120 ) -> std::result::Result<CallToolResponse, ErrorData> {
121 let result: Result<Value> = async {
122 let parts = context.extensions.get::<axum::http::request::Parts>()
123 .ok_or_else(|| Error::new(401, "This connection expired. Connect again."))?;
124 let grant = &parts.extensions.get::<mcp::Grant>()
125 .ok_or_else(|| Error::new(401, "This connection expired. Connect again."))?.0;
126 let mut arguments = request.arguments.unwrap_or_default();
127 if matches!(request.name.as_ref(), "computer_presets" | "computer_create") {
128 if !array(&grant["scopes"]).iter().any(|scope| scope == "computer:create") {
129 return Err(Error::new(403, "Reconnect with permission to create test VMs."));
130 }
131 if request.name == "computer_presets" {
132 if !arguments.is_empty() { return Err(Error::new(400, "This tool takes no arguments.")); }
133 return host::call(json!({"operation":"vm.ai","payload":{"action":"presets","owner":grant["user"]}})).await;
134 }
135 if arguments.keys().any(|key| !["preset","name","vcpus","memory_gib"].contains(&key.as_str())) {
136 return Err(Error::new(400, "Use the fields listed for creating a test VM."));
137 }
138 let created = host::call(json!({"operation":"vm.ai","payload":{"action":"create","owner":grant["user"],
139 "preset":arguments.get("preset"),"name":arguments.get("name"),
140 "vcpus":arguments.get("vcpus").unwrap_or(&json!(2)),"memory":arguments.get("memory_gib").unwrap_or(&json!(4))}})).await?;
141 let mut db = self.app.mcp.db.lock().unwrap();
142 let tx = db.transaction()?;
143 let key = format!("grant:{}",string(&grant["id"]));
144 let mut current = mcp::get(&tx,&key)?;
145 if current["user"] != grant["user"] || !array(&current["scopes"]).iter().any(|scope| scope == "computer:create") {
146 return Err(Error::new(403, "The connection changed while the VM was starting. The test VM will expire automatically."));
147 }
148 let mut selected = array(&current["resources"]).to_vec();
149 selected.push(created["id"].clone());
150 current["resources"] = json!(selected);
151 mcp::put(&tx,&key,&current,0)?;
152 tx.commit()?;
153 return Ok(created);
154 }
155 if request.name == "computer_list" {
156 if !arguments.is_empty() { return Err(Error::new(400, "This tool takes no arguments.")); }
157 return Ok(json!({"computers":resources(&json!({"id":grant["user"]})).await?.into_iter()
158 .filter(|vm| array(&grant["resources"]).iter().any(|id| id == &vm["id"])).collect::<Vec<_>>()}));
159 }
160 let vm = arguments.remove("vm").and_then(|v| v.as_str().map(str::to_owned))
161 .filter(|s| !s.is_empty() && s.len() <= 63)
162 .ok_or_else(|| Error::new(400, "Choose a granted VM."))?;
163 if !array(&grant["resources"]).iter().any(|id| id == &vm) {
164 return Err(Error::new(403, "Choose a VM granted to this connection."));
165 }
166 let action = request.name.strip_prefix("computer_").ok_or_else(|| Error::new(404,"No tool with that name."))?;
167 let owner = host::call(json!({"operation":"vm.owner","payload":{"name":vm}})).await?;
168 permitted(grant, &vm, scope(action,&arguments), &owner)?;
169 if action == "vm" {
170 if arguments.keys().any(|key| !["operation","seconds"].contains(&key.as_str())) {
171 return Err(Error::new(400,"Use the fields listed for this VM operation."));
172 }
173 return match arguments.get("operation").and_then(Value::as_str) {
174 Some(operation @ ("extend" | "delete")) => host::call(json!({"operation":"vm.ai","payload":{
175 "action":operation,"name":vm,"owner":grant["user"],"seconds":arguments.get("seconds").unwrap_or(&json!(3600))}})).await,
176 Some(operation @ ("start" | "shutdown" | "reboot")) if !arguments.contains_key("seconds") => {
177 host::call(json!({"operation":"vm.act","payload":{"name":vm,"action":operation}})).await?;
178 Ok(json!({"id":vm,"requested":operation}))
179 },
180 _ => Err(Error::new(400,"Choose start, shutdown, reboot, extend, or delete.")),
181 };
182 }
183 if matches!(action,"upload"|"download") {
184 let path = arguments.remove("path").and_then(|v| v.as_str().map(str::to_owned))
185 .filter(|p| !p.is_empty() && p.len() <= 4096 && !p.contains('\0'))
186 .ok_or_else(|| Error::new(400,"Choose an absolute guest file path."))?;
187 let upload = action == "upload";
188 let overwrite = arguments.remove("overwrite").unwrap_or(json!(false));
189 if !overwrite.is_boolean() { return Err(Error::new(400,"Choose whether to replace the destination.")); }
190 let size = if upload {
191 arguments.remove("size").and_then(|v|v.as_u64()).ok_or_else(||Error::new(400,"Provide the upload size in bytes."))?
192 } else {
193 let info = dispatch(&vm,json!({"action":"file","operation":"stat","path":path})).await?;
194 if info["directory"] == true { return Err(Error::new(400,"Choose a file to download.")); }
195 info["size"].as_u64().ok_or_else(||Error::new(400,"The guest did not report a file size."))?
196 };
197 if size > 64*1024*1024 || !arguments.is_empty() { return Err(Error::new(400,"Transfer a file of at most 64 MiB using the listed fields.")); }
198 if upload {
199 let parent = path.rfind(['/', '\\']).filter(|index| index + 1 < path.len())
200 .map(|index| &path[..=index]).ok_or_else(|| Error::new(400,"Choose an absolute guest file path."))?;
201 let info = dispatch(&vm,json!({"action":"file","operation":"stat","path":parent})).await?;
202 if info["directory"] != true { return Err(Error::new(400,"Choose an existing destination folder.")); }
203 }
204 let now = std::time::Instant::now();
205 let mut transfers = self.transfers.lock().unwrap();
206 transfers.retain(|_,t|t.expires>now);
207 if transfers.len()>=128 { return Err(Error::new(429,"Too many pending transfers. Finish one or wait for it to expire.")); }
208 let id = format!("{}{}",uuid::Uuid::new_v4().simple(),uuid::Uuid::new_v4().simple());
209 let mut headers = HeaderMap::new();
210 if let Some(value) = parts.headers.get("authorization") { headers.insert("authorization",value.clone()); }
211 transfers.insert(id.clone(),Transfer{headers,vm,path,size,upload,overwrite:overwrite==true,expires:now+Duration::from_secs(600)});
212 return Ok(json!({"url":format!("{}mcp/computer/files/{id}",self.app.mcp.origin),"method":if upload {"PUT"} else {"GET"},"bytes":size,"expires_in":600}));
213 }
214 let fields: &[&str] = match action {
215 "status"|"shot" => &[], "ui" => &["pid"],
216 "input" => &["actions","screenshot"],
217 "ui_action" => &["target","operation","value","screenshot"],
218 "exec" => &["script","runtime","timeout_ms","screenshot"],
219 "spawn" => &["script","runtime"], "process" => &["id","operation"],
220 "file" => &["path","operation"],
221 _ => return Err(Error::new(404,"No tool with that name.")),
222 };
223 if arguments.keys().any(|k|!fields.contains(&k.as_str())) { return Err(Error::new(400,"Use the fields listed for this tool.")); }
224 if action == "file" && !matches!(arguments.get("operation").and_then(Value::as_str),Some("stat"|"list"|"mkdir"|"remove")) {
225 return Err(Error::new(400,"Choose stat, list, mkdir or remove."));
226 }
227 if action == "exec" { arguments.entry("timeout_ms").or_insert(json!(60000)); }
228 if matches!(action,"exec"|"input"|"ui_action") { arguments.entry("screenshot").or_insert(json!(true)); }
229 if matches!(action,"exec"|"spawn") { arguments.entry("runtime").or_insert(json!("default")); }
230 arguments.insert("action".into(),json!(action));
231 dispatch(&vm,Value::Object(arguments)).await
232
233 }.await;
234 Ok(match result {
235 Ok(mut value) => {
236 let png = value.as_object_mut().and_then(|v| v.remove("png"));
237 let mut content = vec![ContentBlock::text(value.to_string())];
238 if let Some(png) = png.and_then(|v| v.as_str().map(str::to_owned)) {
239 content.push(ContentBlock::image(png, "image/png"));
240 }
241 CallToolResult::success(content)
242 }
243 Err(error) => CallToolResult::error(vec![ContentBlock::text(error.message)]),
244 }
245 .into())
246 }
247}
248
249async fn transfer_access(computer: &Computer, transfer: &Transfer) -> Result<()> {
250 if transfer.expires <= std::time::Instant::now() {
251 return Err(Error::new(410, "This transfer expired. Request a new URL."));
252 }
253 let grant = computer
254 .app
255 .mcp
256 .authenticate(&transfer.headers, &computer.app.mcp.resource("computer"))?;
257 if !mcp::active_owner(&computer.app, &grant)? {
258 return Err(Error::new(401, "This connection expired. Connect again."));
259 }
260 let owner = host::call(json!({"operation":"vm.owner","payload":{"name":transfer.vm}})).await?;
261 permitted(&grant, &transfer.vm, "computer:control", &owner)
262}
263
264async fn transfer(
265 State(computer): State<Computer>,
266 axum::extract::Path(id): axum::extract::Path<String>,
267 request: Request,
268) -> Result<Response> {
269 use base64::Engine;
270 let transfer = computer
271 .transfers
272 .lock()
273 .unwrap()
274 .remove(&id)
275 .ok_or_else(|| {
276 Error::new(
277 410,
278 "This transfer expired or was already used. Request a new URL.",
279 )
280 })?;
281 transfer_access(&computer, &transfer).await?;
282 let permit = computer
283 .transfer_slots
284 .clone()
285 .try_acquire_owned()
286 .map_err(|_| {
287 Error::new(
288 429,
289 "Four file transfers are running. Finish one, then request a new URL.",
290 )
291 })?;
292 if request.method()
293 != if transfer.upload {
294 Method::PUT
295 } else {
296 Method::GET
297 }
298 {
299 return Err(Error::new(
300 405,
301 "Use the HTTP method returned with this URL.",
302 ));
303 }
304 if transfer.upload {
305 let temporary = format!(
306 "{}.snowglobe-{}",
307 transfer.path,
308 uuid::Uuid::new_v4().simple()
309 );
310 let mut cleanup = UploadCleanup {
311 vm: transfer.vm.clone(),
312 path: Some(temporary.clone()),
313 };
314 let result: Result<Value> = tokio::time::timeout_at(transfer.expires.into(), async {
315 let mut stream=request.into_body().into_data_stream();
316 let mut offset=0_u64;
317 while let Some(chunk)=stream.next().await {
318 let chunk=chunk.map_err(|_|Error::new(400,"The upload ended early. Request a new URL and retry."))?;
319 for bytes in chunk.chunks(65536) {
320 if offset+bytes.len() as u64>transfer.size { return Err(Error::new(413,"The upload exceeds its declared size.")); }
321 transfer_access(&computer,&transfer).await?;
322 dispatch(&transfer.vm,json!({"action":"file","operation":"write","path":temporary,"offset":offset,"data":base64::engine::general_purpose::STANDARD.encode(bytes)})).await?;
323 offset+=bytes.len() as u64;
324 }
325 }
326 if offset!=transfer.size { return Err(Error::new(400,"The upload ended early. Request a new URL and retry.")); }
327 if offset==0 { dispatch(&transfer.vm,json!({"action":"file","operation":"write","path":temporary,"offset":0,"data":""})).await?; }
328 transfer_access(&computer,&transfer).await?;
329 dispatch(&transfer.vm,json!({"action":"file","operation":"commit","path":temporary,"destination":transfer.path,"overwrite":transfer.overwrite})).await?;
330 Ok(json!({"path":transfer.path,"bytes":offset}))
331 }).await.map_err(|_|Error::new(410,"This transfer expired. Request a new URL."))?;
332 if result.is_ok() {
333 cleanup.path = None;
334 }
335 Ok(axum::Json(result?).into_response())
336 } else {
337 let size = transfer.size;
338 let (sender, receiver) = tokio::sync::mpsc::channel(1);
339 tokio::spawn(async move {
340 let _permit = permit;
341 let result: Result<()> = tokio::time::timeout_at(transfer.expires.into(), async {
342 let mut offset = 0;
343 while offset < transfer.size {
344 if sender.is_closed() { return Ok(()); }
345 transfer_access(&computer, &transfer).await?;
346 let length = (transfer.size - offset).min(65536);
347 let reply = dispatch(&transfer.vm, json!({"action":"file","operation":"read","path":transfer.path,"offset":offset,"length":length})).await?;
348 let bytes = base64::engine::general_purpose::STANDARD.decode(string(&reply["data"]))
349 .map_err(|_| Error::new(502, "The guest returned an incomplete file."))?;
350 if bytes.len() as u64 != length {
351 return Err(Error::new(409, "The guest file changed during the download."));
352 }
353 if sender.send(Ok(Bytes::from(bytes))).await.is_err() { return Ok(()); }
354 offset += length;
355 }
356 Ok(())
357 }).await.unwrap_or_else(|_| Err(Error::new(410, "This transfer expired. Request a new URL.")));
358 if let Err(error) = result {
359 let _ = sender.try_send(Err(std::io::Error::other(error.message)));
360 }
361 });
362 let stream = futures::stream::unfold(receiver, |mut receiver| async {
363 receiver.recv().await.map(|chunk| (chunk, receiver))
364 });
365 Ok(Response::builder()
366 .header("content-type", "application/octet-stream")
367 .header("content-length", size)
368 .header("cache-control", "no-store")
369 .header("content-disposition", "attachment")
370 .body(axum::body::Body::from_stream(stream))
371 .unwrap())
372 }
373}
374
375pub fn router(app: Arc<App>) -> Router {
376 let computer = Computer {
377 app: app.clone(),
378 transfers: Arc::new(Mutex::new(HashMap::new())),
379 transfer_slots: Arc::new(Semaphore::new(4)),
380 };
381 let handler = computer.clone();
382 mcp::router(app, "computer", move || Ok(handler.clone())).merge(
383 Router::new()
384 .route("/mcp/computer/files/{id}", any(transfer))
385 .with_state(computer),
386 )
387}
388
389#[cfg(test)]
390mod tests {
391 use super::*;
392
393 #[test]
394 fn dashboard_admin_access_does_not_extend_mcp_grants() {
395 let admin = json!({"id":"admin","groups":["infra-admin"]});
396 let vm = json!({"owner":"another-user","ownerOnly":true});
397 assert!(vms::visible(&admin, &vm));
398 let grant = json!({"user":"admin","scopes":["computer:read","computer:control"],"resources":["test-vm"]});
399 for scope in ["computer:read", "computer:control"] {
400 assert!(permitted(&grant, "test-vm", scope, &vm).is_err());
401 }
402 }
403
404 #[test]
405 fn control_requires_the_current_owner_selected_vm_and_scope() {
406 let grant = json!({"user":"clover","scopes":["computer:read"],"resources":["m3-devbox"]});
407 let owner = json!({"owner":"clover","ownerOnly":true});
408 assert!(permitted(&grant, "m3-devbox", "computer:read", &owner).is_ok());
409 assert!(permitted(&grant, "m3-devbox", "computer:control", &owner).is_err());
410 assert!(permitted(&grant, "other", "computer:read", &owner).is_err());
411 assert!(
412 permitted(
413 &grant,
414 "m3-devbox",
415 "computer:read",
416 &json!({"owner":"another-user"})
417 )
418 .is_err()
419 );
420 assert!(permitted(&grant, "m3-devbox", "computer:read", &Value::Null).is_err());
421 }
422
423 #[test]
424 fn screen_access_does_not_grant_files_commands_or_lifecycle_changes() {
425 let args = serde_json::Map::new();
426 for action in ["file", "upload", "download", "exec", "spawn", "input", "ui_action", "vm"] {
427 assert_eq!(scope(action, &args), "computer:control");
428 }
429 let status = json!({"operation":"status"});
430 let stop = json!({"operation":"stop"});
431 assert_eq!(scope("process", status.as_object().unwrap()), "computer:read");
432 assert_eq!(scope("process", stop.as_object().unwrap()), "computer:control");
433 }
434}