LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
MCP: render and screenshot PNGs go through a private temp folder (#2573)
Bruno-Alumn8341959e5ece
diff --git a/crates/mcp/src/tests.rs b/crates/mcp/src/tests.rsindex 59e7ba3eb..7cc61a318 100644--- a/crates/mcp/src/tests.rs+++ b/crates/mcp/src/tests.rs@@ -539,3 +539,66 @@ fn the_clipboard_tool_cuts_copies_and_pastes_in_the_app() {assert!(!r.is_error, "{r:?}");assert_eq!(b.0, vec![("ui.clipboard".to_string(), json!({"action": "paste", "text": "travel"}))]);}++/// A running app that writes the PNG `ui.render` / `ui.screenshot` ask for. It notes each path and+/// what its folder looked like then; with `dies_mid_write` it leaves a half-written temp file and+/// fails instead, like an app that quits part-way through.+struct PngWriter {+ seen: Vec<(std::path::PathBuf, Option<std::fs::Metadata>)>,+ dies_mid_write: bool,+}++impl Backend for PngWriter {+ fn call(&mut self, method: &str, params: Value) -> Result<Value, String> {+ assert!(matches!(method, "ui.render" | "ui.screenshot"), "{method}");+ let path = std::path::PathBuf::from(params["path"].as_str().unwrap());+ self.seen.push((path.clone(), path.parent().and_then(|d| std::fs::symlink_metadata(d).ok())));+ if self.dies_mid_write {+ std::fs::write(path.with_file_name(".lightcraft-mcp-test.tmp"), b"half a png").unwrap();+ return Err("connection closed".into());+ }+ crate::write_image(&path, &lightcraft_raster::Rgba8::new(1, 1), 92)?;+ Ok(json!({"width": 1, "height": 1}))+ }+ fn has_ui(&self) -> bool {+ true+ }+ fn describe(&self) -> String {+ "png writer".into()+ }+}++/// Renders and screenshots reach the agent through a PNG the app writes. In a shared /tmp other+/// users could read it or take its predictable name first and make the render fail, so it goes in+/// a new folder of its own, private on Unix, that is gone afterwards even when the write fails+/// (#2573).+#[test]+fn render_and_screenshot_pngs_go_through_a_private_folder() {+ let mut b = PngWriter { seen: vec![], dies_mid_write: false };+ for (tool, args) in [("render_photo", json!({"id": 1})), ("render_preview", json!({"id": 1})), ("screenshot", json!({}))] {+ let r = call_tool(&mut b, tool, &args);+ assert!(!r.is_error, "{tool}: {r:?}");+ assert_eq!(r.image().map(|(_, mime)| mime), Some("image/png"), "{tool}: {r:?}");+ }+ b.dies_mid_write = true;+ assert!(call_tool(&mut b, "screenshot", &json!({})).is_error);+ assert_eq!(b.seen.len(), 4);+ let temp = std::env::temp_dir();+ let mut folders = vec![];+ for (file, folder) in &b.seen {+ let dir = file.parent().unwrap();+ let meta = folder.as_ref().unwrap();+ assert!(meta.is_dir() && !meta.file_type().is_symlink(), "{}", dir.display());+ assert_ne!(dir, temp, "{} is right in the shared temp dir", file.display());+ assert_eq!(dir.parent(), Some(temp.as_path()), "{}", file.display());+ assert!(dir.file_name().unwrap().to_string_lossy().starts_with("lightcraft-mcp-"), "{}", dir.display());+ #[cfg(unix)]+ {+ use std::os::unix::fs::PermissionsExt;+ assert_eq!(meta.permissions().mode() & 0o777, 0o700, "{}", dir.display());+ }+ assert!(!dir.exists(), "{} was left behind", dir.display());+ assert!(!folders.contains(&dir), "{} was used twice", dir.display());+ folders.push(dir);+ }+}diff --git a/crates/mcp/src/tools.rs b/crates/mcp/src/tools.rsindex 8f782bb9d..11c25f087 100644--- a/crates/mcp/src/tools.rs+++ b/crates/mcp/src/tools.rs@@ -2,6 +2,7 @@//! per command in the engine's command registry (`cmd_<id with . → _>`), all forwarded to a//! [`Backend`] as control-channel methods.+use std::hash::{BuildHasher, Hasher, RandomState};use std::sync::atomic::{AtomicU64, Ordering};use serde_json::{Map, Value, json};@@ -437,9 +438,48 @@ fn activate(b: &mut dyn Backend, args: &Value) -> Result<(), String> {Ok(())}-fn temp_path(tag: &str) -> std::path::PathBuf {- static N: AtomicU64 = AtomicU64::new(0);- std::env::temp_dir().join(format!("lightcraft-mcp-{}-{}-{tag}.png", std::process::id(), N.fetch_add(1, Ordering::Relaxed)))+/// Where the backend writes a render or screenshot for us to read back: `<tag>.png` in a new+/// `lightcraft-mcp-<pid>-<random>` folder in the temp dir, private to this user on Unix (0700).+/// Straight in a shared /tmp, other users could read the PNG, and a name they took first made the+/// render fail (#2573). Dropping this removes the folder and whatever is in it.+struct TempPng {+ dir: std::path::PathBuf,+ file: std::path::PathBuf,+}++impl TempPng {+ fn new(tag: &str) -> Result<Self, String> {+ static N: AtomicU64 = AtomicU64::new(0);+ let temp = std::env::temp_dir();+ for _ in 0..100 {+ let mut h = RandomState::new().build_hasher();+ h.write_u64(N.fetch_add(1, Ordering::Relaxed));+ let dir = temp.join(format!("lightcraft-mcp-{}-{:016x}", std::process::id(), h.finish()));+ #[cfg(unix)]+ let builder = {+ use std::os::unix::fs::DirBuilderExt;+ let mut b = std::fs::DirBuilder::new();+ b.mode(0o700);+ b+ };+ #[cfg(not(unix))]+ let builder = std::fs::DirBuilder::new();+ // Never recursive: a name someone else made first fails and is not used.+ match builder.create(&dir) {+ Ok(()) => return Ok(Self { file: dir.join(format!("{tag}.png")), dir }),+ Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => continue,+ Err(e) => return Err(format!("cannot make a private temporary folder in {}: {e}", temp.display())),+ }+ }+ Err(format!("cannot make a private temporary folder in {}: every name tried is taken", temp.display()))+ }+}++impl Drop for TempPng {+ fn drop(&mut self) {+ // Also removes the temp file a backend that died mid-write leaves next to the PNG.+ let _ = std::fs::remove_dir_all(&self.dir);+ }}/// Read a PNG the backend wrote, optionally downscale / re-encode as JPEG, and wrap it as image@@ -512,26 +552,32 @@ fn render_photo(b: &mut dyn Backend, args: &Value) -> ToolResult {},};let Some(id) = id else { return ToolResult::error("no active photo: import or select one, or pass `id`") };- let file = temp_path("render");- let path = file.to_string_lossy().to_string();+ let tmp = match TempPng::new("render") {+ Ok(t) => t,+ Err(e) => return ToolResult::error(e),+ };+ let path = tmp.file.to_string_lossy().to_string();let meta = match b.call("ui.render", json!({"id": id, "size": size, "path": path})) {Ok(m) => m,Err(e) => return ToolResult::error(e),};let mut meta = meta;meta["id"] = json!(id);- image_result(&file, None, args.get("format").and_then(Value::as_str).unwrap_or("png"), args.get("path").and_then(Value::as_str), meta)+ image_result(&tmp.file, None, args.get("format").and_then(Value::as_str).unwrap_or("png"), args.get("path").and_then(Value::as_str), meta)}fn screenshot(b: &mut dyn Backend, args: &Value) -> ToolResult {if let Err(e) = check_save_path(b, args) {return ToolResult::error(e);}- let file = temp_path("screenshot");- let path = file.to_string_lossy().to_string();+ let tmp = match TempPng::new("screenshot") {+ Ok(t) => t,+ Err(e) => return ToolResult::error(e),+ };+ let path = tmp.file.to_string_lossy().to_string();match b.call("ui.screenshot", json!({"path": path})) {Ok(meta) => image_result(- &file,+ &tmp.file,Some(args.get("maxSize").and_then(Value::as_u64).unwrap_or(1600).clamp(64, 8192) as u32),args.get("format").and_then(Value::as_str).unwrap_or("png"),args.get("path").and_then(Value::as_str),