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): hold every tool route on runtime admission while permissions are pending (#6802)
injaneity62806db62d18
diff --git a/libs/cua-driver/rust/crates/cua-driver-sdk/src/abi.rs b/libs/cua-driver/rust/crates/cua-driver-sdk/src/abi.rsindex 999b5aad60..0ae0d8de10 100644--- a/libs/cua-driver/rust/crates/cua-driver-sdk/src/abi.rs+++ b/libs/cua-driver/rust/crates/cua-driver-sdk/src/abi.rs@@ -1325,6 +1325,24 @@ impl NativeAbiDriver {}}+ pub(crate) fn set_awaiting_permissions(&self, awaiting: bool) {+ unsafe {+ if let Some(handle) = self.raw_handle().cast::<CuaDriverHandle>().as_ref() {+ handle.runtime.set_awaiting_permissions(awaiting);+ }+ }+ }++ pub(crate) fn permissions_pending_result(&self) -> Option<Value> {+ let refusal = unsafe {+ self.raw_handle()+ .cast::<CuaDriverHandle>()+ .as_ref()+ .and_then(|handle| handle.runtime.permissions_pending_refusal())+ }?;+ serde_json::to_value(refusal).ok()+ }+pub(crate) fn is_available(&self) -> bool {let mut available = false;let mut error = CuaDriverBuffer::empty();diff --git a/libs/cua-driver/rust/crates/cua-driver-sdk/src/lib.rs b/libs/cua-driver/rust/crates/cua-driver-sdk/src/lib.rsindex f7440ec7fd..58e473d1a9 100644--- a/libs/cua-driver/rust/crates/cua-driver-sdk/src/lib.rs+++ b/libs/cua-driver/rust/crates/cua-driver-sdk/src/lib.rs@@ -328,6 +328,26 @@ impl CuaDriver {}}+ /// Daemon-host seam for its permission gate: while awaiting, every tool+ /// route refuses with `permissions_pending` before dispatch. Only an+ /// embedded runtime has a gate; other backends ignore it.+ #[doc(hidden)]+ pub fn set_awaiting_permissions(&self, awaiting: bool) {+ if let DriverBackend::Embedded(runtime) = &self.backend {+ runtime.set_awaiting_permissions(awaiting);+ }+ }++ /// The raw `permissions_pending` tool result while the permission gate is+ /// pending, so a host transport can answer it before its own refusals.+ #[doc(hidden)]+ pub fn permissions_pending_result(&self) -> Option<Value> {+ match &self.backend {+ DriverBackend::Embedded(runtime) => runtime.permissions_pending_result(),+ _ => None,+ }+ }+/// Trusted Rust-host access to the daemon-owned local history controller./// This is intentionally absent from UniFFI and public agent protocols.#[doc(hidden)]diff --git a/libs/cua-driver/rust/crates/cua-driver-sdk/src/runtime.rs b/libs/cua-driver/rust/crates/cua-driver-sdk/src/runtime.rsindex 540ae0d6e0..24b54b46ac 100644--- a/libs/cua-driver/rust/crates/cua-driver-sdk/src/runtime.rs+++ b/libs/cua-driver/rust/crates/cua-driver-sdk/src/runtime.rs@@ -23,7 +23,7 @@ use cua_driver_core::{use cursor_overlay::CursorConfig;use serde_json::Value;use std::sync::{- atomic::{AtomicBool, AtomicU64, Ordering},+ atomic::{AtomicU64, AtomicU8, Ordering},Arc, Mutex,};@@ -117,6 +117,9 @@ pub(crate) struct RuntimeSession {impl RuntimeSession {pub(crate) async fn invoke(&self, name: &str, mut args: Value) -> Option<CoreToolResult> {+ if let Some(refusal) = self.runtime.permissions_pending_refusal() {+ return Some(refusal);+ }cua_driver_core::tool_args::sanitize_reserved_args(&mut args);let Some(arguments) = args.as_object_mut() else {return Some(permission_denied_result(@@ -161,11 +164,34 @@ impl Drop for RuntimeSession {}}+/// Whether the runtime accepts tool calls. `Closed` is terminal.+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+#[repr(u8)]+enum Admission {+ Open = 0,+ /// The host's permission gate has not confirmed its grants yet. Inventory+ /// and lifecycle diagnostics stay reachable; no tool runs.+ AwaitingPermissions = 1,+ Closed = 2,+}++impl Admission {+ fn from_u8(value: u8) -> Self {+ match value {+ 0 => Self::Open,+ 1 => Self::AwaitingPermissions,+ _ => Self::Closed,+ }+ }+}++const PERMISSIONS_PENDING: &str = "permissions_pending: macOS Accessibility or Screen Recording permission is still pending; no action started, retry after the permission gate completes";+pub(crate) struct DriverRuntime {registry: Arc<ToolRegistry>,authorization_registry: Arc<SessionAuthorizationRegistry>,compatibility_context: Arc<EffectiveAuthorizationContext>,- shutdown: AtomicBool,+ admission: AtomicU8,last_activity: AtomicU64,/// Calls hold a read guard; shutdown takes the write guard after closing/// admission. Therefore shutdown is idempotent and does not return while a@@ -210,7 +236,7 @@ impl DriverRuntime {registry,authorization_registry,compatibility_context,- shutdown: AtomicBool::new(false),+ admission: AtomicU8::new(Admission::Open as u8),last_activity: AtomicU64::new(now_unix_secs()),lifecycle: tokio::sync::RwLock::new(()),lifecycle_maintenance: Mutex::new(None),@@ -221,8 +247,35 @@ impl DriverRuntime {Ok(runtime)}+ fn admission(&self) -> Admission {+ Admission::from_u8(self.admission.load(Ordering::Acquire))+ }+pub(crate) fn is_running(&self) -> bool {- !self.shutdown.load(Ordering::Acquire)+ self.admission() != Admission::Closed+ }++ /// Hold or release tool calls for the host's permission gate. A closed+ /// runtime stays closed.+ pub(crate) fn set_awaiting_permissions(&self, awaiting: bool) {+ let (from, to) = if awaiting {+ (Admission::Open, Admission::AwaitingPermissions)+ } else {+ (Admission::AwaitingPermissions, Admission::Open)+ };+ let _ = self.admission.compare_exchange(+ from as u8,+ to as u8,+ Ordering::AcqRel,+ Ordering::Acquire,+ );+ }++ /// The refusal every tool call gets while the permission gate is pending.+ /// It answers before any other refusal.+ pub(crate) fn permissions_pending_refusal(&self) -> Option<CoreToolResult> {+ (self.admission() == Admission::AwaitingPermissions)+ .then(|| refusal_result("permissions_pending", PERMISSIONS_PENDING.to_owned()))}pub(crate) fn runtime_scope_key(&self) -> String {@@ -230,7 +283,8 @@ impl DriverRuntime {}pub(crate) async fn shutdown(&self) {- self.shutdown.store(true, Ordering::Release);+ self.admission+ .store(Admission::Closed as u8, Ordering::Release);let _drained = self.lifecycle.write().await;self.stop_lifecycle_maintenance();self.authorization_registry.revoke_all();@@ -314,6 +368,9 @@ impl DriverRuntime {context: Arc<EffectiveAuthorizationContext>,evidence: cua_driver_core::tool::TrustedInvocationEvidence,) -> Option<CoreToolResult> {+ if let Some(refusal) = self.permissions_pending_refusal() {+ return Some(refusal);+ }if !self.is_running() {return None;}@@ -462,7 +519,10 @@ fn activity_lifecycle_event(impl Drop for DriverRuntime {fn drop(&mut self) {- let was_running = !self.shutdown.swap(true, Ordering::AcqRel);+ let was_running = self+ .admission+ .swap(Admission::Closed as u8, Ordering::AcqRel)+ != Admission::Closed as u8;self.stop_lifecycle_maintenance();self.authorization_registry.revoke_all();let runtime_scope = self.compatibility_context.runtime_scope_key();@@ -482,10 +542,14 @@ impl Drop for DriverRuntime {}fn permission_denied_result(message: String) -> CoreToolResult {+ refusal_result("permission_denied", message)+}++fn refusal_result(code: &str, message: String) -> CoreToolResult {CoreToolResult::error(message.clone()).with_structured(serde_json::json!({"status": "refused","refusal": {- "code": "permission_denied",+ "code": code,"message": message,}}))@@ -924,6 +988,34 @@ mod tests {runtime.shutdown().await;}+ #[tokio::test]+ async fn awaiting_permissions_refuses_before_dispatch_and_never_reopens_a_closed_runtime() {+ let _runtime_test = TEST_RUNTIME_LOCK.lock().await;+ let runtime = DriverRuntime::create(standard_options()).unwrap();+ runtime.set_awaiting_permissions(true);+ let pending = runtime+ .invoke("get_config", serde_json::json!({}))+ .await+ .expect("an awaiting runtime answers");+ assert_eq!(+ pending+ .structured_content+ .as_ref()+ .and_then(|value| value.pointer("/refusal/code")),+ Some(&serde_json::json!("permissions_pending"))+ );+ assert!(runtime.is_running(), "awaiting is not closed");+ assert!(runtime.tools_list().is_some(), "inventory stays reachable");++ runtime.shutdown().await;+ runtime.set_awaiting_permissions(false);+ assert!(!runtime.is_running());+ assert!(runtime+ .invoke("get_config", serde_json::json!({}))+ .await+ .is_none());+ }+#[tokio::test]async fn shutdown_stops_lifecycle_maintenance() {let _runtime_test = TEST_RUNTIME_LOCK.lock().await;diff --git a/libs/cua-driver/rust/crates/cua-driver/src/main.rs b/libs/cua-driver/rust/crates/cua-driver/src/main.rsindex e2ac8e00a7..9878ec816c 100644--- a/libs/cua-driver/rust/crates/cua-driver/src/main.rs+++ b/libs/cua-driver/rust/crates/cua-driver/src/main.rs@@ -371,6 +371,61 @@ fn inspect_tools_without_runtime() -> serde_json::Value {})}+/// A cua-driver host whose `get_screen_size` is a counting probe, so a test+/// can prove whether a route reached tool execution. The name is one the+/// typed envelope route admits.+#[cfg(test)]+async fn probe_sdk() -> (+ Arc<cua_driver_sdk::CuaDriver>,+ Arc<sdk_adapter::SdkAdapter>,+ &'static std::sync::atomic::AtomicUsize,+) {+ use std::sync::atomic::{AtomicUsize, Ordering};+ static CALLS: AtomicUsize = AtomicUsize::new(0);+ struct Probe(cua_driver_core::tool::ToolDef);+ #[async_trait::async_trait]+ impl cua_driver_core::tool::Tool for Probe {+ fn def(&self) -> &cua_driver_core::tool::ToolDef {+ &self.0+ }+ async fn invoke(&self, _: serde_json::Value) -> cua_driver_core::protocol::ToolResult {+ CALLS.fetch_add(1, Ordering::SeqCst);+ cua_driver_core::protocol::ToolResult::text("probe ran")+ }+ }+ fn register(registry: &mut cua_driver_core::tool::ToolRegistry) {+ registry.register(Box::new(Probe(cua_driver_core::tool::ToolDef {+ name: "get_screen_size".into(),+ description: "test probe".into(),+ input_schema: serde_json::json!({"type": "object"}),+ read_only: true,+ destructive: false,+ idempotent: true,+ open_world: false,+ })));+ }+ CALLS.store(0, Ordering::SeqCst);+ let driver =+ cua_driver_sdk::CuaDriver::try_create_service_for_host(cua_driver_sdk::DriverHostOptions {+ cursor: cursor_overlay::CursorConfig {+ enabled: false,+ ..cursor_overlay::CursorConfig::default()+ },+ host_owns_permission_ux: false,+ host_bundle_id: None,+ claude_code_compatibility: false,+ prepare_desktop_environment: false,+ register_host_tools: Some(register),+ authorization_host: None,+ activity_observer: None,+ })+ .expect("probe host runtime");+ let sdk = sdk_adapter::SdkAdapter::load(driver.clone())+ .await+ .expect("SDK adapter");+ (driver, sdk, &CALLS)+}+#[cfg(test)]fn test_runtime_lock() -> &'static tokio::sync::Mutex<()> {static LOCK: std::sync::OnceLock<tokio::sync::Mutex<()>> = std::sync::OnceLock::new();@@ -634,10 +689,6 @@ fn main() {);}}- // Fail closed until a fresh helper-process probe completes. This- // also covers a probe launch failure without letting the serving- // process perform and cache its own negative TCC preflight.- serve::set_permission_gate_pending(!gate_opts.opt_out);telemetry::capture_start(telemetry::event::SERVE_START_LEGACY,telemetry::Transport::Daemon,@@ -675,6 +726,12 @@ fn main() {std::process::exit(1);}};+ // Fail closed until a fresh helper-process probe completes. This+ // also covers a probe launch failure without letting the serving+ // process perform and cache its own negative TCC preflight. Set+ // before the serve thread binds the socket.+ serve::set_permission_gate_pending(&driver, !gate_opts.opt_out);+ let gate_driver = driver.clone();let sp = socket.unwrap_or_else(serve::default_socket_path);let pid_path = pid_file.unwrap_or_else(serve::default_pid_file_path);@@ -731,7 +788,7 @@ fn main() {}},);- serve::settle_permission_gate(gate_result.is_ok(), move || {+ serve::settle_permission_gate(gate_driver, gate_result.is_ok(), move || {platform_macos::permissions::gate::wait_for_grants(&slow_opts)});let gate_context = platform_macos::permissions::gate::telemetry_context();diff --git a/libs/cua-driver/rust/crates/cua-driver/src/mcp_envelope.rs b/libs/cua-driver/rust/crates/cua-driver/src/mcp_envelope.rsindex 1169f8d1fc..10c1d8d8f7 100644--- a/libs/cua-driver/rust/crates/cua-driver/src/mcp_envelope.rs+++ b/libs/cua-driver/rust/crates/cua-driver/src/mcp_envelope.rs@@ -710,6 +710,58 @@ mod tests {sdk.shutdown().await.unwrap();}+ #[tokio::test]+ async fn envelope_legacy_and_typed_calls_wait_for_the_permission_gate() {+ let _guard = crate::test_runtime_lock().lock().await;+ let (driver, sdk, calls) = crate::probe_sdk().await;+ let service = Service::for_sdk(sdk.clone()).unwrap();+ let (mut client, task) = start(sdk.clone(), service);+ let mut binding = client.open().await;+ let legacy = json!({"name": "get_screen_size", "arguments": {}});+ let typed = |id: &str| {+ let mut envelope = envelope(id);+ envelope["operation"] = json!("call");+ envelope["name"] = json!("get_screen_size");+ envelope+ };++ driver.set_awaiting_permissions(true);+ client.send(2, "tools/call", legacy.clone()).await;+ let pending = client.receive().await;+ assert_eq!(+ pending["result"]["structuredContent"]["refusal"]["code"], "permissions_pending",+ "{pending}"+ );+ binding["envelope"] = typed("typed-pending");+ client+ .send(3, &format!("{PREFIX}exchange"), binding.clone())+ .await;+ let pending = client.receive().await;+ assert_eq!(+ pending["result"]["result"]["structuredContent"]["refusal"]["code"],+ "permissions_pending",+ "{pending}"+ );+ assert_eq!(+ calls.load(Ordering::SeqCst),+ 0,+ "no tool may run while pending"+ );++ driver.set_awaiting_permissions(false);+ client.send(4, "tools/call", legacy).await;+ client.receive().await;+ binding["envelope"] = typed("typed-open");+ client.send(5, &format!("{PREFIX}exchange"), binding).await;+ let open = client.receive().await;+ assert_eq!(open["result"]["ok"], true, "{open}");+ assert_eq!(calls.load(Ordering::SeqCst), 2);++ client.write.shutdown().await.unwrap();+ task.await.unwrap().unwrap();+ sdk.shutdown().await.unwrap();+ }+#[tokio::test]async fn requests_before_initialize_are_refused_without_dispatch() {let _guard = crate::test_runtime_lock().lock().await;diff --git a/libs/cua-driver/rust/crates/cua-driver/src/mcp_http.rs b/libs/cua-driver/rust/crates/cua-driver/src/mcp_http.rsindex cdc2ff0345..f0e8d4539f 100644--- a/libs/cua-driver/rust/crates/cua-driver/src/mcp_http.rs+++ b/libs/cua-driver/rust/crates/cua-driver/src/mcp_http.rs@@ -892,6 +892,33 @@ mod tests {sdk.shutdown().await.expect("SDK shutdown");}+ #[tokio::test]+ async fn http_tool_call_waits_for_the_permission_gate() {+ let _runtime_guard = crate::test_runtime_lock().lock().await;+ let (driver, sdk, calls) = crate::probe_sdk().await;+ let call = || {+ dispatch(+ br#"{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_screen_size","arguments":{}}}"#,+ &sdk,+ "http-pending",+ )+ };++ driver.set_awaiting_permissions(true);+ let pending: serde_json::Value =+ serde_json::from_str(&call().await.expect("JSON-RPC response")).unwrap();+ assert_eq!(+ pending["result"]["structuredContent"]["refusal"]["code"], "permissions_pending",+ "{pending}"+ );+ assert_eq!(calls.load(std::sync::atomic::Ordering::SeqCst), 0);++ driver.set_awaiting_permissions(false);+ call().await.expect("JSON-RPC response");+ assert_eq!(calls.load(std::sync::atomic::Ordering::SeqCst), 1);+ sdk.shutdown().await.expect("SDK shutdown");+ }+#[tokio::test]async fn invalid_bearer_receives_401_before_json_rpc_dispatch() {let _runtime_guard = crate::test_runtime_lock().lock().await;diff --git a/libs/cua-driver/rust/crates/cua-driver/src/sdk_adapter.rs b/libs/cua-driver/rust/crates/cua-driver/src/sdk_adapter.rsindex 9ee25784d3..3509e218c0 100644--- a/libs/cua-driver/rust/crates/cua-driver/src/sdk_adapter.rs+++ b/libs/cua-driver/rust/crates/cua-driver/src/sdk_adapter.rs@@ -154,6 +154,10 @@ impl SdkAdapter {self.driver.local_history_manager()}+ pub fn permissions_pending_result(&self) -> Option<Value> {+ self.driver.permissions_pending_result()+ }+pub fn is_known_tool(&self, name: &str) -> bool {cua_driver_core::tool::renamed_tool(name).is_some()|| self.driver.local_is_known_tool(name).unwrap_or(false)diff --git a/libs/cua-driver/rust/crates/cua-driver/src/serve.rs b/libs/cua-driver/rust/crates/cua-driver/src/serve.rsindex b91940fbef..b1937adc33 100644--- a/libs/cua-driver/rust/crates/cua-driver/src/serve.rs+++ b/libs/cua-driver/rust/crates/cua-driver/src/serve.rs@@ -429,8 +429,8 @@ async fn invoke_daemon_tool(sdk: &std::sync::Arc<crate::sdk_adapter::SdkAdapter>,req: DaemonRequest,) -> DaemonResponse {- if let Some(response) = permission_gate_pending_response(&req) {- return response;+ if let Some(refusal) = sdk.permissions_pending_result() {+ return permissions_pending_response(req.observation_origin, refusal);}let observation_transport = daemon_observation_transport(&req);let direct_client_kind = req.client_kind;@@ -682,16 +682,13 @@ fn prepare_embedded_socket_path(}}-static PERMISSION_GATE_PENDING: std::sync::atomic::AtomicBool =- std::sync::atomic::AtomicBool::new(false);--// Only the macOS first-launch gate sets it; elsewhere it stays false.#[cfg(target_os = "macos")]/// Mark whether the macOS first-launch gate is still waiting for TCC grants.-/// The daemon socket and lifecycle diagnostics remain reachable, but tool calls-/// are rejected before execution until fresh child-process probes confirm grants.-pub fn set_permission_gate_pending(pending: bool) {- PERMISSION_GATE_PENDING.store(pending, std::sync::atomic::Ordering::Release);+/// The daemon socket and lifecycle diagnostics remain reachable, but the+/// runtime refuses every tool call with `permissions_pending` until fresh+/// child-process probes confirm grants.+pub fn set_permission_gate_pending(driver: &cua_driver_sdk::CuaDriver, pending: bool) {+ driver.set_awaiting_permissions(pending);}#[cfg(target_os = "macos")]@@ -699,51 +696,42 @@ pub fn set_permission_gate_pending(pending: bool) {/// A timeout keeps them gated while `wait_after_timeout` keeps polling on its/// own thread, so a later grant opens them without a restart.pub fn settle_permission_gate(- gate_passed: bool,- wait_after_timeout: impl FnOnce() -> anyhow::Result<()> + Send + 'static,-) {- settle_gate_flag(&PERMISSION_GATE_PENDING, gate_passed, wait_after_timeout);-}--#[cfg(target_os = "macos")]-fn settle_gate_flag(- pending: &'static std::sync::atomic::AtomicBool,+ driver: std::sync::Arc<cua_driver_sdk::CuaDriver>,gate_passed: bool,wait_after_timeout: impl FnOnce() -> anyhow::Result<()> + Send + 'static,) -> Option<std::thread::JoinHandle<()>> {if gate_passed {- pending.store(false, std::sync::atomic::Ordering::Release);+ set_permission_gate_pending(&driver, false);return None;}let poll = std::thread::Builder::new().name("cua-permissions-poll".into()).spawn(move || {if wait_after_timeout().is_ok() {- pending.store(false, std::sync::atomic::Ordering::Release);+ set_permission_gate_pending(&driver, false);}}).expect("spawn permissions poll thread");Some(poll)}-fn permission_gate_pending_response(request: &DaemonRequest) -> Option<DaemonResponse> {- permission_gate_response_for_state(- request,- PERMISSION_GATE_PENDING.load(std::sync::atomic::Ordering::Acquire),- )-}--fn permission_gate_response_for_state(- _request: &DaemonRequest,- pending: bool,-) -> Option<DaemonResponse> {- if !pending {- return None;+/// A pending gate answers before every other socket refusal (unknown tool,+/// ended session, authorization). Direct socket clients read it as a+/// retryable transport error (`EX_TEMPFAIL`). The MCP proxy forwards tool+/// results, so it gets the structured `permissions_pending` refusal instead.+fn permissions_pending_response(+ request_origin: Option<ToolObservationOrigin>,+ refusal: serde_json::Value,+) -> DaemonResponse {+ if request_origin == Some(ToolObservationOrigin::McpProxy) {+ return DaemonResponse::ok(refusal);}- Some(DaemonResponse::err(- "permissions_pending: macOS Accessibility or Screen Recording permission is still pending; no action started, retry after the permission gate completes",- 75,- ))+ let message = refusal+ .pointer("/structuredContent/refusal/message")+ .and_then(serde_json::Value::as_str)+ .unwrap_or("permissions_pending")+ .to_owned();+ DaemonResponse::err(message, 75)}fn daemon_metadata_response() -> DaemonResponse {@@ -3099,68 +3087,229 @@ mod gate_tests {}#[cfg(test)]-mod permission_gate_routing_tests {- use super::{permission_gate_response_for_state, DaemonRequest};+mod permission_gate_tests {+ use super::bind_trusted_connection;+ use std::sync::atomic::Ordering;- fn call(name: &str) -> DaemonRequest {- DaemonRequest {- method: "call".into(),- name: Some(name.into()),- args: Some(serde_json::json!({})),- session_id: None,- observation_origin: None,- client_kind: None,- }+ fn refusal_code(result: &serde_json::Value) -> Option<&str> {+ result.pointer("/structuredContent/refusal/code")?.as_str()}- #[test]- fn pending_gate_rejects_desktop_calls_with_typed_retry() {- let response = permission_gate_response_for_state(&call("list_windows"), true)- .expect("pending gate must reject desktop calls");- assert!(!response.ok);- assert!(response- .error- .as_deref()- .is_some_and(|message| message.starts_with("permissions_pending:")));- assert_eq!(response.exit_code, Some(75));+ /// On main the socket checked the gate before anything else, so a pending+ /// gate answers `permissions_pending` even for an unknown tool, an ended+ /// session or a call authorization would refuse. Each of those keeps its+ /// own answer once the gate opens.+ #[cfg(unix)]+ #[tokio::test(flavor = "multi_thread", worker_threads = 2)]+ async fn socket_permissions_pending_wins_over_every_other_refusal() {+ use super::{run_serve, send_request, DaemonRequest, ToolObservationOrigin};+ let _guard = crate::test_runtime_lock().lock().await;+ let (driver, sdk, calls) = crate::probe_sdk().await;+ let socket = format!(+ "/tmp/cua-driver-pending-{}-{}.sock",+ std::process::id(),+ uuid::Uuid::new_v4().simple()+ );+ let server = tokio::spawn({+ let (sdk, socket) = (sdk.clone(), socket.clone());+ async move {+ let _ = run_serve(sdk, &socket, None).await;+ }+ });+ for _ in 0..100 {+ if std::path::Path::new(&socket).exists() {+ break;+ }+ tokio::time::sleep(std::time::Duration::from_millis(20)).await;+ }+ let send = |request: DaemonRequest| {+ let socket = socket.clone();+ async move {+ tokio::task::spawn_blocking(move || send_request(&socket, &request))+ .await+ .unwrap()+ .expect("daemon response")+ }+ };+ let request =+ |method: &str, name: Option<&str>, args, session: Option<&str>| DaemonRequest {+ method: method.into(),+ name: name.map(str::to_owned),+ args,+ session_id: session.map(str::to_owned),+ observation_origin: None,+ client_kind: None,+ };+ let ended = "pending-ended-session";+ let probe = |session| {+ request(+ "call",+ Some("get_screen_size"),+ Some(serde_json::json!({})),+ session,+ )+ };+ let refusals = || {+ [+ (+ "unknown tool",+ request(+ "call",+ Some("no_such_tool"),+ Some(serde_json::json!({})),+ None,+ ),+ ),+ ("ended session", probe(Some(ended))),+ (+ "failed authorization",+ request(+ "call",+ Some("click"),+ Some(serde_json::json!({"pid": std::process::id(), "x": 1, "y": 1})),+ None,+ ),+ ),+ ]+ };++ assert!(send(probe(Some(ended))).await.ok);+ assert!(+ send(request("session_end", None, None, Some(ended)))+ .await+ .ok+ );+ assert_eq!(calls.load(Ordering::SeqCst), 1);++ driver.set_awaiting_permissions(true);+ let mut proxied = probe(None);+ proxied.observation_origin = Some(ToolObservationOrigin::McpProxy);+ let proxied = send(proxied).await;+ assert!(+ proxied.ok,+ "the MCP proxy forwards the refusal as a tool result"+ );+ assert_eq!(+ proxied.result.as_ref().and_then(refusal_code),+ Some("permissions_pending")+ );+ for (label, call) in std::iter::once(("open call", probe(None))).chain(refusals()) {+ let pending = send(call).await;+ assert!(!pending.ok, "{label}");+ assert_eq!(pending.exit_code, Some(75), "{label}: {:?}", pending.error);+ assert!(+ pending+ .error+ .as_deref()+ .is_some_and(|message| message.starts_with("permissions_pending:")),+ "{label}: {:?}",+ pending.error+ );+ }+ assert_eq!(+ calls.load(Ordering::SeqCst),+ 1,+ "no tool may run while pending"+ );++ driver.set_awaiting_permissions(false);+ for ((label, call), (code, text)) in refusals().into_iter().zip([+ (64, "Unknown tool: no_such_tool"),+ (1, "has ended"),+ (1, "own authorization process"),+ ]) {+ let refused = send(call).await;+ assert_eq!(+ refused.exit_code,+ Some(code),+ "{label}: {:?}",+ refused.error+ );+ assert!(+ refused+ .error+ .as_deref()+ .is_some_and(|message| message.contains(text)),+ "{label}: {:?}",+ refused.error+ );+ }+ let open = send(probe(None)).await;+ assert!(open.ok, "{:?}", open.error);+ assert_eq!(calls.load(Ordering::SeqCst), 2);++ let _ = send(request("shutdown", None, None, None)).await;+ let _ = server.await;+ let _ = std::fs::remove_file(&socket);}#[cfg(target_os = "macos")]- #[test]- fn a_late_grant_reopens_tool_calls_without_a_restart() {- use std::sync::atomic::{AtomicBool, Ordering};- // Private flags: the daemon tests in this binary read the real one.- fn gated(pending: &AtomicBool) -> bool {- permission_gate_response_for_state(- &call("list_windows"),- pending.load(Ordering::Acquire),- )- .is_some()- }+ #[tokio::test]+ async fn a_late_grant_reopens_tool_calls_without_a_restart() {+ let _guard = crate::test_runtime_lock().lock().await;+ let (driver, _sdk, calls) = crate::probe_sdk().await;+ let call = || driver.call_tool("get_screen_size".into(), "{}".into());+ let refused = |result: cua_driver_sdk::ToolResult| {+ let value: serde_json::Value = serde_json::from_str(&result.raw_json).unwrap();+ refusal_code(&value) == Some("permissions_pending")+ };- static PASSED: AtomicBool = AtomicBool::new(true);- assert!(super::settle_gate_flag(&PASSED, true, || unreachable!()).is_none());- assert!(!gated(&PASSED));+ driver.set_awaiting_permissions(true);+ assert!(super::settle_permission_gate(driver.clone(), true, || unreachable!()).is_none());+ assert!(!refused(call().await.unwrap()));- static NEVER_GRANTED: AtomicBool = AtomicBool::new(true);- super::settle_gate_flag(&NEVER_GRANTED, false, || anyhow::bail!("not granted"))+ driver.set_awaiting_permissions(true);+ super::settle_permission_gate(driver.clone(), false, || anyhow::bail!("not granted")).expect("a timed-out gate keeps polling").join().unwrap();- assert!(gated(&NEVER_GRANTED));+ assert!(refused(call().await.unwrap()));- static LATE_GRANT: AtomicBool = AtomicBool::new(true);- super::settle_gate_flag(&LATE_GRANT, false, || Ok(()))+ super::settle_permission_gate(driver.clone(), false, || Ok(())).expect("a timed-out gate keeps polling").join().unwrap();- assert!(!gated(&LATE_GRANT));+ assert!(!refused(call().await.unwrap()));+ assert_eq!(calls.load(Ordering::SeqCst), 2);+ driver.shutdown().await.unwrap();}- #[test]- fn calls_resume_only_after_the_gate_completes() {- assert!(permission_gate_response_for_state(&call("check_permissions"), true).is_some());- assert!(permission_gate_response_for_state(&call("list_windows"), false).is_none());+ #[tokio::test]+ async fn trusted_session_call_waits_for_the_permission_gate() {+ let _guard = crate::test_runtime_lock().lock().await;+ let (driver, sdk, calls) = crate::probe_sdk().await;+ let options = cua_driver_sdk::TrustedSessionOptions {+ public_session: "pending-trusted".into(),+ mode: cua_driver_sdk::SessionPermissionMode::Standard,+ ttl_seconds: 60,+ idle_ttl_seconds: 30,+ capability_manifest_path: None,+ bounded_manifest_path: None,+ };+ // The `trusted_session_call` arm calls this bound session directly.+ let connection = bind_trusted_connection(&sdk, options, "trusted-pending".into())+ .expect("bind trusted session");+ let call = || {+ connection+ .session+ .call_tool("get_screen_size".into(), "{}".into())+ };++ driver.set_awaiting_permissions(true);+ let pending: serde_json::Value =+ serde_json::from_str(&call().await.expect("refusal result").raw_json).unwrap();+ assert_eq!(refusal_code(&pending), Some("permissions_pending"));+ assert_eq!(+ calls.load(Ordering::SeqCst),+ 0,+ "no tool may run while pending"+ );++ driver.set_awaiting_permissions(false);+ assert!(!call().await.expect("tool result").is_error);+ assert_eq!(calls.load(Ordering::SeqCst), 1);+ connection.session.close();+ sdk.shutdown().await.unwrap();}}