Skip to content

armgit / cua

Public Imported from GitHub
0

Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.

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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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()