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(cua-driver): keep idle-end launch ownership only until a terminal end (#6738)
injaneityec4d973dbd7e
diff --git a/libs/cua-driver/rust/crates/cua-driver-core/src/browser/engine.rs b/libs/cua-driver/rust/crates/cua-driver-core/src/browser/engine.rsindex 40d2bc5664..df9c8cc7dd 100644--- a/libs/cua-driver/rust/crates/cua-driver-core/src/browser/engine.rs+++ b/libs/cua-driver/rust/crates/cua-driver-core/src/browser/engine.rs@@ -1346,9 +1346,11 @@ impl BrowserEngine {let mut grant = self.existing_profile_grant(session, transport_session, pid).await?;- let driver_owned = self.is_driver_owned_pid_for_session(session, pid)- || transport_session- .is_some_and(|owner| self.is_driver_owned_pid_for_session(owner, pid));+ let driver_owned = self.is_driver_owned_pid_for_session(session, pid).await+ || match transport_session {+ Some(owner) => self.is_driver_owned_pid_for_session(owner, pid).await,+ None => false,+ };let access_class = endpoint_access_class(grant.is_some(), driver_owned, class.process_role).map_err(|refusal| with_existing_profile_next_call(refusal, session, pid, window_id))?;@@ -1559,10 +1561,16 @@ impl BrowserEngine {match record.endpoint_access_class {EndpointAccessClass::DriverOwned => {- let lifecycle_is_live = self.is_driver_owned_pid_for_session(session, record.pid)- || record.transport_session.as_deref().is_some_and(|owner| {- self.is_driver_owned_pid_for_session(owner, record.pid)- });+ let lifecycle_is_live = self+ .is_driver_owned_pid_for_session(session, record.pid)+ .await+ || match record.transport_session.as_deref() {+ Some(owner) => {+ self.is_driver_owned_pid_for_session(owner, record.pid)+ .await+ }+ None => false,+ };if !lifecycle_is_live {return Err(refuse(BrowserRefusalCode::BrowserConsentRequired,diff --git a/libs/cua-driver/rust/crates/cua-driver-core/src/browser/pointer.rs b/libs/cua-driver/rust/crates/cua-driver-core/src/browser/pointer.rsindex 81dbce693b..fa5a6b4ca4 100644--- a/libs/cua-driver/rust/crates/cua-driver-core/src/browser/pointer.rs+++ b/libs/cua-driver/rust/crates/cua-driver-core/src/browser/pointer.rs@@ -772,7 +772,7 @@ impl Tool for BrowserPointerTool {args: &Value,) -> ProtectedResourceOwnership {if adapter_id == "browser_bound_input" {- browser_resource_ownership(&self.engine, args)+ browser_resource_ownership(&self.engine, args).await} else {ProtectedResourceOwnership::UserOwned}diff --git a/libs/cua-driver/rust/crates/cua-driver-core/src/browser/prepare.rs b/libs/cua-driver/rust/crates/cua-driver-core/src/browser/prepare.rsindex 8c162e5e07..e5746627ec 100644--- a/libs/cua-driver/rust/crates/cua-driver-core/src/browser/prepare.rs+++ b/libs/cua-driver/rust/crates/cua-driver-core/src/browser/prepare.rs@@ -303,6 +303,9 @@ struct PreparedProfile {pub(crate) struct ManagedBrowser {child: Box<dyn IsolatedBrowserProcess>,owned_pid: i64,+ /// The launched process instance; `None` when it could not be attested,+ /// which never proves ownership.+ fingerprint: Option<super::types::ProcessFingerprint>,profile: PathBuf,delete_profile: bool,marker: ProfileMarker,@@ -789,18 +792,52 @@ fn spawned_runtime_pid(ownership: &EndpointOwnershipProof) -> i64 {}impl BrowserEngine {- pub(crate) fn is_driver_owned_pid_for_session(&self, session: &str, pid: i64) -> bool {- self.managed_browsers.lock().unwrap().iter().any(|browser| {- browser.owned_pid == pid && browser.owner_sessions.iter().any(|owner| owner == session)- })+ /// Whether `pid` is a browser this engine launched for `session` and is+ /// still the same process instance. A pid alone is not proof: it can be+ /// reused once the launched browser exits.+ pub(crate) async fn is_driver_owned_pid_for_session(&self, session: &str, pid: i64) -> bool {+ let launched = self+ .managed_browsers+ .lock()+ .unwrap()+ .iter()+ .find(|browser| {+ browser.owned_pid == pid+ && browser.owner_sessions.iter().any(|owner| owner == session)+ })+ .and_then(|browser| browser.fingerprint.clone());+ let Some(launched) = launched else {+ return false;+ };+ self.platform+ .process_fingerprint(pid)+ .await+ .is_ok_and(|current| launched.matches(¤t))}pub(crate) fn cleanup_prepared_session(&self, session: &str) {- self.protected_resource_ownership.remove_session(session);- self.managed_browsers- .lock()- .unwrap()- .retain(|browser| !browser.owner_sessions.iter().any(|owner| owner == session));+ // The store is shared with the registry, which owns the session's+ // other launch records. Drop only the browsers reaped here, so none+ // of their pids outlives its process.+ let reaped = {+ let mut browsers = self.managed_browsers.lock().unwrap();+ let (reaped, kept) = std::mem::take(&mut *browsers)+ .into_iter()+ .partition::<Vec<_>, _>(|browser| {+ browser.owner_sessions.iter().any(|owner| owner == session)+ });+ *browsers = kept;+ reaped+ };+ for browser in &reaped {+ let Some(fingerprint) = &browser.fingerprint else {+ continue;+ };+ for owner in &browser.owner_sessions {+ self.protected_resource_ownership+ .remove_process(owner, fingerprint);+ }+ }}pub(crate) async fn prepare_browser(@@ -900,7 +937,8 @@ impl BrowserEngine {owner_sessions.push(transport_session);}}- if let Ok(fingerprint) = self.platform.process_fingerprint(prepared_pid).await {+ let fingerprint = self.platform.process_fingerprint(prepared_pid).await.ok();+ if let Some(fingerprint) = &fingerprint {for owner in &owner_sessions {self.protected_resource_ownership.mark_driver_owned_process(owner, fingerprint.clone());@@ -909,6 +947,7 @@ impl BrowserEngine {self.managed_browsers.lock().unwrap().push(ManagedBrowser {child,owned_pid: prepared_pid,+ fingerprint,profile: prepared_profile.path,delete_profile: prepared_profile.delete_on_cleanup,marker: prepared_profile.marker,diff --git a/libs/cua-driver/rust/crates/cua-driver-core/src/browser/tools.rs b/libs/cua-driver/rust/crates/cua-driver-core/src/browser/tools.rsindex bdd8e47956..f0c1f26afc 100644--- a/libs/cua-driver/rust/crates/cua-driver-core/src/browser/tools.rs+++ b/libs/cua-driver/rust/crates/cua-driver-core/src/browser/tools.rs@@ -263,7 +263,7 @@ fn schema_ref() -> Value {})}-pub(crate) fn browser_resource_ownership(+pub(crate) async fn browser_resource_ownership(engine: &BrowserEngine,args: &Value,) -> ProtectedResourceOwnership {@@ -283,10 +283,14 @@ pub(crate) fn browser_resource_ownership(.and_then(|target_id| engine.store.get_target(&runtime_session, target_id).ok()).map(|target| target.pid)});- if pid.is_some_and(|pid| {- engine.is_driver_owned_pid_for_session(&runtime_session, pid)- || engine.is_driver_owned_pid_for_session(session, pid)- }) {+ let Some(pid) = pid else {+ return ProtectedResourceOwnership::UserOwned;+ };+ if engine+ .is_driver_owned_pid_for_session(&runtime_session, pid)+ .await+ || engine.is_driver_owned_pid_for_session(session, pid).await+ {ProtectedResourceOwnership::DriverOwned} else {ProtectedResourceOwnership::UserOwned@@ -488,7 +492,7 @@ impl Tool for GetBrowserStateTool {args: &Value,) -> ProtectedResourceOwnership {if adapter_id == "private_observation" {- browser_resource_ownership(&self.engine, args)+ browser_resource_ownership(&self.engine, args).await} else {ProtectedResourceOwnership::UserOwned}@@ -1047,7 +1051,7 @@ impl Tool for BrowserNavigateTool {args: &Value,) -> ProtectedResourceOwnership {if adapter_id == "browser_bound_input" {- browser_resource_ownership(&self.engine, args)+ browser_resource_ownership(&self.engine, args).await} else {ProtectedResourceOwnership::UserOwned}@@ -1207,7 +1211,7 @@ impl Tool for BrowserClickTool {args: &Value,) -> ProtectedResourceOwnership {if adapter_id == "browser_bound_input" {- browser_resource_ownership(&self.engine, args)+ browser_resource_ownership(&self.engine, args).await} else {ProtectedResourceOwnership::UserOwned}@@ -1988,7 +1992,7 @@ impl Tool for BrowserTypeTool {args: &Value,) -> ProtectedResourceOwnership {if adapter_id == "browser_bound_input" {- browser_resource_ownership(&self.engine, args)+ browser_resource_ownership(&self.engine, args).await} else {ProtectedResourceOwnership::UserOwned}@@ -2582,7 +2586,7 @@ impl Tool for BrowserSelectTool {args: &Value,) -> ProtectedResourceOwnership {if adapter_id == "browser_bound_input" {- browser_resource_ownership(&self.engine, args)+ browser_resource_ownership(&self.engine, args).await} else {ProtectedResourceOwnership::UserOwned}@@ -2781,7 +2785,7 @@ impl Tool for BrowserDialogTool {adapter_id,"private_observation" | "browser_consequential_action") {- browser_resource_ownership(&self.engine, args)+ browser_resource_ownership(&self.engine, args).await} else {ProtectedResourceOwnership::UserOwned}@@ -3188,6 +3192,8 @@ mod tests {struct MockPlatform {devtools: Option<std::net::TcpListener>,launch_delay: std::time::Duration,+ /// Start time reported for every pid; a change stands for pid reuse.+ start_time: std::sync::atomic::AtomicU64,}impl MockPlatform {@@ -3301,7 +3307,7 @@ mod tests {) -> Result<ProcessFingerprint, BrowserRefusal> {Ok(ProcessFingerprint {pid,- start_time: Some(1),+ start_time: Some(1 + self.start_time.load(std::sync::atomic::Ordering::SeqCst)),executable: None,})}@@ -3377,6 +3383,7 @@ mod tests {BrowserEngine::new(Arc::new(MockPlatform {devtools: Some(std::net::TcpListener::bind("127.0.0.1:0").unwrap()),launch_delay,+ ..MockPlatform::default()}))}@@ -3899,6 +3906,85 @@ mod tests {crate::session::end_session(&session);}+ #[cfg(unix)]+ #[tokio::test]+ async fn an_idle_end_reaps_the_browser_and_forgets_its_pid() {+ // The killed browser's pid can be reused by a user's browser, so no+ // launch record for it may outlive the idle sweep.+ let engine = launching_engine();+ let (session, owner) = start_lifecycle_session(None);+ let prepared =+ prepare_isolated(&engine, &session, &owner, json!({ "mode": "isolated_new" })).await;+ let pid = prepared["prepared_pid"].as_i64().expect("prepared pid");+ let launched_app = pid + 1;+ let ownership = engine.protected_resource_ownership.clone();+ ownership.mark_driver_owned_pid(&session, launched_app);+ let args = json!({ "session": session, "pid": pid });+ assert_eq!(+ browser_resource_ownership(&engine, &args).await,+ ProtectedResourceOwnership::DriverOwned+ );++ assert_eq!(+ crate::session::evict_idle_with_prefix(Duration::ZERO, &session),+ vec![session.clone()]+ );++ assert!(!ownership.is_driver_owned_pid(&session, pid));+ assert!(!ownership.is_driver_owned_pid(&owner, pid));+ assert_eq!(+ browser_resource_ownership(&engine, &args).await,+ ProtectedResourceOwnership::UserOwned+ );+ // Records the browser engine did not create stay for the registry.+ assert!(ownership.is_driver_owned_pid(&session, launched_app));+ crate::session::end_session(&session);+ }++ #[cfg(unix)]+ #[tokio::test]+ async fn a_reused_browser_pid_is_not_driver_owned() {+ let platform = Arc::new(MockPlatform {+ devtools: Some(std::net::TcpListener::bind("127.0.0.1:0").unwrap()),+ ..MockPlatform::default()+ });+ launching_engine();+ let engine = BrowserEngine::new(platform.clone());+ let (session, owner) = start_lifecycle_session(None);+ let prepared =+ prepare_isolated(&engine, &session, &owner, json!({ "mode": "isolated_new" })).await;+ let pid = prepared["prepared_pid"].as_i64().expect("prepared pid");+ let args = json!({ "session": session, "pid": pid });+ assert_eq!(+ browser_resource_ownership(&engine, &args).await,+ ProtectedResourceOwnership::DriverOwned+ );++ // The browser exits and the session's next launch_app gets its pid.+ platform+ .start_time+ .store(1, std::sync::atomic::Ordering::SeqCst);+ let reused = ProcessFingerprint {+ pid,+ start_time: Some(2),+ executable: None,+ };+ let ownership = engine.protected_resource_ownership.clone();+ ownership.mark_driver_owned_process(&session, reused.clone());+ assert_eq!(+ browser_resource_ownership(&engine, &args).await,+ ProtectedResourceOwnership::UserOwned+ );++ // Reaping the browser forgets only its own launch, not the app's.+ assert_eq!(+ crate::session::evict_idle_with_prefix(Duration::ZERO, &session),+ vec![session.clone()]+ );+ assert!(ownership.reprove_driver_owned_process(&session, &reused));+ crate::session::end_session(&session);+ }+#[tokio::test]async fn mutations_on_unknown_targets_refuse_binding_stale() {let e = engine();diff --git a/libs/cua-driver/rust/crates/cua-driver-core/src/consent.rs b/libs/cua-driver/rust/crates/cua-driver-core/src/consent.rsindex add8e9b28d..8f1976c74c 100644--- a/libs/cua-driver/rust/crates/cua-driver-core/src/consent.rs+++ b/libs/cua-driver/rust/crates/cua-driver-core/src/consent.rs@@ -343,6 +343,21 @@ impl ProtectedResourceOwnershipStore {matches}+ /// Forget one launched process instance. A later launch that reused its+ /// pid keeps its own record.+ pub fn remove_process(&self, session: &str, process: &crate::browser::ProcessFingerprint) {+ let mut sessions = self.processes_by_session.lock().unwrap();+ let Some(processes) = sessions.get_mut(session) else {+ return;+ };+ if processes.get(&process.pid) == Some(process) {+ processes.remove(&process.pid);+ }+ if processes.is_empty() {+ sessions.remove(session);+ }+ }+pub fn remove_session(&self, session: &str) {self.processes_by_session.lock().unwrap().remove(session);}diff --git a/libs/cua-driver/rust/crates/cua-driver-core/src/session.rs b/libs/cua-driver/rust/crates/cua-driver-core/src/session.rsindex 1a41f32fa0..8f8a6f202f 100644--- a/libs/cua-driver/rust/crates/cua-driver-core/src/session.rs+++ b/libs/cua-driver/rust/crates/cua-driver-core/src/session.rs@@ -55,6 +55,7 @@ struct RegisteredSessionEndHook {}struct SessionCleanupProgress {+ reason: SessionEndReason,hooks: Vec<(u64, RegisteredSessionEndHook)>,completed: HashSet<u64>,failures: Vec<SessionCleanupFailure>,@@ -475,17 +476,20 @@ fn begin_session_dispatch_inner(// insertion, leaving a tombstoned record that was silently recreated// by a racing first action.let mut ended = ended_sessions().lock().unwrap();- let mut idle_ended = idle_ended_implicit_sessions().lock().unwrap();+ let mut idle_ended = idle_ended_sessions().lock().unwrap();let recreated = ended.contains_key(session_id);if recreated&& !(recreate- && idle_ended.contains(session_id)+ && idle_ended.get(session_id) == Some(&IdleRevival::NextCall)&& ended.get(session_id).is_some_and(|owner| owner.as_deref() == Some(owner_transport))){return Err("session has ended");}+ if recreated && cleanup_pending(session_id) {+ return Err("session cleanup is incomplete; retry the call");+ }let mut records = lifecycle_records().lock().unwrap();let record = records.entry(session_id.to_owned())@@ -669,6 +673,9 @@ pub fn activate_or_revive_session_for_owner(Some(_) => true,None => false,};+ if revived && cleanup_pending(session_id) {+ return Err("session cleanup is incomplete; retry end_session before revival");+ }let mut records = lifecycle_records().lock().unwrap();if let Some(record) = records.get_mut(session_id) {@@ -696,10 +703,7 @@ pub fn activate_or_revive_session_for_owner(}if revived {ended.remove(session_id);- idle_ended_implicit_sessions()- .lock()- .unwrap()- .remove(session_id);+ idle_ended_sessions().lock().unwrap().remove(session_id);}revived};@@ -841,13 +845,14 @@ pub fn list_session_snapshots_with_prefix(}pub fn end_sessions_for_owner(owner_transport: &str, reason: SessionEndReason) -> usize {- let ids = lifecycle_records()+ let mut ids = lifecycle_records().lock().unwrap().iter().filter(|(_, record)| record.owner_transport == owner_transport).map(|(id, _)| id.clone()).collect::<Vec<_>>();+ ids.extend(dormant_sessions(|_, owner| owner == Some(owner_transport)));for id in &ids {end_session_with_reason(id, reason);}@@ -997,10 +1002,21 @@ fn capture_modality_for(tool_name: &str, args: &serde_json::Value) -> Option<Cap/// once. Growth is bounded (one short string per ended session over the/// daemon's lifetime); eviction is a deliberate non-blocking follow-up.static ENDED_SESSIONS: OnceLock<Mutex<HashMap<String, Option<String>>>> = OnceLock::new();-/// Tombstoned unnamed transport sessions whose episode ended only because the-/// idle sweep reclaimed it. Mutated only while holding the `ENDED_SESSIONS`-/// lock, and meaningful only while the matching tombstone exists.-static IDLE_ENDED_IMPLICIT_SESSIONS: OnceLock<Mutex<HashSet<String>>> = OnceLock::new();+/// Tombstoned sessions whose episode ended only because the idle sweep+/// reclaimed it. They are dormant: a later explicit, transport or revoke end+/// makes the end terminal and runs cleanup again with that reason. Mutated+/// only while holding the `ENDED_SESSIONS` lock, and meaningful only while the+/// matching tombstone exists.+static IDLE_ENDED_SESSIONS: OnceLock<Mutex<HashMap<String, IdleRevival>>> = OnceLock::new();++/// How a dormant session comes back.+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+enum IdleRevival {+ /// The transport's own unnamed session: its next call recreates it.+ NextCall,+ /// Only an explicit `start_session` by its owner revives it.+ StartSession,+}/// Runtime generations that have received terminal revoke-all.////// This latch is intentionally independent of grants and public session@@ -1024,8 +1040,28 @@ fn ended_sessions() -> &'static Mutex<HashMap<String, Option<String>>> {ENDED_SESSIONS.get_or_init(|| Mutex::new(HashMap::new()))}-fn idle_ended_implicit_sessions() -> &'static Mutex<HashSet<String>> {- IDLE_ENDED_IMPLICIT_SESSIONS.get_or_init(|| Mutex::new(HashSet::new()))+fn idle_ended_sessions() -> &'static Mutex<HashMap<String, IdleRevival>> {+ IDLE_ENDED_SESSIONS.get_or_init(|| Mutex::new(HashMap::new()))+}++/// Dormant session ids whose tombstone owner passes `keep`.+fn dormant_sessions(keep: impl Fn(&str, Option<&str>) -> bool) -> Vec<String> {+ let ended = ended_sessions().lock().unwrap();+ idle_ended_sessions()+ .lock()+ .unwrap()+ .keys()+ .filter(|id| keep(id, ended.get(*id).and_then(Option::as_deref)))+ .cloned()+ .collect()+}++/// Whether an ended session still has cleanup to run. Revival checks this+/// under the tombstone lock, so a terminal end that has started its cleanup+/// cannot be overtaken by a revival whose new launches that cleanup would+/// then erase.+fn cleanup_pending(session_id: &str) -> bool {+ cleanup_progress().lock().unwrap().contains_key(session_id)}fn suspended_runtime_scopes() -> &'static Mutex<HashSet<String>> {@@ -1217,7 +1253,7 @@ pub fn release_process_state_for_shutdown() {let mut ended = ended.lock().unwrap();ended.clear();ended.shrink_to_fit();- if let Some(idle_ended) = IDLE_ENDED_IMPLICIT_SESSIONS.get() {+ if let Some(idle_ended) = IDLE_ENDED_SESSIONS.get() {let mut idle_ended = idle_ended.lock().unwrap();idle_ended.clear();idle_ended.shrink_to_fit();@@ -1243,59 +1279,77 @@ pub fn fire_session_end(session_id: &str) -> bool {}fn fire_session_end_for_owner(session_id: &str, owner_transport: Option<&str>) -> bool {- let first_fire = mark_session_ended(session_id, owner_transport, SessionEndReason::Unknown);- if first_fire {- initialize_session_cleanup(session_id);- }+ let transition = mark_session_ended(session_id, owner_transport, SessionEndReason::Unknown);let _ = retry_session_cleanup(session_id);- first_fire+ transition == EndTransition::First}-/// Atomically remove a live lifecycle record and install its tombstone.+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+enum EndTransition {+ /// The episode's first end.+ First,+ /// A terminal end of a session the idle sweep had left dormant.+ TerminalAfterIdle,+ /// Already ended; nothing new to clean up.+ Repeat,+}++/// Atomically remove a live lifecycle record, install its tombstone, and+/// register the cleanup the transition needs.////// Hooks run after this short critical section. Keeping this transition under/// the same lock order as dispatch admission prevents a racing first action-/// from recreating a record immediately before or after termination.+/// from recreating a record immediately before or after termination, and a+/// revival from slipping in before the cleanup it would have to wait for.fn mark_session_ended(session_id: &str,owner_transport: Option<&str>,reason: SessionEndReason,-) -> bool {+) -> EndTransition {activity().lock().unwrap().remove(session_id);let mut ended = ended_sessions().lock().unwrap();let record = lifecycle_records().lock().unwrap().remove(session_id);- // Only the transport's own unnamed session, reclaimed for inactivity, is- // recreated on its next call. Named sessions and every other end reason- // keep the resurrection guard until an explicit start_session.- let idle_implicit = reason == SessionEndReason::IdleTimeout- && record- .as_ref()- .is_some_and(|record| record.implicit && record.owner_transport == session_id);- let mut idle_ended = idle_ended_implicit_sessions().lock().unwrap();- if ended.contains_key(session_id) {- // A later explicit or transport end makes an idle end terminal.- if reason != SessionEndReason::IdleTimeout {- idle_ended.remove(session_id);+ let mut idle_ended = idle_ended_sessions().lock().unwrap();+ let transition = if ended.contains_key(session_id) {+ if reason != SessionEndReason::IdleTimeout && idle_ended.remove(session_id).is_some() {+ EndTransition::TerminalAfterIdle+ } else {+ EndTransition::Repeat}- false} else {+ // Only the transport's own unnamed session, reclaimed for inactivity,+ // is recreated on its next call. Named sessions keep the resurrection+ // guard until an explicit start_session.+ let next_call = record+ .as_ref()+ .is_some_and(|record| record.implicit && record.owner_transport == session_id);ended.insert(session_id.to_owned(),owner_transport.map(str::to_owned).or(record.map(|record| record.owner_transport)),);- if idle_implicit {- idle_ended.insert(session_id.to_owned());+ if reason == SessionEndReason::IdleTimeout {+ let revival = if next_call {+ IdleRevival::NextCall+ } else {+ IdleRevival::StartSession+ };+ idle_ended.insert(session_id.to_owned(), revival);} else {idle_ended.remove(session_id);}- true+ EndTransition::First+ };+ if transition != EndTransition::Repeat {+ initialize_session_cleanup(session_id, reason);}+ transition}-fn initialize_session_cleanup(session_id: &str) {- crate::capture_scope::clear_session(session_id);+/// A terminal end after an idle end reruns every hook with its own reason.+/// An idle run still in flight keeps `running` and picks up the rerun.+fn initialize_session_cleanup(session_id: &str, reason: SessionEndReason) {let mut registered = hooks().lock().unwrap()@@ -1303,22 +1357,27 @@ fn initialize_session_cleanup(session_id: &str) {.map(|(id, hook)| (*id, hook.clone())).collect::<Vec<_>>();registered.sort_by_key(|(id, _)| *id);- cleanup_progress().lock().unwrap().insert(- session_id.to_owned(),- SessionCleanupProgress {- hooks: registered,+ let mut all = cleanup_progress().lock().unwrap();+ let progress = all+ .entry(session_id.to_owned())+ .or_insert_with(|| SessionCleanupProgress {+ reason,+ hooks: Vec::new(),completed: HashSet::new(),failures: Vec::new(),running: false,- },- );+ });+ progress.reason = reason;+ progress.hooks = registered;+ progress.completed.clear();+ progress.failures.clear();}/// Retry only the cleanup hooks that have not yet succeeded for this ended/// lifecycle episode. Panics are converted to structured failures so another/// explicit end can retry them instead of losing cleanup state.pub fn retry_session_cleanup(session_id: &str) -> SessionCleanupReport {- let work = {+ let (mut reason, mut work) = {let mut all = cleanup_progress().lock().unwrap();let Some(progress) = all.get_mut(session_id) else {return SessionCleanupReport {@@ -1335,33 +1394,52 @@ pub fn retry_session_cleanup(session_id: &str) -> SessionCleanupReport {};}progress.running = true;- progress- .hooks- .iter()- .filter(|(id, _)| !progress.completed.contains(id))- .cloned()- .collect::<Vec<_>>()+ (+ progress.reason,+ progress+ .hooks+ .iter()+ .filter(|(id, _)| !progress.completed.contains(id))+ .cloned()+ .collect::<Vec<_>>(),+ )};+ // Part of the tracked cleanup, so a revival waiting on it cannot have+ // its new capture policy cleared by this end.+ crate::capture_scope::clear_session(session_id);let mut successes = Vec::new();let mut failures = Vec::new();- for (id, hook) in work {- let result =- std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| (hook.callback)(session_id)));- match result {- Ok(Ok(())) => successes.push(id),- Ok(Err(error)) => failures.push(SessionCleanupFailure {- hook: hook.name,- error,- }),- Err(_) => failures.push(SessionCleanupFailure {- hook: hook.name,- error: "cleanup hook panicked".into(),- }),+ let mut all = loop {+ for (id, hook) in work {+ let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {+ (hook.callback)(session_id)+ }));+ match result {+ Ok(Ok(())) => successes.push(id),+ Ok(Err(error)) => failures.push(SessionCleanupFailure {+ hook: hook.name,+ error,+ }),+ Err(_) => failures.push(SessionCleanupFailure {+ hook: hook.name,+ error: "cleanup hook panicked".into(),+ }),+ }}- }-- let mut all = cleanup_progress().lock().unwrap();+ let all = cleanup_progress().lock().unwrap();+ match all.get(session_id) {+ // A terminal end arrived while these idle hooks ran: run its+ // hooks before anyone may revive the session.+ Some(progress) if progress.reason != reason => {+ reason = progress.reason;+ work = progress.hooks.clone();+ successes.clear();+ failures.clear();+ }+ _ => break all,+ }+ };let Some(progress) = all.get_mut(session_id) else {return SessionCleanupReport {complete: true,@@ -1384,6 +1462,17 @@ pub fn retry_session_cleanup(session_id: &str) -> SessionCleanupReport {}}+/// Why the session ended, while its cleanup hooks run or have unfinished+/// work. A hook reads this to keep state that outlives an idle end; a later+/// terminal end runs the hooks again with its own reason.+pub fn session_end_reason(session_id: &str) -> Option<SessionEndReason> {+ cleanup_progress()+ .lock()+ .unwrap()+ .get(session_id)+ .map(|progress| progress.reason)+}+/// Inspect cleanup progress without starting another attempt.////// Lifecycle tools use this after requesting an end so one public call runs@@ -1409,7 +1498,8 @@ pub fn session_cleanup_status(session_id: &str) -> SessionCleanupReport {/// a local operator control path without requiring an authorization grant:/// revocation can only remove authority, never create it.pub fn revoke_all_sessions() -> usize {- let sessions: Vec<String> = activity().lock().unwrap().keys().cloned().collect();+ let mut sessions: Vec<String> = activity().lock().unwrap().keys().cloned().collect();+ sessions.extend(dormant_sessions(|_, _| true));for session in &sessions {end_session(session);}@@ -1418,13 +1508,14 @@ pub fn revoke_all_sessions() -> usize {/// Revoke only sessions owned by one runtime-private namespace.pub fn revoke_sessions_with_prefix(prefix: &str) -> usize {- let sessions: Vec<String> = activity()+ let mut sessions: Vec<String> = activity().lock().unwrap().keys().filter(|session| session.starts_with(prefix)).cloned().collect();+ sessions.extend(dormant_sessions(|session, _| session.starts_with(prefix)));for session in &sessions {end_session(session);}@@ -1440,10 +1531,10 @@ pub fn forget_ended_sessions_with_prefix(prefix: &str) -> usize {let before = ended.len();ended.retain(|session, _| !session.starts_with(prefix));let forgotten = before - ended.len();- idle_ended_implicit_sessions()+ idle_ended_sessions().lock().unwrap()- .retain(|session| !session.starts_with(prefix));+ .retain(|session, _| !session.starts_with(prefix));drop(ended);cleanup_progress().lock()@@ -1472,10 +1563,7 @@ pub fn recreates_on_next_call(session_id: &str, owner_transport: &str) -> bool {ended.get(session_id).is_some_and(|owner| owner.as_deref() == Some(owner_transport))- && idle_ended_implicit_sessions()- .lock()- .unwrap()- .contains(session_id)+ && idle_ended_sessions().lock().unwrap().get(session_id) == Some(&IdleRevival::NextCall)}/// Whether termination has been requested for a runtime-private lifecycle.@@ -1514,10 +1602,10 @@ pub fn revive_session(session_id: &str) -> bool {return false;}let mut ended = ended_sessions().lock().unwrap();- idle_ended_implicit_sessions()- .lock()- .unwrap()- .remove(session_id);+ if cleanup_pending(session_id) {+ return false;+ }+ idle_ended_sessions().lock().unwrap().remove(session_id);ended.remove(session_id).is_some()}@@ -1570,12 +1658,12 @@ pub fn revive_session_for_owner(Err("session is not available to this transport")}None if owner_transport != session_id => Err("session is not available to this transport"),+ _ if cleanup_pending(session_id) => {+ Err("session cleanup is incomplete; retry end_session before revival")+ }_ => {ended.remove(session_id);- idle_ended_implicit_sessions()- .lock()- .unwrap()- .remove(session_id);+ idle_ended_sessions().lock().unwrap().remove(session_id);Ok(true)}}@@ -1627,7 +1715,12 @@ fn end_session_with_reason(session_id: &str, reason: SessionEndReason) {let mut records = lifecycle_records().lock().unwrap();match records.get_mut(session_id) {Some(record) if record.in_flight > 0 => {- record.pending_end.get_or_insert(reason);+ // A terminal end overrides a pending idle end, which would+ // keep the session's launch records.+ let pending = record.pending_end.get_or_insert(reason);+ if *pending == SessionEndReason::IdleTimeout {+ *pending = reason;+ }true}_ => false,@@ -1640,7 +1733,8 @@ fn end_session_with_reason(session_id: &str, reason: SessionEndReason) {}fn finish_session_end(session_id: &str, reason: SessionEndReason) {- let first_fire = mark_session_ended(session_id, None, reason);+ let transition = mark_session_ended(session_id, None, reason);+ let first_fire = transition == EndTransition::First;let mut cursor_readers = CURSOR_OUTCOME_READERS.get().map(|readers| {@@ -1664,9 +1758,6 @@ fn finish_session_end(session_id: &str, reason: SessionEndReason) {}});let cursor = cursor.or(fallback);- if first_fire {- initialize_session_cleanup(session_id);- }let _ = retry_session_cleanup(session_id);if first_fire {if let Some(observer) = SESSION_OBSERVER.get() {@@ -2334,6 +2425,148 @@ mod tests {assert!(!is_session_ended(&sid));}+ #[test]+ fn a_terminal_end_during_idle_cleanup_blocks_revival_until_its_hooks_ran() {+ let sid = "__cua_runtime_idle-then-terminal:named";+ let owner = "idle-then-terminal-owner";+ activate_session(+ sid,+ Some("named"),+ owner,+ false,+ SessionTransport::Daemon,+ SessionClientKind::Cli,+ )+ .unwrap();+ let (entered_tx, entered_rx) = std::sync::mpsc::channel();+ let (release_tx, release_rx) = std::sync::mpsc::channel::<()>();+ let release_rx = Mutex::new(release_rx);+ let reasons = Arc::new(Mutex::new(Vec::new()));+ let seen = reasons.clone();+ let _hook = register_scoped_session_end_hook(move |id| {+ if id != sid {+ return;+ }+ let reason = session_end_reason(id);+ seen.lock().unwrap().push(reason);+ if reason == Some(SessionEndReason::IdleTimeout) {+ entered_tx.send(()).unwrap();+ release_rx.lock().unwrap().recv().unwrap();+ }+ });++ let idle = std::thread::spawn(|| evict_idle_with_prefix(Duration::ZERO, sid));+ entered_rx.recv().unwrap();+ end_session(sid);+ assert!(+ activate_or_revive_session_for_owner(+ sid,+ Some("named"),+ owner,+ false,+ SessionTransport::Daemon,+ SessionClientKind::Cli,+ None,+ )+ .is_err(),+ "revival must wait for the terminal end's hooks"+ );++ release_tx.send(()).unwrap();+ assert_eq!(idle.join().unwrap(), vec![sid.to_owned()]);+ assert_eq!(+ *reasons.lock().unwrap(),+ [+ Some(SessionEndReason::IdleTimeout),+ Some(SessionEndReason::Explicit)+ ]+ );+ assert_eq!(+ activate_or_revive_session_for_owner(+ sid,+ Some("named"),+ owner,+ false,+ SessionTransport::Daemon,+ SessionClientKind::Cli,+ None,+ ),+ Ok(true)+ );+ end_session(sid);+ }++ #[test]+ fn a_revival_during_a_slow_end_keeps_its_capture_policy() {+ let sid = "__cua_runtime_slow-end:named";+ let owner = "slow-end-owner";+ let start = || {+ activate_or_revive_session_for_owner(+ sid,+ Some("named"),+ owner,+ false,+ SessionTransport::Daemon,+ SessionClientKind::Cli,+ None,+ )+ };+ start().unwrap();+ let (entered_tx, entered_rx) = std::sync::mpsc::channel();+ let (release_tx, release_rx) = std::sync::mpsc::channel::<()>();+ let release_rx = Mutex::new(release_rx);+ let reader = register_scoped_cursor_outcome_reader(Arc::new(move |id| {+ if id == sid {+ entered_tx.send(()).unwrap();+ release_rx.lock().unwrap().recv().unwrap();+ }+ bounded_cursor_outcome(false, false, false, None, false, 0)+ }));++ let end = std::thread::spawn(|| end_session(sid));+ entered_rx.recv().unwrap();+ // The end is waiting on a cursor reader; a revival in that window+ // runs the cleanup itself and then binds its new policy.+ assert_eq!(start(), Ok(true));+ crate::capture_scope::bind_session(sid, Some(CaptureScope::Desktop)).unwrap();+ release_tx.send(()).unwrap();+ end.join().unwrap();++ assert!(crate::capture_scope::get_session(sid).is_some());+ drop(reader);+ end_session(sid);+ }++ #[test]+ fn a_terminal_end_overrides_an_idle_end_deferred_behind_a_dispatch() {+ let sid = "__cua_runtime_deferred-idle:named";+ let owner = "deferred-idle-owner";+ let guard = begin_session_dispatch(+ sid,+ Some("named"),+ owner,+ false,+ SessionTransport::Daemon,+ SessionClientKind::Cli,+ )+ .unwrap();+ let reasons = Arc::new(Mutex::new(Vec::new()));+ let seen = reasons.clone();+ let _hook = register_scoped_session_end_hook(move |id| {+ if id == sid {+ seen.lock().unwrap().push(session_end_reason(id));+ }+ });++ end_session_with_reason(sid, SessionEndReason::IdleTimeout);+ end_session(sid);+ drop(guard);++ assert_eq!(*reasons.lock().unwrap(), [Some(SessionEndReason::Explicit)]);+ assert!(is_session_ended(sid));+ assert!(revive_session_for_owner(sid, owner).is_ok());+ }+#[test]fn revive_is_noop_for_anonymous_ids() {// The anonymous fallback is never tracked, so there is nothing to revive.diff --git a/libs/cua-driver/rust/crates/cua-driver-core/src/tool.rs b/libs/cua-driver/rust/crates/cua-driver-core/src/tool.rsindex 6459fb775b..f4916b3db9 100644--- a/libs/cua-driver/rust/crates/cua-driver-core/src/tool.rs+++ b/libs/cua-driver/rust/crates/cua-driver-core/src/tool.rs@@ -1356,7 +1356,13 @@ impl ToolRegistry {let session_end_hook =crate::session::register_scoped_session_end_hook(move |session_id| {crate::agent_cursor::forget_input_origin(session_id);- if let Some(ownership) = weak_ownership.upgrade() {+ // An idle sweep only pauses a session: the same label can be+ // started again and still owns what it launched. A later+ // terminal end reruns this hook and drops it.+ if let Some(ownership) = weak_ownership.upgrade().filter(|_| {+ crate::session::session_end_reason(session_id)+ != Some(crate::session::SessionEndReason::IdleTimeout)+ }) {ownership.remove_session(session_id);}if let Some(captures) = weak_captures.upgrade() {@@ -5830,6 +5836,208 @@ resources:assert_eq!(hits.load(Ordering::SeqCst), 1);}+ #[tokio::test]+ async fn an_idle_ended_session_keeps_its_launches_for_its_own_label_only() {+ let hits = Arc::new(AtomicUsize::new(0));+ let mut registry = attested_registry("kill_app", None, hits.clone(), false);+ let tools = Arc::get_mut(&mut registry).unwrap();+ tools.register(Box::new(crate::session_tools::StartSessionTool));+ tools.register(Box::new(crate::session_tools::EndSessionTool));+ let context = standard_context();+ let prefix = format!("__cua_runtime_{}:", context.runtime_scope_key());+ let call = |name: &'static str, session: &'static str| {+ let registry = registry.clone();+ let context = context.clone();+ async move {+ registry+ .invoke_with_context(+ name,+ serde_json::json!({"pid": 424242, "session": session}),+ context,+ )+ .await+ }+ };+ let refusal_code = |result: &ToolResult| {+ result+ .structured_content+ .as_ref()+ .and_then(|value| value.pointer("/refusal/code"))+ .and_then(serde_json::Value::as_str)+ .map(str::to_owned)+ };+ let launched = || {+ registry+ .protected_resource_ownership()+ .mark_driver_owned_process(+ &context.runtime_session_key("run"),+ crate::browser::ProcessFingerprint {+ pid: 424242,+ start_time: Some(7),+ executable: Some(fixture_executable()),+ },+ );+ };++ // launch_app under "run", then the run idles past the sweep and the+ // client starts "run" again.+ assert_ne!(call("start_session", "run").await.is_error, Some(true));+ launched();+ assert_eq!(+ crate::session::evict_idle_with_prefix(Duration::ZERO, &prefix).len(),+ 1+ );+ assert_ne!(call("start_session", "run").await.is_error, Some(true));++ // Another session still cannot kill the process.+ assert_ne!(call("start_session", "other").await.is_error, Some(true));+ assert_eq!(+ refusal_code(&call("kill_app", "other").await).as_deref(),+ Some("foreign_process_termination_denied")+ );+ assert_eq!(hits.load(Ordering::SeqCst), 0);++ let killed = call("kill_app", "run").await;+ assert_ne!(killed.is_error, Some(true), "{killed:?}");+ assert_eq!(hits.load(Ordering::SeqCst), 1);++ // Every terminal end drops the launch records, whether the session+ // was live or had already idled out: end_session, transport+ // teardown, and revocation.+ let run = context.runtime_session_key("run");+ for terminal in ["end_session", "transport", "revoke"] {+ for idle_first in [false, true] {+ launched();+ if idle_first {+ crate::session::evict_idle_with_prefix(Duration::ZERO, &prefix);+ }+ match terminal {+ "end_session" => {+ assert_ne!(call("end_session", "run").await.is_error, Some(true));+ }+ "transport" => {+ assert_eq!(+ crate::session::end_sessions_for_owner(+ &run,+ crate::session::SessionEndReason::ProcessExit+ ),+ 1+ );+ }+ _ => {+ assert!(crate::session::revoke_sessions_with_prefix(&prefix) >= 1);+ }+ }+ assert!(+ !registry+ .protected_resource_ownership()+ .is_driver_owned_pid(&run, 424242),+ "{terminal} idle_first={idle_first}"+ );+ assert_ne!(call("start_session", "run").await.is_error, Some(true));+ assert_eq!(+ refusal_code(&call("kill_app", "run").await).as_deref(),+ Some("foreign_process_termination_denied"),+ "{terminal} idle_first={idle_first}"+ );+ }+ }+ assert_eq!(hits.load(Ordering::SeqCst), 1);++ crate::session::revoke_sessions_with_prefix(&prefix);+ crate::session::forget_ended_sessions_with_prefix(&prefix);+ }++ #[tokio::test]+ async fn ending_an_idled_session_keeps_the_launches_of_its_next_episode() {+ let hits = Arc::new(AtomicUsize::new(0));+ let mut registry = attested_registry("kill_app", None, hits.clone(), false);+ let tools = Arc::get_mut(&mut registry).unwrap();+ tools.register(Box::new(crate::session_tools::StartSessionTool));+ tools.register(Box::new(crate::session_tools::EndSessionTool));+ let context = standard_context();+ let prefix = format!("__cua_runtime_{}:", context.runtime_scope_key());+ let run = context.runtime_session_key("revived");+ let call = |name: &'static str| {+ let registry = registry.clone();+ let context = context.clone();+ async move {+ registry+ .invoke_with_context(+ name,+ serde_json::json!({"pid": 424242, "session": "revived"}),+ context,+ )+ .await+ }+ };+ let fingerprint = crate::browser::ProcessFingerprint {+ pid: 424242,+ start_time: Some(7),+ executable: Some(fixture_executable()),+ };+ assert_ne!(call("start_session").await.is_error, Some(true));+ registry+ .protected_resource_ownership()+ .mark_driver_owned_process(&run, fingerprint.clone());+ crate::session::evict_idle_with_prefix(Duration::ZERO, &prefix);++ // A revival racing the explicit end lands while its cleanup runs and+ // records a launch for the next episode if it is admitted.+ let ownership = Arc::downgrade(®istry.protected_resource_ownership());+ let observed = run.clone();+ let raced = Arc::new(std::sync::Mutex::new(None));+ let raced_in_hook = raced.clone();+ let _race = crate::session::register_scoped_session_end_hook(move |ended| {+ if ended != observed+ || crate::session::session_end_reason(ended)+ == Some(crate::session::SessionEndReason::IdleTimeout)+ {+ return;+ }+ let revived = crate::session::activate_or_revive_session_for_owner(+ ended,+ Some("revived"),+ ended,+ false,+ crate::session::SessionTransport::Daemon,+ crate::session::SessionClientKind::Cli,+ None,+ );+ if revived.is_ok() {+ if let Some(ownership) = ownership.upgrade() {+ ownership.mark_driver_owned_process(ended, fingerprint.clone());+ }+ }+ raced_in_hook.lock().unwrap().replace(revived.is_ok());+ });+ assert_ne!(call("end_session").await.is_error, Some(true));+ assert_eq!(+ *raced.lock().unwrap(),+ Some(false),+ "the end ran its cleanup and refused the revival meanwhile"+ );++ // The next episode starts after cleanup, and its launch stays.+ assert_ne!(call("start_session").await.is_error, Some(true));+ registry+ .protected_resource_ownership()+ .mark_driver_owned_process(+ &run,+ crate::browser::ProcessFingerprint {+ pid: 424242,+ start_time: Some(7),+ executable: Some(fixture_executable()),+ },+ );+ let killed = call("kill_app").await;+ assert_ne!(killed.is_error, Some(true), "{killed:?}");+ assert_eq!(hits.load(Ordering::SeqCst), 1);++ crate::session::revoke_sessions_with_prefix(&prefix);+ crate::session::forget_ended_sessions_with_prefix(&prefix);+ }+#[tokio::test]async fn standard_sessionless_foreign_process_termination_still_denies() {let hits = Arc::new(AtomicUsize::new(0));