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): refuse MCP requests before initialize on HTTP and envelope transports (#6743)
injaneity989941fde8a9
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 ec310b484c..1169f8d1fc 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@@ -8,6 +8,7 @@//! No listener, credential issuer, action replay or runtime fallback is added.use crate::driver_service_http::{Request as ServiceRequest, Service};+use cua_driver_core::mcp_wire::ProtocolSession;use cua_driver_core::protocol::{initialize_result, Request, Response};use cua_driver_core::server::{observe_proxy_session_started, observe_proxy_tool_completed, tool_observation_timer,@@ -167,6 +168,7 @@ wherelet mut pending = HashSet::new();let mut reaper = tokio::time::interval(Duration::from_secs(30));let mut session_observed = false;+ let mut protocol = ProtocolSession::default();loop {// read_until is cancellation-safe. Keep partial bytes across task and// reaper wakeups, and retain the original total line budget.@@ -223,6 +225,10 @@ where// Responding to a duplicate active ID would itself be ambiguous. End// this transport rather than miscorrelating an action or replaying it.anyhow::ensure!(!pending.contains(&key), "duplicate active MCP request ID");+ if let Err(response) = protocol.validate(&request) {+ write_response(&writer, response).await?;+ continue;+ }if request.method == "initialize" {let mut result = initialize_result();result["capabilities"]["experimental"][CAPABILITY] = json!({"version": 1});@@ -642,6 +648,8 @@ mod tests {serde_json::from_str(&line).unwrap()}async fn open(&mut self) -> Value {+ self.send(1, "initialize", json!({})).await;+ self.receive().await;self.send(1, &format!("{PREFIX}open"), json!({})).await;let mut result = self.receive().await["result"].clone();result@@ -702,6 +710,36 @@ mod tests {sdk.shutdown().await.unwrap();}+ #[tokio::test]+ async fn requests_before_initialize_are_refused_without_dispatch() {+ let _guard = crate::test_runtime_lock().lock().await;+ let sdk = sdk().await;+ let (service, _, _) = service(false);+ let (mut client, task) = start(sdk.clone(), service);+ for (id, method, params) in [+ (+ 1,+ "tools/call".to_owned(),+ json!({"name":"get_config","arguments":{}}),+ ),+ (2, "tools/list".to_owned(), json!({})),+ (3, format!("{PREFIX}open"), json!({})),+ ] {+ client.send(id, &method, params).await;+ let refused = client.receive().await;+ assert_eq!(refused["id"], id, "{method}");+ assert_eq!(refused["error"]["code"], -32602, "{method}");+ assert!(refused.get("result").is_none(), "{method}");+ }+ client.send(4, "initialize", json!({})).await;+ assert!(client.receive().await.get("result").is_some());+ client.send(5, "tools/list", json!({})).await;+ assert!(client.receive().await["result"]["tools"].is_array());+ client.write.shutdown().await.unwrap();+ task.await.unwrap().unwrap();+ sdk.shutdown().await.unwrap();+ }+#[tokio::test]async fn saturated_stream_keeps_acknowledged_cancel_and_close_responsive() {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 ad49fdcfd1..cdc2ff0345 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@@ -59,6 +59,7 @@ fn configured_port_from(value: Option<std::ffi::OsString>) -> anyhow::Result<Opt/// Spawn the HTTP MCP listener bound to `127.0.0.1:port` (loopback only).pub fn spawn(sdk: Arc<crate::sdk_adapter::SdkAdapter>, port: u16) -> anyhow::Result<()> {let token = Arc::<str>::from(configured_auth_token().map_err(anyhow::Error::msg)?);+ let sessions = Arc::new(Sessions::default());tokio::spawn(async move {let addr: SocketAddr = ([127, 0, 0, 1], port).into();match TcpListener::bind(addr).await {@@ -69,8 +70,9 @@ pub fn spawn(sdk: Arc<crate::sdk_adapter::SdkAdapter>, port: u16) -> anyhow::ResOk((stream, peer)) => {let sdk = sdk.clone();let token = token.clone();+ let sessions = sessions.clone();tokio::spawn(async move {- if let Err(e) = serve_conn(stream, sdk, token).await {+ if let Err(e) = serve_conn(stream, sdk, token, sessions).await {debug!(%peer, "MCP HTTP connection closed: {e}");}});@@ -88,6 +90,64 @@ pub fn spawn(sdk: Arc<crate::sdk_adapter::SdkAdapter>, port: u16) -> anyhow::ResOk(())}+/// MCP session ids minted by a successful `initialize`. Bounded: the oldest id+/// is forgotten first, and its client gets 404 and initializes again.+#[derive(Default)]+struct Sessions(std::sync::Mutex<std::collections::VecDeque<String>>);++const MAX_SESSIONS: usize = 256;++impl Sessions {+ fn mint(&self) -> String {+ let id = uuid::Uuid::new_v4().to_string();+ let mut ids = self.0.lock().unwrap_or_else(|e| e.into_inner());+ if ids.len() >= MAX_SESSIONS {+ ids.pop_front();+ }+ ids.push_back(id.clone());+ id+ }++ fn contains(&self, id: &str) -> bool {+ let ids = self.0.lock().unwrap_or_else(|e| e.into_inner());+ ids.iter().any(|known| known == id)+ }+}++/// Streamable HTTP lifecycle: every request except `initialize` names a live+/// session. Notifications and unparseable bodies fall through to dispatch.+fn session_refusal(+ body: &[u8],+ session: Option<&str>,+ sessions: &Sessions,+) -> Option<(u16, String)> {+ let body: serde_json::Value = serde_json::from_slice(body).ok()?;+ let id = body.get("id")?;+ if body.get("method")?.as_str()? == "initialize" {+ return None;+ }+ let (status, message) = match session {+ None => (400, "Missing Mcp-Session-Id; send initialize first"),+ Some(session) if !sessions.contains(session) => {+ (404, "Unknown MCP session; send initialize again")+ }+ Some(_) => return None,+ };+ let error = serde_json::json!({+ "jsonrpc": "2.0", "id": id, "error": {"code": -32600, "message": message}+ });+ Some((status, error.to_string()))+}++fn is_initialize_success(body: &[u8], response: &str) -> bool {+ let method = serde_json::from_slice::<serde_json::Value>(body)+ .ok()+ .and_then(|body| body.get("method")?.as_str().map(str::to_owned));+ method.as_deref() == Some("initialize")+ && serde_json::from_str::<serde_json::Value>(response)+ .is_ok_and(|response| response.get("result").is_some())+}+/// Handle one TCP connection: a keep-alive loop of HTTP requests. Requests on a/// single connection stay FIFO-ordered (so one agent's ordered calls are safe);/// parallelism comes from DISTINCT connections, each its own task.@@ -95,6 +155,7 @@ async fn serve_conn(mut stream: TcpStream,sdk: Arc<crate::sdk_adapter::SdkAdapter>,token: Arc<str>,+ sessions: Arc<Sessions>,) -> anyhow::Result<()> {let transport_session = format!("http-{}", uuid::Uuid::new_v4());struct TransportCleanup {@@ -121,6 +182,7 @@ async fn serve_conn(403,br#"{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"Browser-origin requests are forbidden"}}"#,keep_alive,+ None,).await?;} else if !req.authorized {@@ -129,6 +191,7 @@ async fn serve_conn(401,br#"{"jsonrpc":"2.0","id":null,"error":{"code":-32001,"message":"Authentication required"}}"#,false,+ None,).await?;return Ok(());@@ -138,24 +201,40 @@ async fn serve_conn(405,br#"{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"Use POST /mcp with a JSON-RPC body"}}"#,keep_alive,+ None,).await?;} else {if let Some(error) =unsupported_protocol_error(&req.body, req.protocol_version.as_deref()){- write_http(&mut stream, 400, error.as_bytes(), keep_alive).await?;+ write_http(&mut stream, 400, error.as_bytes(), keep_alive, None).await?;if !keep_alive {return Ok(());}continue;}- match dispatch(&req.body, &sdk, &transport_session).await {- Some(resp_json) => {- write_http(&mut stream, 200, resp_json.as_bytes(), keep_alive).await?+ if let Some((status, error)) =+ session_refusal(&req.body, req.session_id.as_deref(), &sessions)+ {+ write_http(&mut stream, status, error.as_bytes(), keep_alive, None).await?;+ } else {+ match dispatch(&req.body, &sdk, &transport_session).await {+ Some(resp_json) => {+ let session =+ is_initialize_success(&req.body, &resp_json).then(|| sessions.mint());+ write_http(+ &mut stream,+ 200,+ resp_json.as_bytes(),+ keep_alive,+ session.as_deref(),+ )+ .await?+ }+ // Notification (no id): MCP wants 202 Accepted, no body.+ None => write_http(&mut stream, 202, b"", keep_alive, None).await?,}- // Notification (no id): MCP wants 202 Accepted, no body.- None => write_http(&mut stream, 202, b"", keep_alive).await?,}}// Honor the client's Connection: close (and HTTP/1.0 default) — close the@@ -287,6 +366,7 @@ struct HttpRequest {keep_alive: bool,authorized: bool,protocol_version: Option<String>,+ session_id: Option<String>,}/// Read one HTTP/1.1 request, or `None` on clean EOF. Minimal: request line +@@ -321,6 +401,7 @@ async fn read_http_request(let mut keep_alive = version.eq_ignore_ascii_case("HTTP/1.1"); // 1.1 defaults to keep-alivelet mut authorized = false;let mut protocol_version = None;+ let mut session_id = None;for line in lines {if let Some((k, v)) = line.split_once(':') {let (k, v) = (k.trim(), v.trim());@@ -343,6 +424,8 @@ async fn read_http_request(if protocol_version.as_deref().is_none_or(is_legacy_protocol) {protocol_version = Some(v.to_owned());}+ } else if k.eq_ignore_ascii_case("mcp-session-id") {+ session_id = Some(v.to_owned());}}}@@ -360,6 +443,7 @@ async fn read_http_request(keep_alive,authorized,protocol_version,+ session_id,}))}@@ -408,6 +492,7 @@ async fn write_http(status: u16,body: &[u8],keep_alive: bool,+ session: Option<&str>,) -> anyhow::Result<()> {let reason = match status {200 => "OK",@@ -415,12 +500,16 @@ async fn write_http(400 => "Bad Request",403 => "Forbidden",401 => "Unauthorized",+ 404 => "Not Found",405 => "Method Not Allowed",_ => "OK",};let conn = if keep_alive { "keep-alive" } else { "close" };+ let session = session+ .map(|id| format!("Mcp-Session-Id: {id}\r\n"))+ .unwrap_or_default();let head = format!(- "HTTP/1.1 {status} {reason}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: {conn}\r\n\r\n",+ "HTTP/1.1 {status} {reason}\r\nContent-Type: application/json\r\nContent-Length: {}\r\n{session}Connection: {conn}\r\n\r\n",body.len());stream.write_all(head.as_bytes()).await?;@@ -437,6 +526,14 @@ mod tests {use serde_json::json;async fn serve_raw_request(sdk: Arc<crate::sdk_adapter::SdkAdapter>, request: &[u8]) -> String {+ serve_raw_request_with(sdk, Arc::default(), request).await+ }++ async fn serve_raw_request_with(+ sdk: Arc<crate::sdk_adapter::SdkAdapter>,+ sessions: Arc<Sessions>,+ request: &[u8],+ ) -> String {let listener = TcpListener::bind(("127.0.0.1", 0)).await.unwrap();let addr = listener.local_addr().unwrap();let server = tokio::spawn(async move {@@ -445,6 +542,7 @@ mod tests {stream,sdk,Arc::<str>::from("0123456789abcdef0123456789abcdef"),+ sessions,).await.unwrap();@@ -629,6 +727,83 @@ mod tests {sdk.shutdown().await.expect("SDK shutdown");}+ #[tokio::test]+ async fn http_requires_an_initialized_session_across_connections() {+ let _runtime_guard = crate::test_runtime_lock().lock().await;+ let sdk = crate::sdk_adapter::SdkAdapter::load(crate::build_driver_without_cursor())+ .await+ .expect("SDK adapter");+ let sessions = Arc::new(Sessions::default());+ let post = |id: u64, method: &str, session: Option<&str>| {+ let params = if method == "tools/call" {+ json!({"name": "get_config", "arguments": {}})+ } else {+ json!({})+ };+ let body =+ json!({"jsonrpc": "2.0", "id": id, "method": method, "params": params}).to_string();+ let session = session+ .map(|id| format!("Mcp-Session-Id: {id}\r\n"))+ .unwrap_or_default();+ format!(+ "POST /mcp HTTP/1.1\r\nAuthorization: Bearer 0123456789abcdef0123456789abcdef\r\n{session}Content-Length: {}\r\nConnection: close\r\n\r\n{body}",+ body.len()+ )+ };+ let send = |request: String| {+ let (sdk, sessions) = (sdk.clone(), sessions.clone());+ async move {+ let raw = serve_raw_request_with(sdk, sessions, request.as_bytes()).await;+ let (head, body) = raw.split_once("\r\n\r\n").unwrap();+ let session = head+ .lines()+ .find_map(|line| line.strip_prefix("Mcp-Session-Id: "))+ .map(str::to_owned);+ let status = head.split(' ').nth(1).unwrap().to_owned();+ let body: serde_json::Value = serde_json::from_str(body).unwrap();+ (status, session, body)+ }+ };+ for (id, method, session, status) in [+ (1, "tools/call", None, "400"),+ (2, "tools/list", None, "400"),+ (3, "tools/call", Some("forged"), "404"),+ ] {+ let (got, minted, body) = send(post(id, method, session)).await;+ assert_eq!(got, status, "{method}");+ assert_eq!(body["id"], id);+ assert_eq!(body["error"]["code"], -32600);+ assert!(body.get("result").is_none());+ assert!(minted.is_none());+ }+ let (status, minted, body) = send(post(4, "initialize", None)).await;+ assert_eq!(status, "200");+ assert!(body["result"]["protocolVersion"].is_string());+ let session = minted.expect("initialize mints an Mcp-Session-Id");+ // Each request uses a new connection, as a pooled client may.+ let (status, _, body) = send(post(5, "tools/call", Some(&session))).await;+ assert_eq!(status, "200");+ assert!(body["result"]["content"].is_array(), "{body}");+ let (status, _, body) = send(post(6, "tools/list", Some(&session))).await;+ assert_eq!(status, "200");+ assert!(body["result"]["tools"].is_array());+ sdk.shutdown().await.expect("SDK shutdown");+ }++ #[test]+ fn session_registry_forgets_the_oldest_id_first() {+ let sessions = Sessions::default();+ let first = sessions.mint();+ let second = sessions.mint();+ for _ in 2..MAX_SESSIONS {+ sessions.mint();+ }+ assert!(sessions.contains(&first));+ sessions.mint();+ assert!(!sessions.contains(&first));+ assert!(sessions.contains(&second));+ }+#[test]fn apply_session_identity_uses_transport_implicit_without_session() {let mut req: Request = serde_json::from_value(json!({@@ -732,6 +907,7 @@ mod tests {stream,server_sdk,Arc::<str>::from("0123456789abcdef0123456789abcdef"),+ Arc::default(),).await.unwrap();