| 1 | use crate::*; |
| 2 | use 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 | |
| 11 | pub 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 | |
| 22 | fn 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 | |
| 36 | struct 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 | |
| 46 | struct UploadCleanup { |
| 47 | vm: String, |
| 48 | path: Option<String>, |
| 49 | } |
| 50 | |
| 51 | impl 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)] |
| 71 | struct Computer { |
| 72 | app: Arc<App>, |
| 73 | transfers: Arc<Mutex<HashMap<String, Transfer>>>, |
| 74 | transfer_slots: Arc<Semaphore>, |
| 75 | } |
| 76 | |
| 77 | fn 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 | |
| 88 | async 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 | |
| 98 | impl 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 | |
| 250 | async 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 | |
| 265 | fn 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 | |
| 271 | async 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 | |
| 397 | pub 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)] |
| 412 | mod 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 | } |