Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.
Rust agentai-agentapplecomputer-usecomputer-use-agentcontainerizationcuadesktop-automationhacktoberfestlumemacosmanusoperatorswiftvirtualizationvirtualization-frameworkwindowswindows-sandbox
fix(keyvault): delete items whose delivery target or import is gone (#4889)
ddupontcf1217ce9009
diff --git a/libs/cua/crates/cua-keyvault/src/broker.rs b/libs/cua/crates/cua-keyvault/src/broker.rsindex 113a47abf2..9d46a2c666 100644--- a/libs/cua/crates/cua-keyvault/src/broker.rs+++ b/libs/cua/crates/cua-keyvault/src/broker.rs@@ -3653,10 +3653,19 @@ impl Broker {.collect()};let mut wiped_ids = Vec::new();+ let mut gone_ids: Vec<String> = Vec::new();let mut errors = Vec::new();for d in &live {match self.backend.wipe(&d.target, &d.import_id).await {Ok(_) => wiped_ids.push(d.import_id.clone()),+ // The Space or the import is gone (the user removed the+ // Space, or the target's own expiry already wiped it): the+ // copy no longer exists, so the delivery counts as wiped+ // and must not block deleting the item.+ Err(Error::NotFound(_)) => {+ gone_ids.push(d.import_id.clone());+ wiped_ids.push(d.import_id.clone());+ }Err(e) => errors.push(format!("{}: {e}", d.target)),}}@@ -3673,7 +3682,14 @@ impl Broker {for d in live.iter().filter(|d| wiped_ids.contains(&d.import_id)) {let mut e = ev("target.wipe", caller, "ok");e.target = Some(d.target.clone());- e.detail = format!("import={}", d.import_id);+ e.detail = if gone_ids.contains(&d.import_id) {+ format!(+ "import={} already gone (target or import missing)",+ d.import_id+ )+ } else {+ format!("import={}", d.import_id)+ };Self::audit(&mut st, e);}if !errors.is_empty() {diff --git a/libs/cua/crates/cua-keyvault/tests/broker.rs b/libs/cua/crates/cua-keyvault/tests/broker.rsindex 3ce4c3920b..2ab9436e7a 100644--- a/libs/cua/crates/cua-keyvault/tests/broker.rs+++ b/libs/cua/crates/cua-keyvault/tests/broker.rs@@ -31,6 +31,8 @@ struct FakeBackend {/// The `launch` flag of every launching delivery.launches: Mutex<Vec<bool>>,captures: Mutex<Vec<ImportSpec>>,+ /// Makes every wipe fail like a removed Space or an expired import.+ wipe_gone: Mutex<bool>,/// Name -> immutable Space id. A name absent here resolves to a stable/// `sandbox-<name>`; a test can insert a new id to model a rename or a/// re-created Space (red-team F1).@@ -218,6 +220,9 @@ impl Backend for FakeBackend {}async fn wipe(&self, target: &str, import_id: &str) -> cua_keyvault::Result<Vec<String>> {+ if *self.wipe_gone.lock().unwrap() {+ return Err(Error::NotFound(format!("Space {target:?}")));+ }self.wiped.lock().unwrap()@@ -821,6 +826,32 @@ async fn revoking_one_site_leaves_the_others() {assert_eq!(left[0].id, i2[0]);}+/// #4887: items delivered to a Space that was since removed (or whose import+/// expired) must still be deletable.+#[tokio::test]+async fn deleting_items_whose_space_or_import_is_gone_succeeds() {+ let r = rig().await;+ let (token, ids) = grant(&r, &r.koala, "github.com", "dev-1").await;+ r.broker+ .teleport(+ &r.koala,+ TeleportRequest {+ token: Some(token),+ items: ids.clone(),+ target: "dev-1".into(),+ include_passwords: false,+ launch: false,+ },+ )+ .await+ .unwrap();+ *r.backend.wipe_gone.lock().unwrap() = true;+ r.broker.delete_items(&r.cua, ids.clone()).await.unwrap();+ assert!(all_items(&r).await.is_empty());+ let deliveries = r.broker.list_deliveries(&r.cua).await.unwrap();+ assert!(deliveries.iter().all(|d| d.wiped));+}+#[tokio::test]async fn unattended_rules_need_signed_known_callers_and_expire() {let r = rig().await;diff --git a/libs/cua/crates/cua-spaces-ext/src/daemon/keyvault.rs b/libs/cua/crates/cua-spaces-ext/src/daemon/keyvault.rsindex 03de172b52..99b974e511 100644--- a/libs/cua/crates/cua-spaces-ext/src/daemon/keyvault.rs+++ b/libs/cua/crates/cua-spaces-ext/src/daemon/keyvault.rs@@ -790,6 +790,9 @@ impl Backend for DaemonBackend {}async fn wipe(&self, target: &str, import_id: &str) -> KvResult<Vec<String>> {+ // A Space that no longer exists, or one that no longer knows the+ // import, holds nothing to wipe: report that as NotFound so the+ // broker can finish deleting the item (see `wipe_where`).let space = self.open_target(target).await?;let resp = space.spacesd()@@ -800,7 +803,14 @@ impl Backend for DaemonBackend {all: false,}).await- .map_err(|e| backend_err("wipe import", e))?+ .map_err(|e| {+ // gRPC NOT_FOUND (5): the target no longer knows the import.+ if e.code() as i32 == 5 {+ KvError::NotFound(format!("import {import_id:?} on {target}"))+ } else {+ backend_err("wipe import", e)+ }+ })?.into_inner();Ok(resp.removed_paths)}diff --git a/libs/cua/crates/cua-spaces-ext/tests/e2e_keyvault_delete.rs b/libs/cua/crates/cua-spaces-ext/tests/e2e_keyvault_delete.rsnew file mode 100644index 0000000000..d4111a847a--- /dev/null+++ b/libs/cua/crates/cua-spaces-ext/tests/e2e_keyvault_delete.rs@@ -0,0 +1,271 @@+// SPDX-License-Identifier: FSL-1.1-MIT+// Copyright (c) 2026 Cua AI, Inc.++//! Live e2e of deleting Keyvault items (#4887) against a real cua-spacesd:+//! the real `DaemonBackend` and broker deliver a session, then delete the+//! items with the Space present, after the Space was removed, and after the+//! target forgot the import. Skipped unless `CUA_SPACES_E2E_URL` (and+//! `CUA_SPACES_E2E_TOKEN`) point at a spacesd with a throwaway HOME.+#![cfg(unix)]++use std::collections::HashSet;+use std::io::Write;+use std::sync::Arc;+use std::time::Duration;++use cua_keyvault::CallerIdentity;+use cua_keyvault::broker::{+ AccessRequest, ApproveOptions, Broker, Decision, FakePresence, InitRequest, Selector,+ TeleportRequest,+};+use cua_spaces::Spaces;+use cua_spaces_ext::daemon::keyvault::{DaemonBackend, Keyvault};+use cua_spaces_ext::teleport::AppSessions;+use cua_teleport::bundle::BundleWriter;+use cua_teleport::{+ AppRef, ExportProvider, ExportRegistry, FakeHost, HostEffects, ManifestItem, Platform,+ TransferManifest, TransferScope, WindowRef,+};++const SECRET: &[u8] = b"SEKRIT-github-session-cookie-value";++/// A deterministic provider that exports one fixed, non-sensitive blob as the+/// `chrome` session, so capture never reads a real profile or prompts.+struct FixedProvider {+ host: Arc<dyn HostEffects>,+}++impl ExportProvider for FixedProvider {+ fn id(&self) -> &str {+ "chrome"+ }+ fn display_name(&self) -> &str {+ "Fixed Chrome (test)"+ }+ fn host(&self) -> &dyn HostEffects {+ self.host.as_ref()+ }+ fn platform_supported(&self, _platform: Platform) -> bool {+ true+ }+ fn matches(&self, app: &AppRef) -> bool {+ app.app_id == "chrome"+ }+ fn app_ids(&self) -> &[&str] {+ &["chrome"]+ }+ fn manifest(+ &self,+ _app: &AppRef,+ _window: Option<&WindowRef>,+ scope: TransferScope,+ ) -> cua_teleport::Result<TransferManifest> {+ Ok(TransferManifest {+ provider_id: "chrome".into(),+ app_display_name: "Fixed Chrome (test)".into(),+ scope,+ items: vec![ManifestItem {+ label: "cookies".into(),+ rel_path: "Default/Cookies".into(),+ est_bytes: SECRET.len() as u64,+ count: None,+ count_noun: None,+ // Not sensitive: the biometric gate never fires in the test.+ sensitive: false,+ default_checked: true,+ }],+ total_est_bytes: SECRET.len() as u64,+ notes: vec![],+ })+ }+ fn capture_selected(+ &self,+ _app: &AppRef,+ scope: TransferScope,+ _include: Option<&HashSet<String>>,+ out: &mut dyn Write,+ ) -> cua_teleport::Result<()> {+ let mut writer = BundleWriter::new(out, "chrome", "Fixed Chrome (test)", scope);+ writer.add_bytes("Default/Cookies", 0o600, SECRET)?;+ writer.finish()?;+ Ok(())+ }+}++struct Rig {+ _reg: tempfile::TempDir,+ _vault: tempfile::TempDir,+ spaces: Spaces,+ broker: Arc<Broker>,+ cua: CallerIdentity,+ koala: CallerIdentity,+ url: String,+ token: String,+ target: std::sync::Mutex<String>,+}++fn env() -> Option<(String, String)> {+ let url = std::env::var("CUA_SPACES_E2E_URL")+ .ok()+ .filter(|s| !s.is_empty())?;+ Some((+ url,+ std::env::var("CUA_SPACES_E2E_TOKEN").unwrap_or_default(),+ ))+}++async fn rig(url: String, token: String) -> Rig {+ let reg = tempfile::tempdir().unwrap();+ let spaces = Spaces::builder()+ .home(reg.path())+ .operator_display(Arc::new(cua_spaces::operator::NoDisplay))+ .probe_timeout(Duration::from_secs(20))+ .build();+ let info = spaces+ .add(&url, Some(token.clone()), Some("target".into()))+ .await+ .unwrap();+ let mut registry = ExportRegistry::new();+ registry.register(Box::new(FixedProvider {+ host: Arc::new(FakeHost::new()),+ }));+ let sessions = Arc::new(AppSessions::from_registry(registry));+ let backend = Arc::new(DaemonBackend::new(spaces.clone(), sessions));+ let presence = Arc::new(FakePresence::new(true));+ let vault = tempfile::tempdir().unwrap();+ let kv = Keyvault::new(vault.path().join("keyvault"), backend, presence, false).unwrap();+ let broker = kv.broker();+ let cua = CallerIdentity::for_tests("com.trycua.cua", true);+ let koala = CallerIdentity::for_tests("com.example.koalabot", false);+ broker+ .init(+ &cua,+ InitRequest {+ os_protector: false,+ passphrase: Some("correct horse battery".into()),+ recovery_key: true,+ },+ )+ .await+ .unwrap();+ Rig {+ _reg: reg,+ _vault: vault,+ spaces,+ broker,+ cua,+ koala,+ url,+ token,+ target: std::sync::Mutex::new(info.id),+ }+}++/// Grants chrome into the target and delivers it; returns the item ids.+async fn deliver(r: &Rig) -> Vec<String> {+ let target = r.target.lock().unwrap().clone();+ let pending = r+ .broker+ .request_access(+ &r.koala,+ AccessRequest {+ selectors: vec![Selector::App {+ app: "chrome".into(),+ }],+ targets: vec![target.clone()],+ uses: Some(0),+ ..Default::default()+ },+ )+ .await+ .unwrap();+ r.broker+ .approve(&r.cua, &pending.id, ApproveOptions::default())+ .await+ .unwrap();+ let (token, items) = match r+ .broker+ .await_decision(&r.koala, &pending.id, Duration::from_millis(50))+ .await+ .unwrap()+ {+ Decision::Granted { token, items, .. } => (token, items),+ other => panic!("expected a grant, got {other:?}"),+ };+ r.broker+ .teleport(+ &r.koala,+ TeleportRequest {+ token: Some(token),+ items: items.clone(),+ target,+ include_passwords: false,+ launch: false,+ },+ )+ .await+ .expect("delivery to the real spacesd");+ items+}++#[tokio::test]+async fn e2e_items_delivered_to_a_gone_space_or_import_can_be_deleted() {+ let Some((url, token)) = env() else {+ eprintln!("skipped: set CUA_SPACES_E2E_URL / CUA_SPACES_E2E_TOKEN");+ return;+ };+ let r = rig(url, token).await;++ // 1. The Space exists: deleting wipes the delivered copy (as before).+ let items = deliver(&r).await;+ r.broker.delete_items(&r.cua, items).await.unwrap();+ eprintln!("case 1 (Space present): deleted");++ // 2. The target forgot the import (expired, or a re-created Space).+ let items = deliver(&r).await;+ let deliveries = r.broker.list_deliveries(&r.cua).await.unwrap();+ let live = deliveries.iter().find(|d| !d.wiped).unwrap();+ let space = r.spaces.space(&live.target).await.unwrap();+ space+ .spacesd()+ .unwrap()+ .teleport()+ .wipe_import(cua_spacesd_client::pb::WipeImportRequest {+ import_id: live.import_id.clone(),+ all: false,+ })+ .await+ .unwrap();+ r.broker.delete_items(&r.cua, items).await.unwrap();+ eprintln!("case 2 (import gone): deleted");++ // 3. The Space was removed (the reporter's steps 1 to 3).+ let items = deliver(&r).await;+ let id = r.target.lock().unwrap().clone();+ r.spaces.remove(&id).await.unwrap();+ r.broker.delete_items(&r.cua, items).await.unwrap();+ eprintln!("case 3 (Space removed): deleted");++ // 4. A same-name Space re-created afterwards does not block it either.+ let items = deliver_after_readd(&r).await;+ r.broker.delete_items(&r.cua, items).await.unwrap();+ eprintln!("case 4 (re-created Space): deleted");+}++async fn deliver_after_readd(r: &Rig) -> Vec<String> {+ let info = r+ .spaces+ .add(&r.url, Some(r.token.clone()), Some("target".into()))+ .await+ .unwrap();+ *r.target.lock().unwrap() = info.id.clone();+ let items = deliver(r).await;+ r.spaces.remove(&info.id).await.unwrap();+ let info = r+ .spaces+ .add(&r.url, Some(r.token.clone()), Some("target".into()))+ .await+ .unwrap();+ *r.target.lock().unwrap() = info.id;+ items+}diff --git a/libs/cua/crates/cua-spaces-ext/tests/keyvault_delivery.rs b/libs/cua/crates/cua-spaces-ext/tests/keyvault_delivery.rsindex dc5a191fa6..40678e662c 100644--- a/libs/cua/crates/cua-spaces-ext/tests/keyvault_delivery.rs+++ b/libs/cua/crates/cua-spaces-ext/tests/keyvault_delivery.rs@@ -260,6 +260,50 @@ async fn broker_delivers_a_granted_capability_and_wipes_on_release() {);}+async fn deliver_to_target(r: &Rig) -> Vec<String> {+ let (token, items) = grant(r, &r.target).await;+ r.broker+ .teleport(+ &r.koala,+ TeleportRequest {+ token: Some(token),+ items: items.clone(),+ target: r.target.clone(),+ include_passwords: false,+ launch: false,+ },+ )+ .await+ .unwrap();+ items+}++/// #4887: deleting items delivered to a Space the user has since removed.+#[tokio::test]+async fn items_delivered_to_a_removed_space_can_be_deleted() {+ let r = rig().await;+ let items = deliver_to_target(&r).await;+ r.spaces.remove(&r.target).await.unwrap();+ r.broker.delete_items(&r.cua, items.clone()).await.unwrap();+ assert!(matches!(+ r.broker.delete_items(&r.cua, items).await,+ Err(cua_keyvault::Error::NotFound(_))+ ));+}++/// #4887: the Space exists again (or still) but no longer knows the import.+#[tokio::test]+async fn items_whose_import_expired_on_the_target_can_be_deleted() {+ let r = rig().await;+ let items = deliver_to_target(&r).await;+ r.mock.state.expire_teleport_imports();+ r.broker.delete_items(&r.cua, items.clone()).await.unwrap();+ assert!(matches!(+ r.broker.delete_items(&r.cua, items).await,+ Err(cua_keyvault::Error::NotFound(_))+ ));+}+#[tokio::test]async fn a_capability_for_a_different_target_is_refused() {let r = rig().await;diff --git a/libs/cua/crates/cua-spacesd-client/src/testing.rs b/libs/cua/crates/cua-spacesd-client/src/testing.rsindex 47555705f1..337fb80fec 100644--- a/libs/cua/crates/cua-spacesd-client/src/testing.rs+++ b/libs/cua/crates/cua-spacesd-client/src/testing.rs@@ -239,6 +239,11 @@ impl MockState {self.teleport_wipes.lock().unwrap().clone()}+ /// Forgets every import, as the target's own expiry would.+ pub fn expire_teleport_imports(&self) {+ self.teleport_imports.lock().unwrap().clear();+ }+/// Stored file content.pub fn file(&self, path: &str) -> Option<Vec<u8>> {self.files.lock().unwrap().get(path).cloned()