SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
A failed MCP batch goes back to where it started however long the undo history is: rollback undid as many steps as the undo history had grown, but the history is capped at 200 steps, so once it was full a failed batch reported undone: 0 and left its sketches behind (an empty Sketch1, two sketches named TapHole). New commands edit.checkpoint and edit.restore_checkpoint (forget: true drops one) remember and restore the design, the active sketch and the undo history; batch takes a checkpoint before its first step, restores it on a failure and forgets it on success. Against an app without checkpoints batch falls back to counting undo steps
CypherNaugh_0xab23fc990612
diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rsindex 08eb869590..cdfcd4cc22 100644--- a/crates/engine/src/cmd/edit.rs+++ b/crates/engine/src/cmd/edit.rs@@ -10,6 +10,12 @@ use crate::{EngineError, Result, Sel, Session, Snapshot};pub static COMMANDS: &[CommandSpec] = &[CommandSpec::new("edit.undo", "Undo", undo).icon("undo").key("Ctrl+Z").noundo(),CommandSpec::new("edit.redo", "Redo", redo).icon("redo").key("Ctrl+Y").noundo(),+ CommandSpec::new("edit.checkpoint", "Checkpoint", checkpoint)+ .noundo()+ .params("→ {checkpoint: id}: remember the design, active sketch and undo history (restore with edit.restore_checkpoint)"),+ CommandSpec::new("edit.restore_checkpoint", "Restore Checkpoint", restore_checkpoint)+ .noundo()+ .params("checkpoint: id; forget?: bool (true = drop it without going back). Goes back to it, undo history included"),CommandSpec::new("timeline.compute_all", "Compute All", compute_all).at("SOLID", "MODIFY").icon("compute").noundo(),CommandSpec::new("timeline.delete", "Delete", delete).at("SOLID", "MODIFY")@@ -60,6 +66,21 @@ fn redo(s: &mut Session, _p: &Value) -> Result<Value> {Ok(json!({"redone": label}))}+fn checkpoint(s: &mut Session, _p: &Value) -> Result<Value> {+ Ok(json!({"checkpoint": s.checkpoint()}))+}++fn restore_checkpoint(s: &mut Session, p: &Value) -> Result<Value> {+ let cmd = "edit.restore_checkpoint";+ let id = p.get("checkpoint").and_then(Value::as_u64).ok_or_else(|| bad(cmd, "`checkpoint` must be an id from edit.checkpoint"))?;+ if bool_(p, "forget") == Some(true) {+ s.drop_checkpoint(id);+ return Ok(json!({"checkpoint": id, "restored": false}));+ }+ s.restore_checkpoint(id)?;+ Ok(json!({"checkpoint": id, "restored": true}))+}+fn compute_all(s: &mut Session, _p: &Value) -> Result<Value> {s.model = solvecraft_doc::Model::new();s.refresh();diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rsindex 2ce894952b..22a5106f73 100644--- a/crates/engine/src/lib.rs+++ b/crates/engine/src/lib.rs@@ -170,6 +170,20 @@ pub struct Session {pub analysis: Option<SurfaceAnalysis>,/// What is hidden or shown in the view (`browser.visibility`).pub visibility: Visibility,+ /// States to go back to (`edit.checkpoint`, `edit.restore_checkpoint`): how batches of+ /// commands are undone however long the undo history is.+ pub(crate) checkpoints: Vec<Checkpoint>,+ next_checkpoint: u64,+}++/// The design, active sketch and undo history at an `edit.checkpoint`.+#[derive(Clone, Debug)]+pub(crate) struct Checkpoint {+ pub id: u64,+ pub doc: Arc<Document>,+ pub active_sketch: Option<u64>,+ pub undo: Vec<Snapshot>,+ pub redo: Vec<Snapshot>,}/// Items hidden or shown one by one (view state, not part of the design and not an undo step).@@ -204,6 +218,8 @@ pub enum SurfaceAnalysis {}const MAX_UNDO: usize = 200;+/// Checkpoints kept (the oldest go first).+const MAX_CHECKPOINTS: usize = 16;const MAX_LOG: usize = 2000;impl Default for Session {@@ -235,6 +251,8 @@ impl Session {clipboard: Vec::new(),section: None,analysis: None,+ checkpoints: Vec::new(),+ next_checkpoint: 1,visibility: Visibility::default(),}}@@ -356,6 +374,44 @@ impl Session {}}+ /// Remember the design, active sketch and undo history; returns the checkpoint's id.+ pub fn checkpoint(&mut self) -> u64 {+ let id = self.next_checkpoint;+ self.next_checkpoint += 1;+ self.checkpoints.push(Checkpoint {+ id,+ doc: self.doc.clone(),+ active_sketch: self.active_sketch,+ undo: self.undo.clone(),+ redo: self.redo.clone(),+ });+ if self.checkpoints.len() > MAX_CHECKPOINTS {+ self.checkpoints.remove(0);+ }+ id+ }++ /// Go back to checkpoint `id` as if nothing since had happened (the undo history too). It+ /// and later checkpoints are used up.+ pub fn restore_checkpoint(&mut self, id: u64) -> Result<()> {+ let i = self.checkpoints.iter().position(|c| c.id == id).ok_or_else(|| EngineError::Other(format!("no checkpoint {id}")))?;+ let Some(c) = self.checkpoints.drain(i..).next() else { return Err(EngineError::Other(format!("no checkpoint {id}"))) };+ self.doc = c.doc;+ self.active_sketch = c.active_sketch;+ self.undo = c.undo;+ self.redo = c.redo;+ self.selection.clear();+ self.refresh();+ Ok(())+ }++ /// Forget checkpoint `id` (and later ones) without going back.+ pub fn drop_checkpoint(&mut self, id: u64) {+ if let Some(i) = self.checkpoints.iter().position(|c| c.id == id) {+ self.checkpoints.truncate(i);+ }+ }+/// A scratch copy of the session (same design and model, no history or log) to try/// commands on without touching this one.pub fn scratch(&self) -> Session {@@ -377,6 +433,8 @@ impl Session {clipboard: self.clipboard.clone(),section: None,analysis: None,+ checkpoints: Vec::new(),+ next_checkpoint: 1,visibility: Visibility::default(),}}diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rsindex 3a06c2e65c..2495c83c83 100644--- a/crates/engine/src/tests.rs+++ b/crates/engine/src/tests.rs@@ -855,6 +855,35 @@ fn deleting_a_path_sketch_deletes_its_pipe() {assert!(s.model.results.iter().all(|r| r.error.is_none()));}+/// Regression: batches were rolled back by undoing as many steps as the undo history grew,+/// which is none once the history is full, leaving their sketches behind.+#[test]+fn checkpoint_restores_with_a_full_undo_history() {+ let mut s = Session::default();+ for i in 0..MAX_UNDO + 5 {+ run(&mut s, "parameters.add", json!({"name": format!("p{i}"), "expression": "1 mm"}));+ }+ assert_eq!(s.undo.len(), MAX_UNDO);+ let labels: Vec<String> = s.undo.iter().map(|u| u.label.clone()).collect();+ let doc = s.doc.clone();+ let id = run(&mut s, "edit.checkpoint", json!({}))["checkpoint"].as_u64().unwrap();+ run(&mut s, "sketch.create", json!({"plane": "XY", "name": "TapHole"}));+ run(&mut s, "sketch.circle.center", json!({"center": [0, 0], "radius": 2}));+ assert!(s.active_sketch.is_some());+ run(&mut s, "edit.restore_checkpoint", json!({"checkpoint": id}));+ assert!(Arc::ptr_eq(&s.doc, &doc) && s.active_sketch.is_none());+ assert!(s.doc.find_feature("TapHole").is_none());+ assert_eq!(s.undo.iter().map(|u| u.label.clone()).collect::<Vec<_>>(), labels);+ // Used up: a second restore is an error, not a jump somewhere else.+ assert!(s.execute("edit.restore_checkpoint", &json!({"checkpoint": id})).is_err());+ // Forgetting one leaves the design alone.+ let id = run(&mut s, "edit.checkpoint", json!({}))["checkpoint"].as_u64().unwrap();+ run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Kept"}));+ run(&mut s, "edit.restore_checkpoint", json!({"checkpoint": id, "forget": true}));+ assert!(s.doc.find_feature("Kept").is_some());+ assert!(s.execute("edit.restore_checkpoint", &json!({"checkpoint": id})).is_err());+}+#[test]fn components_occurrences_and_world_placement() {let mut s = Session::default();diff --git a/crates/mcp/src/tests.rs b/crates/mcp/src/tests.rsindex f050cd49ea..64aa12f87b 100644--- a/crates/mcp/src/tests.rs+++ b/crates/mcp/src/tests.rs@@ -213,6 +213,35 @@ fn batch_stops_at_first_error_and_rolls_back() {assert_eq!(tool(&mut s, "measure", json!({}))["body_count"], 2);}+/// Regression: with a full undo history a failed batch reported `undone: 0` and left its+/// sketches behind (an empty "Sketch1", two sketches named "TapHole").+#[test]+fn batch_rolls_back_with_a_full_undo_history() {+ let mut s = server();+ let fill: Vec<Value> =+ (0..230).map(|i| json!({"command": "parameters.add", "params": {"name": format!("p{i}"), "expression": "1 mm"}})).collect();+ tool(&mut s, "batch", json!({"commands": fill}));+ let undo = tool(&mut s, "inspect_design", json!({"measure": false}))["undo"].clone();+ for _ in 0..2 {+ let r = raw_tool(+ &mut s,+ "batch",+ json!({"commands": [+ {"command": "sketch.create", "params": {"plane": "XY", "name": "TapHole"}},+ {"command": "sketch.circle.center", "params": {"center": [0, 0], "radius": 2}},+ {"command": "sketch.dimension", "params": {"entities": ["nope"], "value": 3}},+ ]}),+ );+ let body: Value = serde_json::from_str(r["result"]["content"][0]["text"].as_str().unwrap()).unwrap();+ assert_eq!(body["failed"]["index"], 2, "{body}");+ assert_eq!(body["undone"], 2, "{body}");+ }+ let d = tool(&mut s, "inspect_design", json!({"measure": false, "sketches": false}));+ assert_eq!(d["sketches"].as_array().map(Vec::len), Some(0), "{d}");+ assert!(d["active_sketch"].is_null(), "{d}");+ assert_eq!(d["undo"], undo);+}+#[test]fn helper_sketches_can_be_hidden() {let mut s = server();diff --git a/crates/mcp/src/tools.rs b/crates/mcp/src/tools.rsindex 0d1e993a8c..938e0de7da 100644--- a/crates/mcp/src/tools.rs+++ b/crates/mcp/src/tools.rs@@ -361,7 +361,56 @@ fn undo_depth(b: &mut dyn Backend) -> Option<u64> {b.call("document.inspect", json!({})).ok().and_then(|d| d["undo"].as_u64())}-/// `batch`: run steps in order, stop at the first failure and (by default) undo what ran.+/// How a failed batch goes back to where it started.+enum Undo {+ /// An engine checkpoint: the design, active sketch and undo history exactly as they were.+ Checkpoint(u64),+ /// An app without checkpoints: undo as many steps as the batch added (wrong once the undo+ /// history is full, as its depth no longer grows).+ Depth(u64),+ None,+}++impl Undo {+ fn begin(b: &mut dyn Backend) -> Undo {+ match exec(b, "edit.checkpoint", json!({})).ok().and_then(|v| v["checkpoint"].as_u64()) {+ Some(id) => Undo::Checkpoint(id),+ None => undo_depth(b).map_or(Undo::None, Undo::Depth),+ }+ }++ /// Go back; the number of steps undone.+ fn rollback(self, b: &mut dyn Backend, steps: usize) -> u64 {+ match self {+ Undo::Checkpoint(id) => match exec(b, "edit.restore_checkpoint", json!({"checkpoint": id})) {+ Ok(_) => steps as u64,+ Err(_) => 0,+ },+ Undo::Depth(before) => {+ let after = undo_depth(b).unwrap_or(before);+ let mut undone = 0u64;+ for _ in before..after {+ if exec(b, "edit.undo", json!({})).is_err() {+ break;+ }+ undone += 1;+ }+ undone+ }+ Undo::None => 0,+ }+ }++ /// The batch went through: forget the checkpoint.+ fn finish(self, b: &mut dyn Backend) {+ if let Undo::Checkpoint(id) = self {+ let _ = exec(b, "edit.restore_checkpoint", json!({"checkpoint": id, "forget": true}));+ }+ }+}++/// `batch`: run steps in order, stop at the first failure and (by default) go back to the+/// design as it was before the batch.fn batch(b: &mut dyn Backend, a: &Map<String, Value>) -> Value {let Some(steps) = a.get("commands").and_then(Value::as_array) else {return text_result(&json!("`commands` must be an array of {command, params}"), true);@@ -370,7 +419,7 @@ fn batch(b: &mut dyn Backend, a: &Map<String, Value>) -> Value {return text_result(&json!(format!("batch too long ({} steps, at most {MAX_BATCH})", steps.len())), true);}let rollback = a.get("rollback").and_then(Value::as_bool).unwrap_or(true);- let before = if rollback { undo_depth(b) } else { None };+ let start = if rollback { Undo::begin(b) } else { Undo::None };let mut results = Vec::with_capacity(steps.len());for (i, step) in steps.iter().enumerate() {let command = step.get("command").or_else(|| step.get("id")).and_then(Value::as_str);@@ -381,15 +430,7 @@ fn batch(b: &mut dyn Backend, a: &Map<String, Value>) -> Value {match r {Ok(v) => results.push(v),Err(e) => {- let mut undone = 0u64;- if let (Some(before), Some(after)) = (before, rollback.then(|| undo_depth(b)).flatten()) {- for _ in before..after {- if exec(b, "edit.undo", json!({})).is_err() {- break;- }- undone += 1;- }- }+ let undone = start.rollback(b, i);return text_result(&json!({"ok": false,@@ -404,6 +445,7 @@ fn batch(b: &mut dyn Backend, a: &Map<String, Value>) -> Value {}}}+ start.finish(b);text_result(&json!({"ok": true, "completed": results.len(), "results": results}), false)}diff --git a/docs/mcp.md b/docs/mcp.mdindex 3aec985e14..63370d711e 100644--- a/docs/mcp.md+++ b/docs/mcp.md@@ -69,8 +69,11 @@ Errors: an unknown tool or arguments that don't match the tool's schema are JSON`-32602` errors; an engine failure (bad command parameters, a feature that fails) is a toolresult with `isError: true` and the engine's message, which the model can read and correct.-`batch` rollback undoes as many steps as the batch added to the undo history; batches that-themselves call `edit.undo`, `file.new` or `doc.open` are not rolled back exactly.+`batch` rollback goes back to an engine checkpoint (`edit.checkpoint`) taken before the first+step: the design, the active sketch and the undo history are restored exactly as they were,+however long the history is. Batches that call `file.new` or `doc.open` get the design back,+not its file path. (An older app without checkpoints falls back to undoing as many steps as+the batch added to the undo history.)## Demo: an enclosure built over MCP