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" | "force_off" | "reset")) if !arguments.contains_key("seconds") => {
177 let host_action = if operation == "force_off" { "destroy" } else { operation };
178 host::call(json!({"operation":"vm.act","payload":{"name":vm,"action":host_action}})).await?;
179 Ok(json!({"id":vm,"requested":operation}))
180 },
181 _ => Err(Error::new(400,"Choose start, shutdown, reboot, force_off, reset, extend, or delete.")),
182 };
183 }
184 if matches!(action,"upload"|"download") {
185 let path = arguments.remove("path").and_then(|v| v.as_str().map(str::to_owned))
186 .filter(|p| !p.is_empty() && p.len() <= 4096 && !p.contains('\0'))
187 .ok_or_else(|| Error::new(400,"Choose an absolute guest file path."))?;
188 let upload = action == "upload";
189 let overwrite = arguments.remove("overwrite").unwrap_or(json!(false));
190 if !overwrite.is_boolean() { return Err(Error::new(400,"Choose whether to replace the destination.")); }
191 let size = if upload {
192 arguments.remove("size").and_then(|v|v.as_u64()).ok_or_else(||Error::new(400,"Provide the upload size in bytes."))?
193 } else {
194 let info = dispatch(&vm,json!({"action":"file","operation":"stat","path":path})).await?;
195 if info["directory"] == true { return Err(Error::new(400,"Choose a file to download.")); }
196 info["size"].as_u64().ok_or_else(||Error::new(400,"The guest did not report a file size."))?
197 };
198 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.")); }
199 if upload {
200 let parent = path.rfind(['/', '\\']).filter(|index| index + 1 < path.len())
201 .map(|index| &path[..=index]).ok_or_else(|| Error::new(400,"Choose an absolute guest file path."))?;
202 let info = dispatch(&vm,json!({"action":"file","operation":"stat","path":parent})).await?;
203 if info["directory"] != true { return Err(Error::new(400,"Choose an existing destination folder.")); }
204 }
205 let now = std::time::Instant::now();
206 let mut transfers = self.transfers.lock().unwrap();
207 transfers.retain(|_,t|t.expires>now);
208 if transfers.len()>=128 { return Err(Error::new(429,"Too many pending transfers. Finish one or wait for it to expire.")); }
209 let id = format!("{}{}",uuid::Uuid::new_v4().simple(),uuid::Uuid::new_v4().simple());
210 let mut headers = HeaderMap::new();
211 if let Some(value) = parts.headers.get("authorization") { headers.insert("authorization",value.clone()); }
212 transfers.insert(id.clone(),Transfer{headers,vm,path,size,upload,overwrite:overwrite==true,expires:now+Duration::from_secs(600)});
213 return Ok(json!({"url":format!("{}mcp/computer/files/{id}",self.app.mcp.origin),"method":if upload {"PUT"} else {"GET"},"bytes":size,"expires_in":600}));
214 }
215 let fields: &[&str] = match action {
216 "status"|"shot" => &[], "ui" => &["pid"],
217 "input" => &["actions","screenshot"],
218 "ui_action" => &["target","operation","value","screenshot"],
219 "exec" => &["script","runtime","timeout_ms","screenshot"],
220 "spawn" => &["script","runtime"], "process" => &["id","operation"],
221 "file" => &["path","operation"],
222 _ => return Err(Error::new(404,"No tool with that name.")),
223 };
224 if arguments.keys().any(|k|!fields.contains(&k.as_str())) { return Err(Error::new(400,"Use the fields listed for this tool.")); }
225 if action == "file" && !matches!(arguments.get("operation").and_then(Value::as_str),Some("stat"|"list"|"mkdir"|"remove")) {
226 return Err(Error::new(400,"Choose stat, list, mkdir or remove."));
227 }
228 if action == "exec" { arguments.entry("timeout_ms").or_insert(json!(60000)); }
229 if matches!(action,"exec"|"input"|"ui_action") { arguments.entry("screenshot").or_insert(json!(true)); }
230 if matches!(action,"exec"|"spawn") { arguments.entry("runtime").or_insert(json!("default")); }
231 arguments.insert("action".into(),json!(action));
232 dispatch(&vm,Value::Object(arguments)).await
233
234 }.await;
235 Ok(match result {
236 Ok(mut value) => {
237 let png = value.as_object_mut().and_then(|v| v.remove("png"));
238 let mut content = vec![ContentBlock::text(value.to_string())];
239 if let Some(png) = png.and_then(|v| v.as_str().map(str::to_owned)) {
240 content.push(ContentBlock::image(png, "image/png"));
241 }
242 CallToolResult::success(content)
243 }
244 Err(error) => CallToolResult::error(vec![ContentBlock::text(error.message)]),
245 }
246 .into())
247 }
248}
249
250async fn transfer_access(computer: &Computer, transfer: &Transfer) -> Result<()> {
251 if transfer.expires <= std::time::Instant::now() {
252 return Err(Error::new(410, "This transfer expired. Request a new URL."));
253 }
254 let grant = computer
255 .app
256 .mcp
257 .authenticate(&transfer.headers, &computer.app.mcp.resource("computer"))?;
258 if !mcp::active_owner(&computer.app, &grant)? {
259 return Err(Error::new(401, "This connection expired. Connect again."));
260 }
261 let owner = host::call(json!({"operation":"vm.owner","payload":{"name":transfer.vm}})).await?;
262 permitted(&grant, &transfer.vm, "computer:control", &owner)
263}
264
265fn transfer_chunk(reply: &Value) -> usize {
266 reply["chunk_bytes"].as_u64()
267 .filter(|size| (65536..=host::LIMITS.file_chunk as u64).contains(size))
268 .unwrap_or(65536) as usize
269}
270
271async fn transfer(
272 State(computer): State<Computer>,
273 axum::extract::Path(id): axum::extract::Path<String>,
274 request: Request,
275) -> Result<Response> {
276 use base64::Engine;
277 let mut transfer = computer
278 .transfers
279 .lock()
280 .unwrap()
281 .remove(&id)
282 .ok_or_else(|| {
283 Error::new(
284 410,
285 "This transfer expired or was already used. Request a new URL.",
286 )
287 })?;
288 transfer_access(&computer, &transfer).await?;
289 let permit = computer
290 .transfer_slots
291 .clone()
292 .try_acquire_owned()
293 .map_err(|_| {
294 Error::new(
295 429,
296 "Four file transfers are running. Finish one, then request a new URL.",
297 )
298 })?;
299 if request.method()
300 != if transfer.upload {
301 Method::PUT
302 } else {
303 Method::GET
304 }
305 {
306 return Err(Error::new(
307 405,
308 "Use the HTTP method returned with this URL.",
309 ));
310 }
311 transfer.expires = std::time::Instant::now() + Duration::from_secs(1800);
312 if transfer.upload {
313 let temporary = format!(
314 "{}.snowglobe-{}",
315 transfer.path,
316 uuid::Uuid::new_v4().simple()
317 );
318 let mut cleanup = UploadCleanup {
319 vm: transfer.vm.clone(),
320 path: Some(temporary.clone()),
321 };
322 let result: Result<Value> = tokio::time::timeout_at(transfer.expires.into(), async {
323 let mut stream=request.into_body().into_data_stream();
324 let mut offset=0_u64;
325 let mut chunk=bytes::Bytes::new();
326 let mut chunk_size=65536;
327 let mut buffer=Vec::with_capacity(65536);
328 loop {
329 buffer.clear();
330 while buffer.len()<chunk_size {
331 if chunk.is_empty() {
332 let Some(next)=stream.next().await else { break };
333 chunk=next.map_err(|_|Error::new(400,"The upload ended early. Request a new URL and retry."))?;
334 }
335 let length=(chunk_size-buffer.len()).min(chunk.len());
336 buffer.extend_from_slice(&chunk.split_to(length));
337 }
338 if offset+buffer.len() as u64>transfer.size { return Err(Error::new(413,"The upload exceeds its declared size.")); }
339 if buffer.is_empty() && offset>0 { break; }
340 transfer_access(&computer,&transfer).await?;
341 let reply=dispatch(&transfer.vm,json!({"action":"file","operation":"write","path":temporary,"offset":offset,"data":base64::engine::general_purpose::STANDARD.encode(&buffer)})).await?;
342 offset+=buffer.len() as u64;
343 if buffer.len()<chunk_size { break; }
344 chunk_size=transfer_chunk(&reply);
345 }
346 if offset!=transfer.size { return Err(Error::new(400,"The upload ended early. Request a new URL and retry.")); }
347 transfer_access(&computer,&transfer).await?;
348 dispatch(&transfer.vm,json!({"action":"file","operation":"commit","path":temporary,"destination":transfer.path,"overwrite":transfer.overwrite})).await?;
349 Ok(json!({"path":transfer.path,"bytes":offset}))
350 }).await.unwrap_or_else(|_|Err(Error::new(410,"This transfer expired. Request a new URL.")));
351 if result.is_ok() || matches!(tokio::time::timeout(Duration::from_secs(15),
352 dispatch(&transfer.vm,json!({"action":"file","operation":"remove","path":temporary}))).await, Ok(Ok(_))) {
353 cleanup.path = None;
354 }
355 Ok(axum::Json(result?).into_response())
356 } else {
357 let size = transfer.size;
358 let (sender, receiver) = tokio::sync::mpsc::channel(1);
359 tokio::spawn(async move {
360 let _permit = permit;
361 let result: Result<()> = tokio::time::timeout_at(transfer.expires.into(), async {
362 let mut offset = 0;
363 let mut chunk_size = 65536;
364 while offset < transfer.size {
365 if sender.is_closed() { return Ok(()); }
366 transfer_access(&computer, &transfer).await?;
367 let length = (transfer.size - offset).min(chunk_size as u64);
368 let reply = dispatch(&transfer.vm, json!({"action":"file","operation":"read","path":transfer.path,"offset":offset,"length":length})).await?;
369 let bytes = base64::engine::general_purpose::STANDARD.decode(string(&reply["data"]))
370 .map_err(|_| Error::new(502, "The guest returned an incomplete file."))?;
371 if bytes.len() as u64 != length {
372 return Err(Error::new(409, "The guest file changed during the download."));
373 }
374 if sender.send(Ok(Bytes::from(bytes))).await.is_err() { return Ok(()); }
375 offset += length;
376 chunk_size = transfer_chunk(&reply);
377 }
378 Ok(())
379 }).await.unwrap_or_else(|_| Err(Error::new(410, "This transfer expired. Request a new URL.")));
380 if let Err(error) = result {
381 let _ = sender.try_send(Err(std::io::Error::other(error.message)));
382 }
383 });
384 let stream = futures::stream::unfold(receiver, |mut receiver| async {
385 receiver.recv().await.map(|chunk| (chunk, receiver))
386 });
387 Ok(Response::builder()
388 .header("content-type", "application/octet-stream")
389 .header("content-length", size)
390 .header("cache-control", "no-store")
391 .header("content-disposition", "attachment")
392 .body(axum::body::Body::from_stream(stream))
393 .unwrap())
394 }
395}
396
397pub fn router(app: Arc<App>) -> Router {
398 let computer = Computer {
399 app: app.clone(),
400 transfers: Arc::new(Mutex::new(HashMap::new())),
401 transfer_slots: Arc::new(Semaphore::new(4)),
402 };
403 let handler = computer.clone();
404 mcp::router(app, "computer", move || Ok(handler.clone())).merge(
405 Router::new()
406 .route("/mcp/computer/files/{id}", any(transfer))
407 .with_state(computer),
408 )
409}
410
411#[cfg(test)]
412mod tests {
413 use super::*;
414
415 #[test]
416 fn dashboard_admin_access_does_not_extend_mcp_grants() {
417 let admin = json!({"id":"admin","groups":["infra-admin"]});
418 let vm = json!({"owner":"another-user","ownerOnly":true});
419 assert!(vms::visible(&admin, &vm));
420 let grant = json!({"user":"admin","scopes":["computer:read","computer:control"],"resources":["test-vm"]});
421 for scope in ["computer:read", "computer:control"] {
422 assert!(permitted(&grant, "test-vm", scope, &vm).is_err());
423 }
424 }
425
426 #[test]
427 fn control_requires_the_current_owner_selected_vm_and_scope() {
428 let grant = json!({"user":"clover","scopes":["computer:read"],"resources":["m3-devbox"]});
429 let owner = json!({"owner":"clover","ownerOnly":true});
430 assert!(permitted(&grant, "m3-devbox", "computer:read", &owner).is_ok());
431 assert!(permitted(&grant, "m3-devbox", "computer:control", &owner).is_err());
432 assert!(permitted(&grant, "other", "computer:read", &owner).is_err());
433 assert!(
434 permitted(
435 &grant,
436 "m3-devbox",
437 "computer:read",
438 &json!({"owner":"another-user"})
439 )
440 .is_err()
441 );
442 assert!(permitted(&grant, "m3-devbox", "computer:read", &Value::Null).is_err());
443 }
444
445 #[test]
446 fn screen_access_does_not_grant_files_commands_or_lifecycle_changes() {
447 let args = serde_json::Map::new();
448 for action in ["file", "upload", "download", "exec", "spawn", "input", "ui_action", "vm"] {
449 assert_eq!(scope(action, &args), "computer:control");
450 }
451 let status = json!({"operation":"status"});
452 let stop = json!({"operation":"stop"});
453 assert_eq!(scope("process", status.as_object().unwrap()), "computer:read");
454 assert_eq!(scope("process", stop.as_object().unwrap()), "computer:control");
455 }
456}