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): 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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();
}
}