From fdec948abc49eded511e8fef9800392f0346eb21 Mon Sep 17 00:00:00 2001 From: Mateusz Sych <151755914+SychPL@users.noreply.github.com> Date: Wed, 21 Oct 2026 00:54:33 +0000 Subject: [PATCH] Control channel: control.running lists what the app is running, across connections (#3654) (#3689) * claim: #3654 * Control channel: control.running lists what the app is running, across connections (#3654) control.pending answers only for the connection that asks, so a second client, the MCP bridge after a reconnect or a script saw {"pending": null} while the app was busy. control.running answers for the whole app, the same on every connection and at once (the connection's own thread answers it, also while it is busy with a timed-out request): every request the app has been sent and not answered yet, oldest first, with its connection, id, method, command id (or a batch's step count), seconds since it arrived and whether it still waits its turn. A timed-out request stays listed until the app answers it, also after its connection closed. Parameters are never shown. The window marks a request started when it takes it (ControlRequest.started), which tells queued from running. The MCP server gets a read-only `running` tool. --------- Co-authored-by: MateuszSychXpl <151755914+MateuszSychXpl@users.noreply.github.com> --- apps/solidcraft/src/control_server.rs | 248 ++++++++++++++++++++++++-- crates/mcp/src/backend.rs | 4 +- crates/mcp/src/tests.rs | 16 +- crates/mcp/src/tools.rs | 11 ++ crates/ui-egui/src/control.rs | 4 +- crates/ui-egui/src/lib.rs | 1 + docs/control-protocol.md | 19 ++ docs/mcp.md | 1 + 8 files changed, 291 insertions(+), 13 deletions(-) diff --git a/apps/solidcraft/src/control_server.rs b/apps/solidcraft/src/control_server.rs index c7ee296ad..5466f0b4e 100644 --- a/apps/solidcraft/src/control_server.rs +++ b/apps/solidcraft/src/control_server.rs @@ -3,9 +3,10 @@ use std::io::{BufRead, BufReader, Write}; use std::net::{TcpListener, TcpStream}; -use std::sync::atomic::{AtomicUsize, Ordering}; +use std::sync::atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering}; use std::sync::mpsc::{Receiver, Sender, TryRecvError, channel}; -use std::time::Duration; +use std::sync::{Arc, Mutex, MutexGuard, PoisonError}; +use std::time::{Duration, Instant}; use serde_json::{Value, json}; use solidcraft_engine::MAX_LINE; @@ -178,11 +179,137 @@ struct Pending { reply: Receiver, } -fn serve(stream: TcpStream, token: &str, tx: Sender, ctx: egui::Context, patient: bool) { - serve_with(stream, token, tx, ctx, patient, WAITS); +/// Every request the app has been sent and not answered yet, from every connection, for +/// `control.running` (#3654). Each connection's own thread answers that, so it never waits behind +/// a running request. +struct Running { + list: Mutex>, + connections: AtomicU64, + keys: AtomicU64, } -fn serve_with(stream: TcpStream, token: &str, tx: Sender, ctx: egui::Context, patient: bool, waits: Waits) { +/// What `control.running` says about a request: never its parameters beyond the command id. +struct InFlight { + key: u64, + connection: u64, + id: Value, + method: String, + command: Option<&'static str>, + steps: Option, + since: Instant, + started: Arc, +} + +/// The app's requests, from both of its listeners. +static RUNNING: Running = Running::new(); + +impl Running { + const fn new() -> Self { + Running { list: Mutex::new(Vec::new()), connections: AtomicU64::new(0), keys: AtomicU64::new(0) } + } + + fn lock(&self) -> MutexGuard<'_, Vec> { + self.list.lock().unwrap_or_else(PoisonError::into_inner) + } + + /// List `req`, sent on `connection`, until the returned ticket is dropped. + fn add(&'static self, connection: u64, id: &Value, req: &ControlRequest) -> Ticket { + let key = self.keys.fetch_add(1, Ordering::Relaxed); + // Ids and methods come from the client: only short ones are repeated to the others. + let id = match id { + Value::Number(_) => id.clone(), + Value::String(s) if s.len() <= 64 => id.clone(), + _ => Value::Null, + }; + let p = &req.params; + let command = match req.method.as_str() { + "engine.execute" | "command" => p.get("command").and_then(Value::as_str).and_then(solidcraft_engine::find_command).map(|c| c.id), + _ => None, + }; + let steps = match req.method.as_str() { + "engine.batch" | "engine.script" => p.get("commands").and_then(Value::as_array).map(Vec::len), + _ => None, + }; + let method = req.method.chars().take(64).collect(); + let started = req.started.clone(); + self.lock().push(InFlight { key, connection, id, method, command, steps, since: Instant::now(), started }); + Ticket { running: self, key } + } + + /// The `control.running` result, as `asker`'s connection sees it. + fn result(&self, asker: u64) -> Value { + let rows: Vec = self + .lock() + .iter() + .map(|e| { + let mut r = json!({ + "connection": e.connection, + "id": e.id, + "method": e.method, + "running_s": (e.since.elapsed().as_secs_f64() * 10.0).round() / 10.0, + "queued": !e.started.load(Ordering::Relaxed), + }); + if let Some(c) = e.command { + r["command"] = json!(c); + } + if let Some(n) = e.steps { + r["steps"] = json!(n); + } + if e.connection == asker { + r["self"] = json!(true); + } + r + }) + .collect(); + json!({"running": rows}) + } +} + +/// A listed request; dropped when its reply arrives. +struct Ticket { + running: &'static Running, + key: u64, +} + +impl Drop for Ticket { + fn drop(&mut self) { + let key = self.key; + self.running.lock().retain(|e| e.key != key); + } +} + +/// The reply to a timed-out request, received on a thread of its own so the request stays listed +/// until the app answers, also once its connection has closed (#3654). +fn watch(reply: Receiver, ticket: Ticket) -> Receiver { + let (late_tx, late_rx) = channel(); + // A small thread per timed-out request (each connection has at most one). If none can be + // made, the reply is lost and `control.pending` says the app ended the request without one. + // The reply is passed on before the request leaves the list: once `control.running` no longer + // shows it, its connection's `control.pending` has it. + let _ = std::thread::Builder::new().stack_size(64 * 1024).spawn(move || { + if let Ok(v) = reply.recv() { + let _ = late_tx.send(v); + } + drop(late_tx); + drop(ticket); + }); + late_rx +} + +fn serve(stream: TcpStream, token: &str, tx: Sender, ctx: egui::Context, patient: bool) { + serve_with(stream, token, tx, ctx, patient, WAITS, &RUNNING); +} + +fn serve_with( + stream: TcpStream, + token: &str, + tx: Sender, + ctx: egui::Context, + patient: bool, + waits: Waits, + running: &'static Running, +) { + let connection = running.connections.fetch_add(1, Ordering::Relaxed) + 1; let Ok(read) = stream.try_clone() else { return }; let mut out = stream; let mut reader = BufReader::new(read); @@ -216,13 +343,16 @@ fn serve_with(stream: TcpStream, token: &str, tx: Sender, ctx: e let id = msg.get("id").cloned().unwrap_or(Value::Null); let method = msg.get("method").and_then(Value::as_str).unwrap_or("").to_string(); let params = msg.get("params").cloned().unwrap_or(json!({})); - // A request that timed out may have finished since (#1618). - let late = pending.as_ref().and_then(|p| match p.reply.try_recv() { + // A request that timed out may have finished since (#1618). `control.running` only + // looks, so it leaves that reply where it is. + let late = pending.as_ref().filter(|_| method != "control.running").and_then(|p| match p.reply.try_recv() { Ok(reply) => Some(reply), Err(TryRecvError::Disconnected) => Some(json!({"ok": false, "error": "the app ended the request without a reply"})), Err(TryRecvError::Empty) => None, }); - let mut r = if method == "control.pending" { + let mut r = if method == "control.running" { + json!({"ok": true, "result": running.result(connection)}) + } else if method == "control.pending" { match (pending.take(), late) { (None, _) => json!({"ok": true, "result": {"pending": null}}), (Some(p), Some(reply)) => json!({"ok": true, "result": {"pending": p.id, "method": p.method, "done": true, "reply": reply}}), @@ -243,6 +373,7 @@ fn serve_with(stream: TcpStream, token: &str, tx: Sender, ctx: e // A batch replaces many short requests: the whole of it may take long (#743). let wait = if patient || method == "engine.batch" { waits.long } else { waits.short }; let (req, rrx) = ControlRequest::new(method.clone(), params); + let ticket = running.add(connection, &id, &req); if tx.send(req).is_err() { break; } @@ -251,7 +382,7 @@ fn serve_with(stream: TcpStream, token: &str, tx: Sender, ctx: e Ok(r) => r, Err(_) => { let r = json!({"ok": false, "running": true, "error": format!("timeout: `{method}` is still running in the app and will still apply; ask `control.pending` for its result")}); - pending = Some(Pending { id: id.clone(), method, reply: rrx }); + pending = Some(Pending { id: id.clone(), method, reply: watch(rrx, ticket) }); r } } @@ -307,9 +438,10 @@ mod tests { } }); let waits = Waits { short: Duration::from_millis(100), long: Duration::from_millis(100) }; + static RUNNING: Running = Running::new(); std::thread::spawn(move || { if let Some(stream) = listener.incoming().flatten().next() { - serve_with(stream, token, tx, egui::Context::default(), false, waits); + serve_with(stream, token, tx, egui::Context::default(), false, waits, &RUNNING); } }); let s = TcpStream::connect(addr).unwrap(); @@ -349,6 +481,102 @@ mod tests { assert_eq!(*ran.lock().unwrap(), ["slow", "ui.view"], "the busy request never reached the app"); } + /// #3654: `control.running` answers on every connection, at once, with what any connection + /// has the app running or queued (command ids, never parameters); a timed-out request stays + /// listed until the app answers it, and an idle app lists nothing. + #[test] + fn every_connection_sees_what_the_app_is_running() { + static RUNNING: Running = Running::new(); + let token = "0123456789abcdef0123456789abcdef"; + let listener = TcpListener::bind("127.0.0.1:0").unwrap(); + let addr = listener.local_addr().unwrap(); + let (tx, rx) = channel::(); + // The window: one request at a time, as `drain_control` takes them; the export is held + // until the test lets it go. + let (gate_tx, gate_rx) = channel::<()>(); + std::thread::spawn(move || { + for req in rx { + req.started.store(true, Ordering::Relaxed); + if req.method == "engine.execute" { + let _ = gate_rx.recv(); + } + let _ = req.reply.send(json!({"ok": true, "result": req.method})); + } + }); + let waits = Waits { short: Duration::from_millis(100), long: Duration::from_secs(60) }; + std::thread::spawn(move || { + for stream in listener.incoming().flatten() { + let tx = tx.clone(); + std::thread::spawn(move || serve_with(stream, token, tx, egui::Context::default(), false, waits, &RUNNING)); + } + }); + let open = || { + let s = TcpStream::connect(addr).unwrap(); + s.set_read_timeout(Some(Duration::from_secs(10))).unwrap(); + let mut out = s.try_clone().unwrap(); + let mut lines = BufReader::new(s); + move |v: Value| -> Value { + writeln!(out, "{v}").unwrap(); + let mut l = String::new(); + lines.read_line(&mut l).unwrap(); + serde_json::from_str(&l).unwrap() + } + }; + let running = |ask: &mut dyn FnMut(Value) -> Value, until: &dyn Fn(&[Value]) -> bool| { + let deadline = Instant::now() + Duration::from_secs(10); + loop { + let r = ask(json!({"id": 0, "method": "control.running", "token": token})); + let rows = r["result"]["running"].as_array().cloned().unwrap_or_default(); + if until(&rows) || Instant::now() > deadline { + return (r, rows); + } + std::thread::sleep(Duration::from_millis(10)); + } + }; + let mut watcher = open(); + let (r, rows) = running(&mut watcher, &|_| true); + assert!(r["ok"] == true && rows.is_empty(), "idle: {r}"); + + let mut export = open(); + let path = "/private/part.step"; + let params = json!({"command": "file.export", "params": {"path": path}}); + let r = export(json!({"id": 7, "method": "engine.execute", "params": params, "token": token})); + assert_eq!(r["running"], true, "{r}"); + // A batch from another connection waits behind the export. + let mut batch = open(); + let queued = std::thread::spawn(move || { + let steps = json!([{"command": "solid.box"}, {"command": "solid.box"}]); + batch(json!({"id": "b", "method": "engine.batch", "params": {"commands": steps}, "token": token})) + }); + // The window may not have taken the export yet, even though it timed out. + let (r, rows) = running(&mut watcher, &|rows| rows.len() == 2 && rows[0]["queued"] == false); + assert_eq!(rows.len(), 2, "{r}"); + let (e, b) = (&rows[0], &rows[1]); + assert_eq!( + (&e["id"], &e["method"], &e["command"], &e["queued"]), + (&json!(7), &json!("engine.execute"), &json!("file.export"), &json!(false)), + "{r}" + ); + assert!(e["running_s"].as_f64().is_some_and(|s| s >= 0.1), "{r}"); + assert_eq!((&b["id"], &b["method"], &b["steps"], &b["queued"]), (&json!("b"), &json!("engine.batch"), &json!(2), &json!(true)), "{r}"); + assert_ne!(e["connection"], b["connection"], "{r}"); + assert!(rows.iter().all(|row| row.get("self").is_none()), "{r}"); + assert!(!r.to_string().contains(path), "parameters stay with their connection: {r}"); + // The connection whose request timed out may ask too, and sees its own marked. + let r = export(json!({"id": 8, "method": "control.running"})); + let own: Vec<&Value> = r["result"]["running"].as_array().unwrap().iter().filter(|row| row["self"] == true).collect(); + assert_eq!(own.len(), 1, "{r}"); + assert_eq!(own[0]["command"], "file.export", "{r}"); + + gate_tx.send(()).unwrap(); + assert_eq!(queued.join().unwrap()["result"], "engine.batch"); + let (r, rows) = running(&mut watcher, &|rows| rows.is_empty()); + assert!(rows.is_empty(), "done: {r}"); + // Asking `control.running` did not take the export's reply from its connection. + let r = export(json!({"id": 9, "method": "control.pending"})); + assert_eq!((&r["result"]["pending"], &r["result"]["done"]), (&json!(7), &json!(true)), "{r}"); + } + /// #205: a connection runs nothing until a request carries the launch's token; a wrong or /// missing token, or garbage, is refused and the connection closed. Once shown, the token /// need not be repeated on that connection. diff --git a/crates/mcp/src/backend.rs b/crates/mcp/src/backend.rs index e3b2c2078..585a2b090 100644 --- a/crates/mcp/src/backend.rs +++ b/crates/mcp/src/backend.rs @@ -10,7 +10,7 @@ use solidcraft_engine::render::StandardView; use solidcraft_engine::view::Guides; /// Something that answers control-channel methods: `engine.execute`, `engine.commands`, -/// `document.inspect`, `ui.view`, `ui.render`, `ui.screenshot`. +/// `document.inspect`, `ui.view`, `ui.render`, `ui.screenshot`, `control.running`. pub trait Backend { fn call(&mut self, method: &str, params: Value) -> Result; /// True when a real window is attached (`ui.screenshot` can capture it). @@ -301,6 +301,8 @@ impl Backend for Headless { })) } "ui.screenshot" => Err("no window in headless mode; use ui.render".into()), + // Calls run here one at a time: none is running while this one is asked. + "control.running" => Ok(json!({"running": []})), other => Err(format!("unknown method `{other}`")), } } diff --git a/crates/mcp/src/tests.rs b/crates/mcp/src/tests.rs index 71cdb9513..c17e332b6 100644 --- a/crates/mcp/src/tests.rs +++ b/crates/mcp/src/tests.rs @@ -100,6 +100,7 @@ fn handshake_and_tools_list() { "undo", "redo", "crash_reports", + "running", "new_design", "open", "save", @@ -114,6 +115,8 @@ fn handshake_and_tools_list() { let cmds = tool(&mut s, "list_commands", json!({"filter": "fillet"})); assert!(cmds.as_array().unwrap().iter().any(|c| c["id"] == "solid.fillet"), "{cmds}"); assert!(cmds.as_array().unwrap().len() < 5); + // Headless, calls run one at a time: none is running while `running` is asked (#3654). + assert_eq!(tool(&mut s, "running", json!({})), json!({"running": []})); let res = call(&mut s, 5, "resources/list", json!({})); assert_eq!(res["result"]["resources"].as_array().unwrap().len(), 2); @@ -1348,6 +1351,17 @@ fn methods(b: &Recorder) -> Vec<&str> { b.calls.iter().map(|(m, _)| m.as_str()).collect() } +/// #3654: bridged, `running` asks the app's `control.running`; an older app's refusal is the +/// tool's error. +#[test] +fn running_asks_the_app() { + let mut b = Recorder { calls: Vec::new(), batch: Ok(json!({})) }; + let r = crate::tools::call_tool(&mut b, "running", &json!({})); + assert_eq!(methods(&b), ["control.running"]); + assert_eq!(r["isError"], json!(true), "{r}"); + assert!(r["content"][0]["text"].as_str().is_some_and(|t| t.starts_with("unknown method")), "{r}"); +} + /// #743: bridged to an app that has `engine.batch`, a batch is one control request. #[test] fn batch_is_one_engine_batch_call() { @@ -1555,7 +1569,7 @@ fn tool_annotations_tell_the_whole_truth() { for name in ["execute", "batch", "save", "export", "open", "screenshot"] { assert_eq!(hints(name), (false, true, true), "{name}"); } - for name in ["list_commands", "describe_command", "inspect_design", "measure", "body_topology", "crash_reports"] { + for name in ["list_commands", "describe_command", "inspect_design", "measure", "body_topology", "crash_reports", "running"] { assert_eq!(hints(name), (true, false, false), "{name}"); } assert_eq!(hints("new_design"), (false, true, false)); diff --git a/crates/mcp/src/tools.rs b/crates/mcp/src/tools.rs index 7ef0d822d..5453c8031 100644 --- a/crates/mcp/src/tools.rs +++ b/crates/mcp/src/tools.rs @@ -255,6 +255,16 @@ pub fn tool_definitions() -> Vec { ), Effect::ReadOnly, ), + tool( + "running", + "What the app is running", + "What the app is running or has queued right now, for every client: each request's connection and id, method, \ + command id (a batch's step count), seconds since it arrived (running_s) and whether it still waits its turn \ + (queued); `self` marks a request sent on the connection that asks. Answers at once, even while the app is busy, \ + and never shows parameters. Ask it when a call timed out or the app seems slow, before sending a change again.", + obj(json!({}), &[]), + Effect::ReadOnly, + ), tool("undo", "Undo", "Undo the last change to the design.", obj(json!({}), &[]), Effect::Edits), tool("redo", "Redo", "Redo the last undone change.", obj(json!({}), &[]), Effect::Edits), tool( @@ -454,6 +464,7 @@ fn dispatch(b: &mut dyn Backend, name: &str, a: &Map) -> Result exec(b, "diagnostics.crash_report", pick(a, &["id"])), None => exec(b, "diagnostics.crash_reports", pick(a, &["limit"])), }, + "running" => b.call("control.running", json!({})), "undo" => exec(b, "edit.undo", json!({})), "redo" => exec(b, "edit.redo", json!({})), "new_design" => exec(b, "file.new", pick(a, &["name"])), diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs index 932bb7f7f..2576a5802 100644 --- a/crates/ui-egui/src/control.rs +++ b/crates/ui-egui/src/control.rs @@ -56,12 +56,14 @@ pub struct ControlRequest { pub method: String, pub params: Value, pub reply: Sender, + /// Set once the window starts on it; until then it waits its turn (`control.running`, #3654). + pub started: std::sync::Arc, } impl ControlRequest { pub fn new(method: impl Into, params: Value) -> (Self, std::sync::mpsc::Receiver) { let (tx, rx) = std::sync::mpsc::channel(); - (Self { method: method.into(), params, reply: tx }, rx) + (Self { method: method.into(), params, reply: tx, started: Default::default() }, rx) } } diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index 9c8c3246c..67b437b2b 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -1706,6 +1706,7 @@ impl SolveApp { } continue; } + req.started.store(true, std::sync::atomic::Ordering::Relaxed); // Opening or importing a file: answered when the file is in, without freezing the window. let Some(req) = file_load::control(self, req) else { ctx.request_repaint(); diff --git a/docs/control-protocol.md b/docs/control-protocol.md index b5ef79c2c..5e852bb05 100644 --- a/docs/control-protocol.md +++ b/docs/control-protocol.md @@ -59,6 +59,25 @@ with `control.pending`: `{"pending": , "method": …, "done": false}` while connection is refused at once with `{"ok": false, "busy": true, "error": "busy: …"}` and not run, so nothing is queued to apply unseen behind it. +`control.pending` answers only for its own connection. `control.running` answers for the whole +app, the same on every connection, at once (it never waits behind a running request, and a +connection may ask it while it is `busy`): every request the app has been sent and has not +answered yet, oldest first, from any connection, including a timed-out one whose connection has +since closed: + +```text +{"id":1,"method":"control.running","token":"…"} +→ {"id":1,"ok":true,"result":{"running":[ + {"connection":3,"id":17,"method":"engine.execute","command":"file.export","running_s":312.4,"queued":false}, + {"connection":5,"id":2,"method":"engine.batch","steps":12,"running_s":4.1,"queued":true,"self":true}]}} +``` + +`running_s` counts seconds since the request arrived; `queued` is true while it still waits its +turn behind another. `command` is the command id of `engine.execute` (a known one only) and +`steps` the length of `engine.batch` or `engine.script`; parameters are never shown, so file +paths and expressions stay with the connection that sent them. `self` marks the asking +connection's own request. `{"running": []}` when the app is idle. + Any request's `params` may carry `allow_paths: ["/abs/folder", …]`: every file that request reads, writes or deletes (command paths such as `file.export`'s `path` or `doc.recovery_*`'s `dir`, `ui.render`, `ui.screenshot`) must then lie inside one of those folders after `..` and diff --git a/docs/mcp.md b/docs/mcp.md index c6db0875f..5741e1695 100644 --- a/docs/mcp.md +++ b/docs/mcp.md @@ -164,6 +164,7 @@ They cover the workflow, the command shapes, how to verify with `measure`, and t | `export` | `path`, `format?` (step, 3mf, 3mf-tagged, stl, stla, obj, urdf), `bodies?`, `mesh_prefix?`, `effort?`, `velocity?` | STEP, 3MF or mesh export; URDF writes the whole assembly with its meshes next to it (`docs/urdf.md`). | | `undo`, `redo` | — | Undo / redo one change. | | `crash_reports` | `id?`, `limit?` | The crash reports on this computer, newest first; with `id`, the whole report (backtrace, command, recent commands, `design_path`/`replay_path`). See [crash-reports.md](crash-reports.md). | +| `running` | - | What the app is running or has queued, for every client (`control.running`, see [control-protocol.md](control-protocol.md#limits)): each request's connection and id, method, command id or a batch's step count, `running_s` and `queued`, never its parameters. Answers at once while the app is busy: ask it when a call timed out before sending a change again. Headless: always `{"running": []}`. | | `new_design` | `name?` | Start an empty design. | | `open` | `path` | Open a `.solidcraft` design, a STEP file (`.step`/`.stp`) as a new design holding its bodies (an Import base feature), or a 3MF/STL file as mesh bodies. | | `save` | `path?` | Save the design (to its current file without `path`). |