From 0520910bfd4ff6d24c850f4a20a604f6128f87bf Mon Sep 17 00:00:00 2001 From: raykholo Date: Sat, 24 Oct 2026 17:28:12 +0000 Subject: [PATCH] Control: name the token file and spot a stale one when a call is unauthorized (#4664) (#4670) * claim: #4664 * Control: name the token file and spot a stale one when a call is unauthorized (#4664) When the app refuses a token that the MCP client read from a token file, the error now names that file, when it was written and how long ago, without printing the token. The app also writes `.pid` beside the token file (its process id and, on Linux, its start time) and removes both at exit; when that process has exited, the error says the token file is stale. The process check runs only after a refusal, and the token file itself stays one line, so existing clients keep working. Document force-quit leftovers and the MSIX AppData redirection. * Bench assistant: read the token out of the new ClientToken Co-Authored-By: Claude Sonnet 5.5 --------- Co-authored-by: bherbruck Co-authored-by: Claude Sonnet 5.5 --- apps/solidcraft-cli/src/bench_assistant.rs | 1 + apps/solidcraft/src/control_server.rs | 2 +- crates/engine/src/control_auth.rs | 231 ++++++++++++++++++++- crates/mcp/src/backend.rs | 11 +- docs/control-protocol.md | 10 +- 5 files changed, 239 insertions(+), 16 deletions(-) diff --git a/apps/solidcraft-cli/src/bench_assistant.rs b/apps/solidcraft-cli/src/bench_assistant.rs index d6f0740b9..9ec3b1b31 100644 --- a/apps/solidcraft-cli/src/bench_assistant.rs +++ b/apps/solidcraft-cli/src/bench_assistant.rs @@ -69,6 +69,7 @@ impl Control { return Err("--connect requires a loopback address and a nonzero port (the app listens on 127.0.0.1)".into()); } let token = solidcraft_engine::control_auth::client_token(addr.port(), token) + .map(|t| t.token) .ok_or("no control token: pass --token, set SOLIDCRAFT_CONTROL_TOKEN, or run on the app's computer (its token file)")?; if token.len() > 4096 { return Err("the control token is longer than 4096 bytes".into()); diff --git a/apps/solidcraft/src/control_server.rs b/apps/solidcraft/src/control_server.rs index ea4a65d4d..3cb96e332 100644 --- a/apps/solidcraft/src/control_server.rs +++ b/apps/solidcraft/src/control_server.rs @@ -35,7 +35,7 @@ fn new_token() -> Option { pub fn remove_token_file() { if let Ok(files) = TOKEN_FILES.lock() { for p in files.iter() { - let _ = std::fs::remove_file(p); + control_auth::remove_token_file(p); } } if let Some(port) = APP_PORT.lock().ok().and_then(|p| *p) { diff --git a/crates/engine/src/control_auth.rs b/crates/engine/src/control_auth.rs index b6162e905..125fca8ed 100644 --- a/crates/engine/src/control_auth.rs +++ b/crates/engine/src/control_auth.rs @@ -2,10 +2,12 @@ //! makes a random token, writes it to a file only the user can read //! ([`token_path`]) and refuses every connection whose first request doesn't carry it, so other //! users on the same machine (loopback is shared, on Windows across remote-desktop sessions too) -//! can't drive the app. Clients find it with [`client_token`]. +//! can't drive the app. Clients find it with [`client_token`]. Next to it, `.pid` names +//! the process that wrote it, so a client refused with a leftover token can say the file is stale. -use std::io::{Error, ErrorKind, Result, Write}; +use std::io::{Error, ErrorKind, Read, Result, Write}; use std::path::{Path, PathBuf}; +use std::time::{SystemTime, UNIX_EPOCH}; /// Shortest token accepted from `SOLIDCRAFT_CONTROL_TOKEN` (hex characters). pub const MIN_TOKEN_LEN: usize = 32; @@ -106,16 +108,151 @@ pub fn env_token() -> Option { /// The token a client sends to the app on `port`: `explicit` (`--token`), else /// `SOLIDCRAFT_CONTROL_TOKEN`, else the app's token file. -pub fn client_token(port: u16, explicit: Option<&str>) -> Option { +pub fn client_token(port: u16, explicit: Option<&str>) -> Option { if let Some(t) = explicit.map(str::trim).filter(|t| !t.is_empty()) { - return Some(t.to_string()); + return Some(ClientToken { token: t.to_string(), file: None }); } if let Some(t) = env_token() { - return Some(t); + return Some(ClientToken { token: t, file: None }); } // Read directly, not through `vfs`: the app's own file, outside any agent's folders. - let text = std::fs::read_to_string(token_path(port)?).ok().filter(|t| t.len() <= 4096)?; - Some(text.trim().to_string()).filter(|t| !t.is_empty()) + read_token_file(&token_path(port)?) +} + +/// A client token and, when it came from a token file, where that file is. +pub struct ClientToken { + pub token: String, + pub file: Option, +} + +/// The token file a client read: its path, when it was written and the process that wrote it. +pub struct TokenSource { + pub path: PathBuf, + pub modified: Option, + /// From `.pid`: the writer's process id and, on Linux, its start time. + pub writer: Option<(u32, Option)>, +} + +impl ClientToken { + /// The app's `error`, and for a refused token read from a file, which file it was, when it + /// was written and whether the instance that wrote it has exited. Never the token itself. + pub fn explain_error(&self, error: &str) -> String { + let Some(src) = &self.file else { return error.to_string() }; + if !error.starts_with("unauthorized") { + return error.to_string(); + } + let written = src + .modified + .and_then(|t| t.duration_since(UNIX_EPOCH).ok()) + .map(|t| crate::crash::utc(t.as_secs())) + .unwrap_or_else(|| "at an unknown time".into()); + let age = src.modified.and_then(|t| t.elapsed().ok()).map(|d| format!(" ({} s ago)", d.as_secs())).unwrap_or_default(); + let path = src.path.display(); + match src.writer.filter(|(pid, start)| writer_exited(*pid, *start)) { + Some((pid, _)) => format!( + "{error}; stale token file from an instance that exited (process {pid}): {path}, written {written}{age}; delete that file or restart SolidCraft" + ), + None => format!("{error}; token from {path}, written {written}{age}; if SolidCraft was force-quit, restart it or delete that file"), + } + } +} + +/// Files bigger than this are not token files. +const MAX_TOKEN_FILE: u64 = 4096; + +fn read_token_file(path: &Path) -> Option { + let f = std::fs::File::open(path).ok()?; + let modified = f.metadata().ok().and_then(|m| m.modified().ok()); + let mut text = String::new(); + f.take(MAX_TOKEN_FILE + 1).read_to_string(&mut text).ok()?; + if text.len() as u64 > MAX_TOKEN_FILE { + return None; + } + let token = text.trim(); + if token.is_empty() { + return None; + } + let path = std::fs::canonicalize(path).unwrap_or_else(|_| path.to_path_buf()); + let writer = read_pid_file(&pid_path(&path)); + Some(ClientToken { token: token.to_string(), file: Some(TokenSource { path, modified, writer }) }) +} + +/// The process file beside the token file `path`: `7878.token` → `7878.pid`. +pub fn pid_path(path: &Path) -> PathBuf { + path.with_extension("pid") +} + +/// ` []`; anything else (or no file) is no information. +fn read_pid_file(path: &Path) -> Option<(u32, Option)> { + let mut text = String::new(); + std::fs::File::open(path).ok()?.take(256).read_to_string(&mut text).ok()?; + let mut fields = text.split_whitespace(); + let pid = fields.next()?.parse::().ok().filter(|&pid| pid > 0)?; + Some((pid, fields.next().and_then(|s| s.parse().ok()))) +} + +/// Whether the process that wrote a token file is known to be gone: not running, or its id now +/// belongs to a process that started at another time. Unknown counts as running. +fn writer_exited(pid: u32, start: Option) -> bool { + process_running(pid) == Some(false) || start.zip(process_start(pid)).is_some_and(|(saved, now)| saved != now) +} + +/// Whether process `pid` runs; `None` when that can't be found out. +fn process_running(pid: u32) -> Option { + #[cfg(target_os = "linux")] + { + if !Path::new("/proc/self").exists() { + return None; + } + match std::fs::metadata(format!("/proc/{pid}")) { + Ok(_) => Some(true), + Err(e) if e.kind() == ErrorKind::NotFound => Some(false), + Err(_) => None, + } + } + #[cfg(all(unix, not(target_os = "linux")))] + { + let output = std::process::Command::new("ps").args(["-p", &pid.to_string(), "-o", "pid="]).output().ok()?; + if output.status.success() { + return Some(true); + } + (output.status.code() == Some(1) && output.stdout.iter().all(u8::is_ascii_whitespace)).then_some(false) + } + #[cfg(windows)] + { + use std::os::windows::process::CommandExt; + let output = std::process::Command::new("tasklist") + .args(["/FI", &format!("PID eq {pid}"), "/FO", "CSV", "/NH"]) + .creation_flags(0x0800_0000) + .output() + .ok()?; + if !output.status.success() || output.stdout.is_empty() { + return None; + } + // `"image","pid",…` per process; with no match, a message line without a pid. + let text = String::from_utf8_lossy(&output.stdout); + Some(text.lines().any(|line| line.split("\",\"").nth(1).and_then(|s| s.trim_matches('"').parse::().ok()) == Some(pid))) + } + #[cfg(not(any(unix, windows)))] + { + let _ = pid; + None + } +} + +/// Linux: the process's start time (clock ticks after boot), which tells a reused id apart. +fn process_start(pid: u32) -> Option { + #[cfg(target_os = "linux")] + { + let mut stat = String::new(); + std::fs::File::open(format!("/proc/{pid}/stat")).ok()?.take(4096).read_to_string(&mut stat).ok()?; + stat.rsplit_once(')')?.1.split_whitespace().nth(19)?.parse().ok() + } + #[cfg(not(target_os = "linux"))] + { + let _ = pid; + None + } } /// `a == b`, taking the same time wherever they differ. @@ -127,7 +264,7 @@ pub fn tokens_match(a: &str, b: &str) -> bool { /// Write `token` to `path`, readable and writable only by the user: the folder is made `0700` /// and the file `0600` on Unix; on Windows the file's inherited permissions are replaced by one /// entry for the user (`icacls`) before the token goes in. A file left by an earlier launch is -/// replaced. +/// replaced. The process file beside it ([`pid_path`]) records this process, best effort. pub fn write_token_file(path: &Path, token: &str) -> Result<()> { let dir = path.parent().ok_or_else(|| Error::new(ErrorKind::InvalidInput, "no folder"))?; std::fs::create_dir_all(dir)?; @@ -145,7 +282,17 @@ pub fn write_token_file(path: &Path, token: &str) -> Result<()> { restrict_to_user(path)?; f.write_all(token.as_bytes())?; f.write_all(b"\n")?; - f.sync_all() + f.sync_all()?; + let pid = std::process::id(); + let line = process_start(pid).map_or_else(|| format!("{pid}\n"), |start| format!("{pid} {start}\n")); + let _ = std::fs::write(pid_path(path), line); + Ok(()) +} + +/// Remove a token file this launch wrote, and its process file. +pub fn remove_token_file(path: &Path) { + let _ = std::fs::remove_file(path); + let _ = std::fs::remove_file(pid_path(path)); } /// Windows: drop inherited entries and grant only the current user full access. @@ -170,7 +317,7 @@ pub struct TokenFile(pub PathBuf); impl Drop for TokenFile { fn drop(&mut self) { - let _ = std::fs::remove_file(&self.0); + remove_token_file(&self.0); } } @@ -221,6 +368,66 @@ mod tests { let _ = std::fs::remove_dir_all(&dir); } + /// A one-line token file (and one with no process file) still reads. + #[test] + fn a_token_file_reads_with_and_without_its_process_file() { + let dir = std::env::temp_dir().join(format!("solidcraft-control-read-{}", std::process::id())); + std::fs::create_dir_all(&dir).unwrap(); + let path = dir.join("7879.token"); + std::fs::write(&path, "legacy-token\n").unwrap(); + let client = read_token_file(&path).unwrap(); + assert_eq!(client.token, "legacy-token"); + let src = client.file.as_ref().unwrap(); + assert_eq!(src.path, std::fs::canonicalize(&path).unwrap()); + assert!(src.modified.is_some() && src.writer.is_none()); + std::fs::write(pid_path(&path), "not a pid\n").unwrap(); + assert!(read_token_file(&path).unwrap().file.unwrap().writer.is_none()); + std::fs::write(&path, "x".repeat(4097)).unwrap(); + assert!(read_token_file(&path).is_none()); + let _ = std::fs::remove_dir_all(&dir); + } + + /// A refused token names its file and when it was written, never the token. + #[test] + fn unauthorized_error_names_the_token_file() { + let path = PathBuf::from("control/7878.token"); + let modified = Some(UNIX_EPOCH + std::time::Duration::from_secs(1_700_000_000)); + let client = ClientToken { token: "secret-token".into(), file: Some(TokenSource { path: path.clone(), modified, writer: None }) }; + let error = client.explain_error("unauthorized: send the control token"); + assert!(error.contains(&format!("token from {}, written 2023-11-14T22:13:20Z (", path.display())), "{error}"); + assert!(error.contains("restart it or delete that file") && !error.contains("secret-token"), "{error}"); + assert_eq!(client.explain_error("unknown method"), "unknown method"); + let explicit = client_token(0, Some("explicit-token")).unwrap(); + assert!(explicit.token == "explicit-token" && explicit.file.is_none()); + assert_eq!(explicit.explain_error("unauthorized"), "unauthorized"); + } + + /// A process file naming a process that has exited marks the token file stale. + #[cfg(any(unix, windows))] + #[test] + fn a_token_file_from_an_exited_process_is_stale() { + let mut child = std::process::Command::new(std::env::current_exe().unwrap()) + .args(["--exact", "control_auth::tests::tokens_compare_whole"]) + .stdout(std::process::Stdio::null()) + .spawn() + .unwrap(); + let pid = child.id(); + assert!(child.wait().unwrap().success()); + let source = |writer| Some(TokenSource { path: PathBuf::from("7878.token"), modified: None, writer }); + let stale = ClientToken { token: "secret-token".into(), file: source(Some((pid, None))) }; + let error = stale.explain_error("unauthorized"); + assert!(error.contains(&format!("stale token file from an instance that exited (process {pid}): 7878.token")), "{error}"); + assert!(!error.contains("secret-token")); + let live = ClientToken { token: "t".into(), file: source(Some((std::process::id(), process_start(std::process::id())))) }; + assert!(!live.explain_error("unauthorized").contains("stale")); + #[cfg(target_os = "linux")] + { + let reused = process_start(std::process::id()).map(|s| s + 1); + let reused = ClientToken { token: "t".into(), file: source(Some((std::process::id(), reused))) }; + assert!(reused.explain_error("unauthorized").contains("stale token file")); + } + } + /// The token file is the user's alone, and a client reads it back. #[cfg(unix)] #[test] @@ -237,8 +444,10 @@ mod tests { assert_eq!(mode(&path), 0o600); assert_eq!(mode(path.parent().unwrap()), 0o700); assert_eq!(std::fs::read_to_string(&path).unwrap().trim(), "0123456789abcdef0123456789abcdef"); + let writer = read_token_file(&path).unwrap().file.unwrap().writer; + assert_eq!(writer.map(|(pid, _)| pid), Some(std::process::id())); drop(TokenFile(path.clone())); - assert!(!path.exists()); + assert!(!path.exists() && !pid_path(&path).exists()); let _ = std::fs::remove_dir_all(&dir); } } diff --git a/crates/mcp/src/backend.rs b/crates/mcp/src/backend.rs index 1e168ca41..e2e71cf0f 100644 --- a/crates/mcp/src/backend.rs +++ b/crates/mcp/src/backend.rs @@ -267,8 +267,9 @@ impl Remote { } 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). - if let Some(t) = solidcraft_engine::control_auth::client_token(self.port, self.explicit_token.as_deref()) { - msg["token"] = json!(t); + let token = solidcraft_engine::control_auth::client_token(self.port, self.explicit_token.as_deref()); + if let Some(t) = &token { + msg["token"] = json!(t.token); } msg.to_string() } @@ -422,7 +423,11 @@ impl Remote { self.settle_earlier()?; return self.call_once(method, params, false); } - outcome(&v) + // A refused token: say which token file it came from (and whether it is stale). + outcome(&v).map_err(|error| { + solidcraft_engine::control_auth::client_token(self.port, self.explicit_token.as_deref()) + .map_or_else(|| error.clone(), |t| t.explain_error(&error)) + }) } } diff --git a/docs/control-protocol.md b/docs/control-protocol.md index 25dc503f9..63800ba8f 100644 --- a/docs/control-protocol.md +++ b/docs/control-protocol.md @@ -44,7 +44,15 @@ launch and writes it, as one line of hex, to a file only the user can read: On Unix the folder is `0700` and the file `0600`; on Windows the file's inherited permissions are replaced by a single entry for the user. `SOLIDCRAFT_CONTROL_DIR` moves the folder. The file is removed when the app exits, and the next launch writes a new token. The token file's path is -printed to stderr at start-up. +printed to stderr at start-up. Beside it, `.pid` holds the app's process id (and, on Linux, +its start time). + +An app that is force-quit can't remove its files, so a later client may send that launch's token. +When the app refuses it, `solidcraft-cli mcp` names the token file it read and when it was +written, and says the file is stale when the process in `.pid` has exited. Delete the file +or restart SolidCraft. On Windows, an app or client started from inside an MSIX-packaged app (and +the tools it launches) has its AppData redirected: it writes and reads +`%LOCALAPPDATA%\Packages\\LocalCache\Local\SolidCraft\control\` before the folder above. The first request on a connection must carry the token as a top-level `"token"` member (`{"id": 1, "method": "ui.inspect", "params": {}, "token": "…"}`); later requests on the same