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(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.rs
index 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.rs
index 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.rs
index 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(&current))
}
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.rs
index 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.rs
index 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.rs
index 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.rs
index 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(&registry.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));