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-rs): proxy MCP through daemon on Windows/Linux when one is up (#1580)
Francesco Bonacci2192f3726d1a
diff --git a/libs/cua-driver-rs/crates/cua-driver/src/cli.rs b/libs/cua-driver-rs/crates/cua-driver/src/cli.rsindex 6768779667..5fb5267bc8 100644--- a/libs/cua-driver-rs/crates/cua-driver/src/cli.rs+++ b/libs/cua-driver-rs/crates/cua-driver/src/cli.rs@@ -366,9 +366,38 @@ pub fn should_use_daemon_proxy(no_daemon_relaunch: bool) -> bool {true}+/// Non-macOS targets don't have TCC, but they DO have the equivalent+/// problem of session attribution on Windows (Session 0 vs the user's+/// interactive Session 1+). When the CLI is spawned via SSH or a+/// Windows service, it lands in Session 0 where the desktop, window+/// APIs, and UI Automation return empty. A daemon running in the+/// interactive session (via `cua-driver autostart enable && kick`,+/// or any other Session-1+ launch) can answer tool calls correctly —+/// so when one is up, we proxy through it.+///+/// Behaviour:+/// * `--no-daemon-relaunch` or `CUA_DRIVER_RS_MCP_NO_RELAUNCH=1`+/// forces in-process (matches macOS opt-out).+/// * `CUA_DRIVER_RS_MCP_FORCE_PROXY=1` always proxies, even with+/// no daemon up — the caller is responsible for having one+/// already.+/// * Otherwise we probe `is_daemon_listening` on the default+/// socket: a live daemon means proxy through it; nothing+/// listening means run in-process (no autospawn equivalent on+/// Linux/Windows — there's no `open -a CuaDriver` analog).#[cfg(not(target_os = "macos"))]-pub fn should_use_daemon_proxy(_no_daemon_relaunch: bool) -> bool {- false+pub fn should_use_daemon_proxy(no_daemon_relaunch: bool) -> bool {+ use crate::bundle::is_env_truthy;+ if no_daemon_relaunch {+ return false;+ }+ if is_env_truthy("CUA_DRIVER_RS_MCP_NO_RELAUNCH") {+ return false;+ }+ if is_env_truthy("CUA_DRIVER_RS_MCP_FORCE_PROXY") {+ return true;+ }+ crate::serve::is_daemon_listening(&crate::serve::default_socket_path())}/// Spawn `/usr/bin/open -n -g -a CuaDriver --args serve` to launch@@ -449,15 +478,15 @@ pub fn launch_daemon_and_wait(socket_path: &str, timeout_secs: u64) -> anyhow::R/// `open` if needed), then `crate::proxy::run_proxy` against its/// socket. Builds its own tokio runtime — same shape as the other/// `run_*` helpers in this file that own their event loop.-#[cfg(target_os = "macos")]pub fn run_mcp_via_daemon_proxy(socket: Option<String>) -> anyhow::Result<()> {let socket_path = socket.unwrap_or_else(crate::serve::default_socket_path);if !crate::serve::is_daemon_listening(&socket_path) {// CUA_DRIVER_RS_MCP_FORCE_PROXY callers (test harness, custom- // bundle setups) supply their own daemon — skip the `open -a`- // step, since they don't have an installed CuaDriver.app to- // relaunch into. Fail fast if no daemon is up at this point.+ // bundle setups) supply their own daemon — skip the auto-+ // launch step, since they don't have an installed+ // CuaDriver.app to relaunch into. Fail fast if no daemon is+ // up at this point.if crate::bundle::is_env_truthy("CUA_DRIVER_RS_MCP_FORCE_PROXY") {anyhow::bail!("CUA_DRIVER_RS_MCP_FORCE_PROXY=1 but no daemon listening on \@@ -465,17 +494,40 @@ pub fn run_mcp_via_daemon_proxy(socket: Option<String>) -> anyhow::Result<()> {and retry.");}- let socket_suffix = if socket_path != crate::serve::default_socket_path() {- format!(" --socket {socket_path}")- } else {- String::new()- };- eprintln!(- "cua-driver-rs: mcp launched without CuaDriver.app's TCC grants; \- auto-launching the daemon via `open -n -g -a CuaDriver --args serve{socket_suffix}` \- and proxying MCP requests through it. Pass --no-daemon-relaunch to stay in-process."- );- launch_daemon_and_wait(&socket_path, 10)?;+ #[cfg(target_os = "macos")]+ {+ let socket_suffix = if socket_path != crate::serve::default_socket_path() {+ format!(" --socket {socket_path}")+ } else {+ String::new()+ };+ eprintln!(+ "cua-driver-rs: mcp launched without CuaDriver.app's TCC grants; \+ auto-launching the daemon via `open -n -g -a CuaDriver --args serve{socket_suffix}` \+ and proxying MCP requests through it. Pass --no-daemon-relaunch to stay in-process."+ );+ launch_daemon_and_wait(&socket_path, 10)?;+ }+ // On Linux / Windows there's no equivalent `open -a CuaDriver`+ // mechanism to spawn a daemon attributed to the user's+ // interactive session. The caller is expected to have one+ // running already (e.g. via `cua-driver autostart enable && kick`+ // on Windows). Bail with an actionable error rather than+ // silently falling back to an in-process server that would+ // be attributed to whatever session spawned us (typically+ // Session 0 over SSH).+ #[cfg(not(target_os = "macos"))]+ {+ anyhow::bail!(+ "no cua-driver daemon listening on {socket_path}. Start one in \+ your interactive session — on Windows run \+ `cua-driver autostart enable && cua-driver autostart kick`; \+ on Linux run `cua-driver serve &` in the user's session. \+ Then re-run `cua-driver mcp`. To skip the proxy and run \+ in-process anyway (Session 0 attribution, GUI tools will \+ return empty), pass --no-daemon-relaunch."+ );+ }}let rt = tokio::runtime::Builder::new_multi_thread()diff --git a/libs/cua-driver-rs/crates/cua-driver/src/main.rs b/libs/cua-driver-rs/crates/cua-driver/src/main.rsindex aa635d9e75..8f6632fc13 100644--- a/libs/cua-driver-rs/crates/cua-driver/src/main.rs+++ b/libs/cua-driver-rs/crates/cua-driver/src/main.rs@@ -431,12 +431,30 @@ fn main() -> anyhow::Result<()> {}cli::Command::Mcp { no_daemon_relaunch, socket } => {// Long-running MCP server — kick off the background update- // check before falling through to the in-process server.+ // check before any daemon-proxy decisions.version_check::maybe_announce_update();- // Non-macOS: TCC doesn't exist, no daemon proxy path. The- // flags parse cleanly so cross-platform MCP config- // snippets work, but we ignore them and run in-process.- let _ = (no_daemon_relaunch, socket);+ // Daemon-proxy sidestep for Windows Session 0 attribution+ // (and equivalent on Linux when a daemon is up): if a+ // daemon is listening on the default socket, forward+ // stdio MCP through it instead of running the server+ // in-process. The proxy preserves the daemon's session+ // identity (typically Session 1+ on Windows) so window /+ // UIA / screen tools see the user's actual desktop —+ // without this, an `cua-driver mcp` spawned by Claude+ // Code over SSH lands in Session 0 and every desktop+ // tool returns empty. See `cli::should_use_daemon_proxy`.+ if cli::should_use_daemon_proxy(no_daemon_relaunch) {+ if let Err(e) = cli::run_mcp_via_daemon_proxy(socket) {+ eprintln!("cua-driver-rs: {e}");+ std::process::exit(1);+ }+ return Ok(());+ }+ // Fall through to the in-process MCP server below. The+ // `socket` flag is daemon-proxy-only; ignored on the+ // in-process path (mirrors the macOS arm's drop-on-floor+ // behaviour).+ let _ = socket;}}