SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
MCP save: a folder the agent opened or saved a design in stays in scope (#7181) (#7216)
Mateusz Syche181015fd156
diff --git a/apps/solidcraft-cli/src/main.rs b/apps/solidcraft-cli/src/main.rsindex ebba3484f4..b5835e0c92 100644--- a/apps/solidcraft-cli/src/main.rs+++ b/apps/solidcraft-cli/src/main.rs@@ -653,7 +653,7 @@ fn cmd_mcp(args: &[String]) -> Result<(), String> {if let Some(s) = &scope {let roots: Vec<String> = s.roots().iter().map(|r| r.display().to_string()).collect();eprintln!(- "solidcraft mcp: files limited to {} and the open design's folder (--allow-path DIR adds one, --allow-any-path lifts the limit)",+ "solidcraft mcp: files limited to {} and the folders of designs opened or saved here (--allow-path DIR adds one, --allow-any-path lifts the limit)",roots.join(", "));let design_dir = flag(args, "--in")diff --git a/crates/io/src/vfs.rs b/crates/io/src/vfs.rsindex 900169cfa5..2c6f6c7603 100644--- a/crates/io/src/vfs.rs+++ b/crates/io/src/vfs.rs@@ -141,15 +141,18 @@ pub use imp::*;/// refuses paths outside it; without one (the user's own file dialogs, the CLI) nothing changes.////// Two kinds of folder: those named on purpose (`--allow-path`, the app's own recovery folder),-/// where everything is reachable, and the open design's folder, which counts only when-/// [`design_folder_refusal`] has nothing against it and never reaches hidden files or folders-/// (`.env`, `.git`) inside it.+/// where everything is reachable, and design folders (the open design's, and those an agent+/// opened or saved a design in, #7181), which count only when [`design_folder_refusal`] has+/// nothing against them and never reach hidden files or folders (`.env`, `.git`) inside them.#[derive(Clone, Debug, Default, PartialEq)]pub struct PathScope {roots: Vec<std::path::PathBuf>,design_roots: Vec<std::path::PathBuf>,}+/// At most this many design folders in a scope; the oldest gives way.+pub const MAX_DESIGN_FOLDERS: usize = 16;+thread_local! {static SCOPE: std::cell::RefCell<Option<PathScope>> = const { std::cell::RefCell::new(None) };}@@ -216,15 +219,44 @@ impl PathScope {}/// Also the folder of the design at `path` (the open design), when- /// [`design_folder_refusal`] allows it; hidden entries inside it stay out of reach.- pub fn with_design(mut self, path: Option<&str>) -> PathScope {- let dir = path- .map(std::path::Path::new)- .and_then(std::path::Path::parent)- .map(|d| if d.as_os_str().is_empty() { std::path::Path::new(".") } else { d });- if let Some(d) = dir.filter(|d| design_folder_refusal(d).is_none()).and_then(canonical)+ /// [`design_folder_refusal`] allows it; hidden entries inside it stay out of reach. It is the+ /// folder of the file as [`PathScope::check`] resolves it: a link to a design elsewhere puts+ /// the folder it leads to in reach, never the folder the link lies in.+ pub fn with_design(self, path: Option<&str>) -> PathScope {+ let file = path.and_then(|p| resolve(std::path::Path::new(p)).ok());+ match file.as_deref().and_then(std::path::Path::parent) {+ Some(d) => self.with_design_root(d),+ None => self,+ }+ }++ /// Also the folder of `path`, a design file an agent opened or saved (#7181), on the same+ /// terms as the open design's. On Windows its text is judged first, as [`PathScope::check`]+ /// judges a path: resolving a UNC path would already make Windows connect out.+ pub fn with_design_file(self, path: &str) -> PathScope {+ if cfg!(windows) && windows_refusal(path).is_some() {+ return self;+ }+ self.with_design(Some(path))+ }++ /// Also `dir`, a folder an agent opened or saved a design in (a request's `design_folders`),+ /// on the same terms as the open design's folder, its text judged first on Windows.+ pub fn with_design_folder(self, dir: &std::path::Path) -> PathScope {+ if cfg!(windows) && windows_refusal(&dir.to_string_lossy()).is_some() {+ return self;+ }+ self.with_design_root(dir)+ }++ fn with_design_root(mut self, dir: &std::path::Path) -> PathScope {+ if design_folder_refusal(dir).is_none()+ && let Some(d) = canonical(dir)&& !self.design_roots.contains(&d){+ if self.design_roots.len() >= MAX_DESIGN_FOLDERS {+ self.design_roots.remove(0);+ }self.design_roots.push(d);}self@@ -235,7 +267,7 @@ impl PathScope {&self.roots}- /// The open design's folder, when it counts.+ /// The design folders that count.pub fn design_roots(&self) -> &[std::path::PathBuf] {&self.design_roots}@@ -962,6 +994,34 @@ mod tests {let _ = std::fs::remove_dir_all(&base);}+ /// Folders an agent opened or saved a design in (#7181) count as the open design's folder+ /// does, hidden ones never, and a scope keeps at most `MAX_DESIGN_FOLDERS`: the oldest gives+ /// way.+ #[cfg(not(target_arch = "wasm32"))]+ #[test]+ fn a_scope_keeps_the_latest_design_folders() {+ use super::{MAX_DESIGN_FOLDERS, PathScope};+ let base = super::temp_dir().join(format!("solidcraft-vfs-design-folders-{}", std::process::id()));+ let _ = std::fs::remove_dir_all(&base);+ let dirs: Vec<_> = (0..=MAX_DESIGN_FOLDERS).map(|i| base.join(format!("d{i}"))).collect();+ for d in dirs.iter().chain([&base.join(".hidden")]) {+ std::fs::create_dir_all(d).unwrap();+ }+ let scope = dirs+ .iter()+ .fold(PathScope::new([]), |s, d| s.with_design_folder(d))+ .with_design_folder(&dirs[1])+ .with_design_folder(&base.join(".hidden"));+ let canon = |d: &std::path::Path| std::fs::canonicalize(d).unwrap();+ assert_eq!(scope.design_roots().len(), MAX_DESIGN_FOLDERS, "{scope:?}");+ assert_eq!(scope.design_roots().last(), Some(&canon(&dirs[MAX_DESIGN_FOLDERS])), "{scope:?}");+ let file = |d: &std::path::Path| d.join("part.solidcraft").to_string_lossy().to_string();+ assert!(scope.check(&file(&dirs[1])).is_ok());+ assert!(scope.check(&file(&dirs[0])).is_err(), "the oldest gave way");+ assert!(scope.check(&file(&base.join(".hidden"))).is_err(), "a hidden folder never counts");+ let _ = std::fs::remove_dir_all(&base);+ }+/// A save follows a symbolic link to the file it points to (#845), so the link's target is/// what a scope judges: a link inside an allowed folder that leads out is refused, a chain of/// links that stays inside is fine.diff --git a/crates/mcp/src/backend.rs b/crates/mcp/src/backend.rsindex 023ba44f5b..cfc459e9f6 100644--- a/crates/mcp/src/backend.rs+++ b/crates/mcp/src/backend.rs@@ -273,6 +273,10 @@ impl Remote {// The app confines the files this request reaches to the agent's folders (control.rs).if let (Some(scope), Some(o)) = (solidcraft_engine::io::vfs::current_scope(), params.as_object_mut()) {o.insert("allow_paths".into(), json!(scope.roots().iter().map(|r| r.to_string_lossy()).collect::<Vec<_>>()));+ // And the folders it opened or saved a design in, which count as its open design's.+ if !scope.design_roots().is_empty() {+ o.insert("design_folders".into(), json!(scope.design_roots().iter().map(|r| r.to_string_lossy()).collect::<Vec<_>>()));+ }}let mut msg = json!({"id": id, "method": method, "params": params});// The token goes with every request (an app restarted mid-session has a new one).diff --git a/crates/mcp/src/lib.rs b/crates/mcp/src/lib.rsindex 36391eac0b..f3e3c54077 100644--- a/crates/mcp/src/lib.rs+++ b/crates/mcp/src/lib.rs@@ -25,7 +25,8 @@ use solidcraft_engine::io::vfs::{self, PathScope};/// The folders `solidcraft-cli mcp` lets its agent read, write and delete in by default: the/// app's own recovery folder, this server's private scratch folder (screenshots), and each/// `allowed` folder (`--allow-path`). The open design's folder joins on every call when it is a-/// safe one (`vfs::design_folder_refusal`; the server adds it). The working folder, the home+/// safe one (`vfs::design_folder_refusal`; the server adds it), and stays for the rest of the run+/// like the folder of every design a call opens or saves (#7181). The working folder, the home/// folder and anything above it never count by themselves, so `~/.ssh`, `~/.bashrc` and other/// dotfiles are out of reach unless a folder holding them is allowed on purpose.pub fn agent_scope(allowed: impl IntoIterator<Item = PathBuf>) -> PathScope {diff --git a/crates/mcp/src/server.rs b/crates/mcp/src/server.rsindex 2a897c0d85..8f9fc4efe6 100644--- a/crates/mcp/src/server.rs+++ b/crates/mcp/src/server.rs@@ -43,6 +43,29 @@ pub struct Server {scope: Option<PathScope>,}+/// The design files a call opens or saves (#7181): `open` and `save`, and the commands they run+/// (`doc.open`, `file.save`, `file.save_as`) through `execute` or as `batch` steps. Each reads or+/// writes the file it names through the agent's scope.+fn design_files(name: &str, args: &Value) -> Vec<String> {+ let step = |command: &str, params: &Value| {+ let params = match command {+ "open" | "save" | "doc.open" | "file.save" | "file.save_as" => params,+ "execute" if matches!(params["command"].as_str(), Some("doc.open" | "file.save" | "file.save_as")) => ¶ms["params"],+ _ => return None,+ };+ params["path"].as_str().map(str::to_owned)+ };+ match name {+ "batch" => args["commands"]+ .as_array()+ .into_iter()+ .flatten()+ .filter_map(|s| step(s["command"].as_str().or_else(|| s["id"].as_str())?, &s["params"]))+ .collect(),+ _ => step(name, args).into_iter().collect(),+ }+}+fn response(id: Value, result: Value) -> Value {json!({"jsonrpc": "2.0", "id": id, "result": result})}@@ -185,10 +208,21 @@ impl Server {Some(a) => a.clone(),};check_arguments(name, &args).map_err(|e| (INVALID_PARAMS, e))?;- // The open design's folder counts as it is now (a save-as or open moves it).- let scope = self.scope.clone().map(|s| s.with_design(self.backend.design_path().as_deref()));+ // The open design's folder counts, and goes on counting for the rest of this run+ // when a save-as or open moves the design elsewhere (#7181).+ let open = self.backend.design_path();+ self.scope = self.scope.take().map(|s| s.with_design(open.as_deref()));+ let scope = self.scope.clone();let backend = self.backend.as_mut();let mut result = vfs::scoped(scope, || call_tool(backend, name, &args));+ // So does the folder of each design file the call opened or saved: the call reached+ // it, so it was one of the agent's folders already. Only paths given in full: a+ // running app resolves a relative one against its own working folder.+ if result["isError"] != true {+ for file in design_files(name, &args).iter().filter(|f| std::path::Path::new(f).is_absolute()) {+ self.scope = self.scope.take().map(|s| s.with_design_file(file));+ }+ }if let Some(note) = backend.notice()&& let Some(content) = result.get_mut("content").and_then(Value::as_array_mut){diff --git a/crates/mcp/src/tests.rs b/crates/mcp/src/tests.rsindex 4eb804dc20..2643964a00 100644--- a/crates/mcp/src/tests.rs+++ b/crates/mcp/src/tests.rs@@ -897,6 +897,59 @@ fn the_default_folders_are_the_designs_the_recovery_folder_and_the_scratch_foldelet _ = std::fs::remove_dir_all(&base);}+/// #7181: the folder the agent opened or saved a design in stays one of its folders when the+/// design moves on (a new design, a STEP file opened from there, a save-as into a subfolder), so+/// a later `save` beside it works. Its hidden files and the folders beside it stay out of reach,+/// and a refused call adds nothing.+#[test]+fn a_folder_the_agent_saved_a_design_in_stays_its_folder() {+ use solidcraft_engine::io::vfs::PathScope;+ let base = solidcraft_engine::io::vfs::temp_dir().join(format!("solidcraft-mcp-remembered-{}", std::process::id()));+ let _ = std::fs::remove_dir_all(&base);+ let (proj, other) = (base.join("proj"), base.join("other"));+ std::fs::create_dir_all(proj.join("sub")).unwrap();+ std::fs::create_dir_all(&other).unwrap();+ let at = |d: &std::path::Path, f: &str| d.join(f).to_string_lossy().to_string();+ let mut session = solidcraft_engine::Session::default();+ session.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10})).unwrap();+ session.execute("file.save_as", &json!({"path": at(&proj, "part.solidcraft")})).unwrap();+ let mut s = Server::new(Box::new(Headless::new(session))).with_path_scope(Some(PathScope::new([])));+ tool(&mut s, "export", json!({"path": at(&proj, "part.step")}));+ tool(&mut s, "new_design", json!({}));+ tool(&mut s, "execute", json!({"command": "solid.box", "params": {"length": 5, "width": 5, "height": 5}}));+ tool(&mut s, "save", json!({"path": at(&proj, "part-2.solidcraft")}));+ // A STEP file opens as a new, unsaved design; it saves beside its file.+ tool(&mut s, "open", json!({"path": at(&proj, "part.step")}));+ tool(&mut s, "save", json!({"path": at(&proj, "part-3.solidcraft")}));+ // A save-as into a subfolder moves the design there; the folder above goes on counting.+ tool(&mut s, "execute", json!({"command": "file.save_as", "params": {"path": at(&proj.join("sub"), "part-4.solidcraft")}}));+ tool(&mut s, "save", json!({"path": at(&proj, "part-5.solidcraft")}));+ for f in ["part-2", "part-3", "sub/part-4", "part-5"] {+ assert!(proj.join(format!("{f}.solidcraft")).exists(), "{f}");+ }+ // Twice: the first refusal must not have added anything.+ for _ in 0..2 {+ let r = raw_tool(&mut s, "export", json!({"path": at(&proj, ".env")}));+ assert_eq!(r["result"]["isError"], json!(true), "{r}");+ let r = raw_tool(&mut s, "save", json!({"path": at(&other, "x.solidcraft")}));+ assert!(r.to_string().contains("outside the folders this agent may use"), "{r}");+ }+ assert!(!proj.join(".env").exists());+ assert_eq!(std::fs::read_dir(&other).unwrap().count(), 0);+ // A link beside it to a design here counts where it leads, never where it lies.+ #[cfg(unix)]+ {+ std::os::unix::fs::symlink(proj.join("part.step"), other.join("link.step")).unwrap();+ std::os::unix::fs::symlink(proj.join("part.solidcraft"), other.join("link.solidcraft")).unwrap();+ tool(&mut s, "open", json!({"path": at(&other, "link.step")}));+ tool(&mut s, "open", json!({"path": at(&other, "link.solidcraft")}));+ let r = raw_tool(&mut s, "save", json!({"path": at(&other, "x.solidcraft")}));+ assert!(r.to_string().contains("outside the folders this agent may use"), "{r}");+ assert!(!other.join("x.solidcraft").exists());+ }+ let _ = std::fs::remove_dir_all(&base);+}+/// Tool calls reach files only inside the server's folders (#205): the usual workflow (save,/// export, open, screenshots) works there; a path outside, directly, through `..` or through a/// symlink that leads out, is refused with a clear error and nothing is written.@@ -1041,6 +1094,43 @@ fn a_bridged_request_carries_the_agents_folders() {echo.join().unwrap();}+/// #7181, bridged: once the agent has saved a design through the app, that file's folder goes+/// with every later request as `design_folders`, so the app counts it after the design moves on.+/// Not before the save succeeded, not for one the app refused, not for a relative path (the app+/// resolves those against its own working folder).+#[test]+fn a_bridged_server_sends_the_folders_the_agent_saved_designs_in() {+ use solidcraft_engine::io::vfs::PathScope;+ let base = solidcraft_engine::io::vfs::temp_dir().join(format!("solidcraft-mcp-bridged-folders-{}", std::process::id()));+ let _ = std::fs::remove_dir_all(&base);+ let (proj, other) = (base.join("proj"), base.join("other"));+ std::fs::create_dir_all(&proj).unwrap();+ std::fs::create_dir_all(&other).unwrap();+ let at = |d: &std::path::Path, f: &str| d.join(f).to_string_lossy().to_string();+ let sent = std::sync::Arc::new(std::sync::Mutex::new(Vec::<Value>::new()));+ let (log, refused) = (sent.clone(), at(&other, "x.solidcraft"));+ let (addr, _) = scripted_app(move |req| {+ if req["method"] == "engine.execute" {+ log.lock().unwrap().push(req["params"]["design_folders"].clone());+ }+ if req["params"]["params"]["path"] == refused.as_str() {+ json!({"ok": false, "error": "outside the folders this agent may use"})+ } else {+ json!({"ok": true, "result": {}})+ }+ });+ let remote = crate::Remote::connect_with_token(&addr, Some("0123456789abcdef0123456789abcdef")).unwrap();+ let mut s = Server::new(Box::new(remote)).with_path_scope(Some(PathScope::new([])));+ let r = raw_tool(&mut s, "save", json!({"path": at(&other, "x.solidcraft")}));+ assert_eq!(r["result"]["isError"], json!(true), "{r}");+ tool(&mut s, "save", json!({"path": "relative/y.solidcraft"}));+ tool(&mut s, "save", json!({"path": at(&proj, "a.solidcraft")}));+ tool(&mut s, "new_design", json!({}));+ let proj = std::fs::canonicalize(&proj).unwrap();+ assert_eq!(*sent.lock().unwrap(), [Value::Null, Value::Null, Value::Null, json!([proj.to_string_lossy()])]);+ let _ = std::fs::remove_dir_all(&base);+}+/// #528: an agent saves the angle of a product photo as a named view once, then renders the/// model from that view after each change. The render must use the saved camera, not a/// standard view.diff --git a/crates/mcp/src/tools.rs b/crates/mcp/src/tools.rsindex 15c3e8697a..353f1bfa91 100644--- a/crates/mcp/src/tools.rs+++ b/crates/mcp/src/tools.rs@@ -316,7 +316,10 @@ pub fn tool_definitions() -> Vec<Value> {tool("save","Save the design",- "Save the design to `path` or its current file (a design opened as .solidcraft keeps that name). New designs are .sc files. The default is a design container; a .json path selects plain JSON. Set format to container or json to override the path.",+ "Save the design to `path` or its current file (a design opened as .solidcraft keeps that name). New designs are .sc files. The default is a design container; a .json path selects plain JSON. Set format to container or json to override the path. \+ By default the path must lie in one of the agent's folders: the folder of a design opened or saved in this session (not its hidden files), \+ SolidCraft's recovery folder, or a folder this server was started with `--allow-path DIR`. For a folder outside them, ask the user \+ to add `--allow-path` and that folder to this server's arguments in their MCP client configuration.",obj(json!({"path": string("Path to save to, e.g. part.sc (default: the current file)"), "format": {"type": "string", "enum": ["container", "json"], "description": "Design encoding (default: JSON for .json, container otherwise)"}}),&[],diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rsindex 62750b3152..c52d091f79 100644--- a/crates/ui-egui/src/control.rs+++ b/crates/ui-egui/src/control.rs@@ -366,12 +366,21 @@ fn with_timings(mut reply: Value, timed: bool, rows: Vec<Value>, total_ms: f64)/// file the request reaches must lie inside them (docs/mcp.md). `None`: it names none.pub fn request_scope(app: &SolveApp, params: &Value) -> Result<Option<vfs::PathScope>, String> {let Some(allowed) = params.get("allow_paths") else { return Ok(None) };- let Some(roots) = allowed.as_array().and_then(|a| a.iter().map(|r| r.as_str().map(std::path::PathBuf::from)).collect::<Option<Vec<_>>>()) else {+ let folders = |v: &Value| v.as_array().and_then(|a| a.iter().map(|r| r.as_str().map(std::path::PathBuf::from)).collect::<Option<Vec<_>>>());+ let Some(roots) = folders(allowed) else {return Err("`allow_paths` must be a list of folders".into());};+ // The folders the agent opened or saved a design in (#7181), judged as the open design's is.+ let designs = match params.get("design_folders") {+ None => Vec::new(),+ Some(v) => folders(v)+ .filter(|d| d.len() <= vfs::MAX_DESIGN_FOLDERS)+ .ok_or_else(|| format!("`design_folders` must be a list of at most {} folders", vfs::MAX_DESIGN_FOLDERS))?,+ };// Plus the app's own recovery folder and, when it is a safe one, the open design's folder.let roots = roots.into_iter().chain(solidcraft_engine::recovery::default_dir());- Ok(Some(vfs::PathScope::new(roots).with_design(app.session.path.as_deref())))+ let scope = designs.iter().fold(vfs::PathScope::new(roots), |s, d| s.with_design_folder(d));+ Ok(Some(scope.with_design(app.session.path.as_deref())))}/// What a picture of the view shows: the model as the window shows it (theme and colour vision@@ -420,6 +429,7 @@ pub fn handle(app: &mut SolveApp, ctx: &egui::Context, req: &ControlRequest) ->let mut p = req.params.clone();if let Some(o) = p.as_object_mut() {o.remove("allow_paths");+ o.remove("design_folders");}vfs::scoped(Some(scope), || dispatch(app, ctx, &req.method, &p))}@@ -1916,6 +1926,47 @@ mod tests {assert!(path.is_file());}+ /// A request's `design_folders` (where its MCP agent opened or saved a design, #7181) count+ /// as the open design's folder does: their files are reachable, their hidden files and the+ /// folders beside them are not, and a list that is not one of at most+ /// `vfs::MAX_DESIGN_FOLDERS` folders is refused.+ #[test]+ fn a_requests_design_folders_count_as_the_open_designs() {+ let mut s = Session::default();+ s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10})).unwrap();+ let mut app = SolveApp::new(s, Services::default());+ let base = vfs::temp_dir().join(format!("solidcraft-control-design-folders-{}", std::process::id()));+ let (root, proj, out) = (base.join("root"), base.join("proj"), base.join("out"));+ for d in [&root, &proj.join(".git"), &out] {+ std::fs::create_dir_all(d).unwrap();+ }+ let at = |d: &std::path::Path, f: &str| d.join(f).to_string_lossy().to_string();+ let mut call = |path: String, designs: Value| {+ let params =+ json!({"command": "file.export", "params": {"path": path}, "allow_paths": [root.to_string_lossy()], "design_folders": designs});+ let (req, _rx) = ControlRequest::new("engine.execute", params);+ match handle(&mut app, &crate::fonts::test_context(), &req) {+ Outcome::Done(v) => v,+ Outcome::Screenshot { path } => json!({"ok": true, "screenshot": path}),+ }+ };+ let designs = json!([proj.to_string_lossy()]);+ assert_eq!(call(at(&proj, "a.step"), designs.clone())["ok"], true);+ for p in [at(&proj, ".secret.step"), at(&proj, ".git/a.step"), at(&out, "a.step")] {+ let v = call(p.clone(), designs.clone());+ assert!(v["ok"] == false && v.to_string().contains("outside the folders this agent may use"), "{p}: {v}");+ }+ assert!(!proj.join(".secret.step").exists() && !proj.join(".git/a.step").exists());+ assert_eq!(std::fs::read_dir(&out).unwrap().count(), 0, "nothing written beside it");+ let too_many = json!(vec![proj.to_string_lossy(); vfs::MAX_DESIGN_FOLDERS + 1]);+ for bad in [json!(proj.to_string_lossy()), json!([1]), too_many] {+ let v = call(at(&proj, "b.step"), bad);+ assert!(v["error"].as_str().is_some_and(|e| e.contains("design_folders")), "{v}");+ }+ assert!(!proj.join("b.step").exists());+ let _ = std::fs::remove_dir_all(&base);+ }+/// `ui.camera` reads the camera and sets it; its reply, passed back, sets the same view/// again. Fields left out keep their values, `fit` frames occurrences, and a refused field/// changes nothing.diff --git a/docs/control-protocol.md b/docs/control-protocol.mdindex 4808a6feae..848d3b5aea 100644--- a/docs/control-protocol.md+++ b/docs/control-protocol.md@@ -124,7 +124,9 @@ reads, writes or deletes (command paths such as `file.export`'s `path` or `doc.r`dir`, `ui.render`, `ui.screenshot`) must then lie inside one of those folders after `..` andsymlinks are resolved, or the request fails with `… outside the folders this agent may use …`.The app adds its own recovery folder and, when it lies safely inside the home folder and not in-a hidden folder, the open design's folder (whose hidden files stay out of reach). The bridged+a hidden folder, the open design's folder (whose hidden files stay out of reach). With+`allow_paths`, `design_folders: ["/abs/folder", …]` (at most 16) names folders the agent opened+or saved a design in; each counts on the open design folder's terms. The bridgedMCP server sends its folders this way on every request ([mcp.md](mcp.md)). Without`allow_paths` file paths are not limited: a client holding the token can do what the user can.diff --git a/docs/mcp.md b/docs/mcp.mdindex 0d14256d4e..079f0781fa 100644--- a/docs/mcp.md+++ b/docs/mcp.md@@ -77,11 +77,19 @@ design is left as it was. Calls bridged to the app are not checked yet.Tool calls read, write and delete files only inside the server's folders:-- the folder of the open design (the `--in` design, or whatever the agent last opened or saved),- but only when it lies strictly inside your home folder (or the temporary folder) and not in a- hidden folder. Home itself, a folder above it (`/`, `/home`, `/Users`, a drive's root),- hidden folders such as `~/.config` and folders elsewhere don't count. Hidden files and folders- inside the design's folder (`.env`, `.git`) are out of reach too;+- the folder of the open design (the `--in` design, the design open in the app, or whatever+ the agent last opened or saved), but only when it lies strictly inside your home folder (or+ the temporary folder) and not in a hidden folder. Home itself, a folder above it (`/`,+ `/home`, `/Users`, a drive's root), hidden folders such as `~/.config` and folders elsewhere+ don't count. Hidden files and folders inside the design's folder (`.env`, `.git`) are out of+ reach too;+- on the same terms, every folder the agent opened or saved a design file in during this+ server's run (`open`, `save`, or `doc.open`, `file.save` and `file.save_as` through `execute`+ or `batch`, with the path given in full) and, headless, every folder a design was open in,+ until the server stops (the 16 most recent). So after a new design, an opened STEP file or a+ save-as elsewhere, the agent can still save beside the design it worked on. Such a call+ succeeded only because its folder was already one of the agent's, so no folder joins just+ because the agent names it;- SolidCraft's own recovery folder, so `doc.recovery_list`, `doc.recover` and`doc.recovery_discard` work out of the box (discarding deletes only real recovery entries);- the server's own scratch folder (a new private `solidcraft-mcp-*` folder in the temporary@@ -116,7 +124,15 @@ solidcraft-cli mcp --allow-path ~/designs --allow-path ~/exportssolidcraft-cli mcp --allow-any-path # no limit (the behaviour before this option existed)```-Bridged, the server sends its folders with every request (`allow_paths`, see+When a `save` (or any other call) is refused with `… outside the folders this agent may use …`,+add the folder to the server's `args` in your MCP client's configuration (the `mcpServers`+entries below, or what `solidcraft-cli mcp setup` wrote), for example+`"args": ["mcp", "--allow-path", "/Users/NAME/Documents/Designs"]`, and restart the client.+An agent should ask you to do that rather than save through the app's control port, which+knows nothing of these folders.++Bridged, the server sends its folders with every request (`allow_paths`, and the folders the+agent opened or saved a design in as `design_folders`, see[control-protocol.md](control-protocol.md)) and the app adds its own recovery folder and thefolder of the design open in it, under the same rules, so give absolute paths: a relative oneresolves against the app's working folder, not the server's. The app's own