From 6b16ec2b416a91abaf2ccc49a8a29921c3a75546 Mon Sep 17 00:00:00 2001 From: David Mann Date: Wed, 18 Nov 2026 03:19:07 +0100 Subject: [PATCH] craft-control agents: second review round (#2141) - The token is passed on as the app wrote it (trimmed): craft-control's server compares exactly and accepts any CONTROL_TOKEN of 32+ chars. The token file is checked as a regular file before it is opened (a FIFO would block the open). - Allow Agent Control off counts as not allowed on the CLI's side too. - A window route is dropped once no app accepts agents. - A headless session with the app's agent folders ends when the person stops letting agents in. - The launch timeout is capped and the deadline computed without overflow; the poll interval is kept between 1 ms and 1 s. - The connect error names the app's window; the guide says to remove the connection file on quit and that one process per settings folder accepts agents; the AppImage mount is compared after resolving links. - Tests for each, and a wider margin in the queued-start test. --- crates/control/src/agents/live.rs | 139 +++++++++++++++++++++--------- crates/control/src/agents/mod.rs | 11 ++- crates/control/src/lib.rs | 3 +- crates/control/tests/agents.rs | 127 +++++++++++++++++++++++++-- 4 files changed, 227 insertions(+), 53 deletions(-) diff --git a/crates/control/src/agents/live.rs b/crates/control/src/agents/live.rs index a151a137b..49b242ff5 100644 --- a/crates/control/src/agents/live.rs +++ b/crates/control/src/agents/live.rs @@ -7,15 +7,20 @@ //! //! - An app that accepts agents: the call goes to its open window ([`Route::Window`]). The same //! port, token and process id keep the window client the app made; any change makes a new one. -//! - No app accepts agents, and the person doesn't let agents use it: a session without a window -//! with only the folders given to the command ([`LiveConfig::read_roots`], [`LiveConfig::write_root`]), -//! as `mcp` always worked. The app's own folders are for agents the person let in. +//! - No app accepts agents, and the person doesn't let agents use it ([`Consent::allowed`] off, or +//! [`AgentSettings::allow_agent_control`] off, under which the app doesn't listen either): a +//! session without a window with only the folders given to the command +//! ([`LiveConfig::read_roots`], [`LiveConfig::write_root`]), as `mcp` always worked. The app's own +//! folders are for agents the person let in. //! - No app accepts agents, but agents are allowed: the closed-app choice decides //! ([`LiveConfig::when_closed`], otherwise [`AgentSettings::when_app_closed`]): start the app and //! wait until it accepts agents, a headless session with the app's agent folders (the command's //! folders win), or an error that says what to do. //! -//! Once headless, the session stays headless: documents don't move under the agent. Lookups are +//! Once headless, the session stays headless: documents don't move under the agent. Only a session +//! made with the app's agent folders ends when the person stops letting agents in; the next call +//! gets one with the command's folders. A window route is dropped as soon as no app accepts agents. +//! Lookups are //! serialised, so concurrent calls start the app once: calls that queued while a start was under //! way and found no window get that start's error rather than starting the app again; a call made //! after it tries again. @@ -49,6 +54,10 @@ pub type HeadlessFn = Box Result + Sen pub const LAUNCH_TIMEOUT: Duration = Duration::from_secs(45); /// How often a starting app's connection file is looked for. pub const LAUNCH_POLL: Duration = Duration::from_millis(250); +/// The longest [`LiveConfig::launch_timeout`] used; a longer one is cut to this. +const MAX_LAUNCH_TIMEOUT: Duration = Duration::from_secs(600); +/// The range [`LiveConfig::poll`] is kept in. +const POLL_RANGE: (Duration, Duration) = (Duration::from_millis(1), Duration::from_secs(1)); /// The open window a call goes to: from the connection file, with the token from its token file. #[derive(Clone, PartialEq, Eq)] @@ -58,7 +67,7 @@ pub struct Window { pub port: u16, /// The app's process id. pub pid: u32, - /// The control token (hex digits, lower case). + /// The control token, as its token file holds it (trimmed). pub token: String, } @@ -80,8 +89,9 @@ impl fmt::Debug for Window { #[derive(Clone, Debug, Default, PartialEq, Eq)] #[non_exhaustive] pub struct Consent { - /// Agents may use the app ([`super::agents_allowed`]: with the suite's `AI-MCP` flag, the - /// ArtCraft Launcher's switch). + /// Agents may use the app: `agents_allowed(mcp_flag(), launcher_allows(""), legacy)` + /// ([`super::agents_allowed`]), with the suite's `AI-MCP` flag the ArtCraft Launcher's switch. + /// [`Live`] also requires [`AgentSettings::allow_agent_control`]. pub allowed: bool, /// The app's agent settings (closed-app choice, folders). pub settings: AgentSettings, @@ -130,9 +140,9 @@ pub struct LiveConfig { pub write_root: Option, /// Starts the app; `None` when this install can't ([`launcher`] found nothing to start). pub launch: Option, - /// How long a started app gets to accept agents ([`LAUNCH_TIMEOUT`]). + /// How long a started app gets to accept agents ([`LAUNCH_TIMEOUT`]; at most 10 minutes). pub launch_timeout: Duration, - /// How often a starting app is looked for ([`LAUNCH_POLL`]). + /// How often a starting app is looked for ([`LAUNCH_POLL`]; kept between 1 ms and 1 s). pub poll: Duration, consent: ConsentFn, connect: ConnectFn, @@ -168,8 +178,15 @@ impl LiveConfig { /// The port, token and process id a window client was made for: a restarted app may keep its /// port and token, but its old socket is gone. type WindowKey = (u16, String, u32); -/// The current route, and for a window the key it was made for. -type Current = Option<(Route, Option)>; +/// The route the last call took. +struct Current { + route: Route, + /// For a window, the key its client was made for. + key: Option, + /// A headless session that holds folders of the app's agent settings: it lasts only while + /// the person lets agents in. + app_folders: bool, +} /// Resolves each tool call of one MCP session; see the module docs. pub struct Live { @@ -178,7 +195,7 @@ pub struct Live { lookup: Mutex>, /// How many starts have finished, read before a call queues for `lookup`. finished: AtomicU64, - current: Mutex>, + current: Mutex>>, } impl Live { @@ -189,38 +206,67 @@ impl Live { /// The route the last [`Self::resolve`] chose, if any. pub fn current(&self) -> Option> { - self.current.lock().unwrap_or_else(PoisonError::into_inner).as_ref().map(|(r, _)| r.clone()) + self.current.lock().unwrap_or_else(PoisonError::into_inner).as_ref().map(|c| c.route.clone()) } - fn set(&self, route: Route, key: Option) -> Route { - *self.current.lock().unwrap_or_else(PoisonError::into_inner) = Some((route.clone(), key)); + fn set(&self, route: Route, key: Option, app_folders: bool) -> Route { + *self.current.lock().unwrap_or_else(PoisonError::into_inner) = Some(Current { route: route.clone(), key, app_folders }); route } + /// The headless session to keep using, if any: one made with the app's folders only while + /// agents are still `allowed`. A route that may not be kept is dropped. + fn sticky_headless(&self, allowed: bool) -> Option> { + let mut current = self.current.lock().unwrap_or_else(PoisonError::into_inner); + match current.as_ref() { + Some(c) if matches!(c.route, Route::Headless(_)) && (allowed || !c.app_folders) => Some(c.route.clone()), + Some(c) if matches!(c.route, Route::Headless(_)) => { + *current = None; + None + } + _ => None, + } + } + + /// Forgets a window route: no app accepts agents any more, so its client is for a socket + /// that is gone. + fn drop_window(&self) { + let mut current = self.current.lock().unwrap_or_else(PoisonError::into_inner); + if current.as_ref().is_some_and(|c| matches!(c.route, Route::Window(_))) { + *current = None; + } + } + /// Where the next tool call goes. Blocks; see the module docs. The error is the tool call's /// result. pub fn resolve(&self) -> Result, String> { let queued_at = self.finished.load(Ordering::Acquire); let mut last_failure = self.lookup.lock().unwrap_or_else(PoisonError::into_inner); - if let Some(route @ Route::Headless(_)) = self.current() { + let consent = (self.cfg.consent)(&self.cfg.config_dir); + // Allow Agent Control off refuses agents, as the app does: it doesn't listen then. + let allowed = consent.allowed && consent.settings.allow_agent_control; + if let Some(route) = self.sticky_headless(allowed) { return Ok(route); } - let consent = (self.cfg.consent)(&self.cfg.config_dir); if let Some(window) = self.find_app()? { return self.use_window(window); } - if !consent.allowed { - let folders = HeadlessFolders { read: self.cfg.read_roots.clone(), write: self.cfg.write_root.clone() }; - return self.headless(&folders, "the automation roots can't be used"); - } + self.drop_window(); let app = &self.cfg.app_name; + if !allowed { + let folders = HeadlessFolders { read: self.cfg.read_roots.clone(), write: self.cfg.write_root.clone() }; + return self.headless(&folders, false, &format!("{app} can't use the automation roots")); + } match self.cfg.when_closed.unwrap_or(consent.settings.when_app_closed) { WhenAppClosed::Error => Err(format!("{app} isn't running: open it, then try again.")), WhenAppClosed::Headless => { + let app_read = self.cfg.read_roots.is_empty() && consent.settings.read_folder().is_some(); + let app_write = self.cfg.write_root.is_none() && consent.settings.write_folder().is_some(); let read = if self.cfg.read_roots.is_empty() { consent.settings.read_folder().into_iter().collect() } else { self.cfg.read_roots.clone() }; let write = self.cfg.write_root.clone().or_else(|| consent.settings.write_folder()); - self.headless(&HeadlessFolders { read, write }, &format!("{app} isn't running and its agent folders can't be used")) + let why = format!("{app} isn't running and its agent folders can't be used"); + self.headless(&HeadlessFolders { read, write }, app_read || app_write, &why) } WhenAppClosed::Launch => { // A start finished while this call waited and the app still isn't there: its answer @@ -238,44 +284,51 @@ impl Live { } } - fn headless(&self, folders: &HeadlessFolders, why: &str) -> Result, String> { + /// A headless session with `folders` from now on; `app_folders` when some of them are the + /// app's agent folders. `why` leads its error. + fn headless(&self, folders: &HeadlessFolders, app_folders: bool, why: &str) -> Result, String> { let session = (self.cfg.headless)(folders).map_err(|e| format!("{why}: {e}"))?; - Ok(self.set(Route::Headless(session), None)) + Ok(self.set(Route::Headless(session), None, app_folders)) } + /// Starts the app and waits until it accepts agents, at most the launch timeout. fn launch_and_wait(&self) -> Result, String> { let app = &self.cfg.app_name; let Some(launch) = &self.cfg.launch else { return Err(format!("{app} isn't running, and this install can't start it from here: open {app}, then try again.")); }; launch().map_err(|e| format!("couldn't start {app}: {e}"))?; - let deadline = Instant::now() + self.cfg.launch_timeout; + let timeout = self.cfg.launch_timeout.min(MAX_LAUNCH_TIMEOUT); + let started = Instant::now(); + let deadline = started.checked_add(timeout).unwrap_or(started); + let poll = self.cfg.poll.clamp(POLL_RANGE.0, POLL_RANGE.1); loop { - std::thread::sleep(self.cfg.poll); + std::thread::sleep(poll); if let Some(window) = self.find_app()? { return self.use_window(window); } if Instant::now() >= deadline { return Err(format!( "{app} didn't accept agents within {} s of starting. If it's still opening, try again in a moment; otherwise check that AI agents are on in ArtCraft Launcher › Settings › AI agents.", - self.cfg.launch_timeout.as_secs() + timeout.as_secs() )); } } } + /// The client for `window`: the one made for the same port, token and process, or a new one. fn use_window(&self, window: Window) -> Result, String> { let key: WindowKey = (window.port, window.token.clone(), window.pid); { let current = self.current.lock().unwrap_or_else(PoisonError::into_inner); - if let Some((route, Some(k))) = current.as_ref() - && *k == key + if let Some(c) = current.as_ref() + && c.key.as_ref() == Some(&key) { - return Ok(route.clone()); + return Ok(c.route.clone()); } } - let client = (self.cfg.connect)(&window)?; - Ok(self.set(Route::Window(client), Some(key))) + let client = (self.cfg.connect)(&window).map_err(|e| format!("couldn't reach {}'s window: {e}", self.cfg.app_name))?; + Ok(self.set(Route::Window(client), Some(key), false)) } /// The app accepting agents now: `None` when there is no connection file, or one left by an @@ -299,12 +352,17 @@ pub fn find_window(dir: &Path, app_name: &str) -> Result, String> /// The largest token file read; a token is far shorter. const MAX_TOKEN_FILE: u64 = 4096; -/// The token in the token file at `path`, trimmed. The file must be a regular file of at most -/// [`MAX_TOKEN_FILE`] bytes holding a non-empty token of hex digits, and on Unix readable by its -/// owner only: a token others could read is refused rather than used. +/// The token in the token file at `path`, trimmed and otherwise as written: the app's server +/// compares it exactly ([`crate::auth::tokens_match`]). The file must be a regular file of at most +/// [`MAX_TOKEN_FILE`] bytes holding one token (no spaces or control characters in it), and on Unix +/// readable by its owner only: a token others could read is refused rather than used. fn read_token(path: &Path) -> Result { use std::io::Read; let shown = |e: &dyn fmt::Display| format!("{}: {e}", path.display()); + // Before opening: opening a FIFO for reading blocks until something writes to it. + if !std::fs::metadata(path).map_err(|e| shown(&e))?.is_file() { + return Err(shown(&"not a regular file")); + } let file = std::fs::File::open(path).map_err(|e| shown(&e))?; let meta = file.metadata().map_err(|e| shown(&e))?; if !meta.is_file() { @@ -323,10 +381,10 @@ fn read_token(path: &Path) -> Result { return Err(shown(&format!("larger than {MAX_TOKEN_FILE} bytes"))); } let token = text.trim(); - if token.is_empty() || !token.bytes().all(|b| b.is_ascii_hexdigit()) { + if token.is_empty() || token.chars().any(|c| c.is_whitespace() || c.is_control()) { return Err(shown(&"not a control token")); } - Ok(token.to_ascii_lowercase()) + Ok(token.to_owned()) } /// How to start the desktop app `exe` (its file name without `.exe`) that ships beside the CLI at @@ -336,14 +394,16 @@ fn read_token(path: &Path) -> Result { pub fn launcher(cli: &Path, exe: &str) -> Option { use std::process::{Command, Stdio}; let env = |name: &str| std::env::var_os(name).filter(|v| !v.is_empty()); + // Both sides resolved, so a mount reached through a symlink (`$TMPDIR`) still matches. + let resolved = |p: &Path| std::fs::canonicalize(p).unwrap_or_else(|_| p.to_path_buf()); let install = Install { platform: Platform::current(), flatpak: env("FLATPAK_ID").is_some(), appimage: env("APPIMAGE"), - appdir: env("APPDIR"), + appdir: env("APPDIR").map(|d| resolved(Path::new(&d)).into_os_string()), system_root: env("SystemRoot"), }; - let (program, args) = launch_command(cli, exe, &install, &|p| p.is_file())?; + let (program, args) = launch_command(&resolved(cli), exe, &install, &|p| p.is_file())?; let mut command = Command::new(program); command.args(args); let command = Mutex::new(command); @@ -391,6 +451,7 @@ enum Platform { } impl Platform { + /// The platform this build runs on. fn current() -> Self { if cfg!(windows) { Self::Windows diff --git a/crates/control/src/agents/mod.rs b/crates/control/src/agents/mod.rs index 8deaa34bd..e1b0b9923 100644 --- a/crates/control/src/agents/mod.rs +++ b/crates/control/src/agents/mod.rs @@ -14,7 +14,7 @@ //! reads that file before every tool call ([`Live`]), so an MCP client's configuration never holds //! a port or a token. The file holds no secret. A crashed app can leave it behind; nothing then //! listens on its port ([`probe`]), and the app's next launch removes it -//! ([`remove_stale_connection`]). +//! ([`remove_stale_connection`]). An app that quits removes its own ([`remove_connection`]). //! //! | Part | Names | Builds | //! |---|---|---| @@ -37,13 +37,16 @@ //! launcher's switch wakes the app and when the person changes the setting. When it turns true, //! listen on loopback with a token, the token in an owner-only file //! ([`crate::auth::App::write_token_file`]), and [`write_connection`] with [`Connection::new`]; -//! when it turns false, stop listening and [`remove_connection`] with the app's process id. No -//! restart, no agents switch of its own. +//! when it turns false, and when the app quits, stop listening and [`remove_connection`] with +//! the app's process id. No restart, no agents switch of its own. There is one connection file +//! per settings folder: an app that runs more than one process on one folder lets only one of +//! them accept agents. //! //! Its `gridcraft-cli mcp`: //! //! 1. A [`LiveConfig`] with the app's settings folder; `consent` reads its saved -//! [`AgentSettings`] and asks [`launcher_allows`]; `connect` makes the app's client for a +//! [`AgentSettings`] and answers `agents_allowed(mcp_flag(), launcher_allows("gridcraft"), legacy)` +//! ([`agents_allowed`], [`mcp_flag`], [`launcher_allows`]); `connect` makes the app's client for a //! [`Window`] (its address and token); `headless` makes its session without a window for //! [`HeadlessFolders`]. [`launcher`] starts the app beside the CLI. //! 2. Before every tool call, [`Live::resolve`] (from a blocking thread in an async server), then diff --git a/crates/control/src/lib.rs b/crates/control/src/lib.rs index d2e4f3d95..56ce2e685 100644 --- a/crates/control/src/lib.rs +++ b/crates/control/src/lib.rs @@ -3,7 +3,8 @@ //! request to the window ([`server`]), the client that talks to it ([`client`]), the request the //! window answers ([`ControlRequest`]), the document watch subscribed connections wait on //! ([`DocumentWatch`]), what a request still running does when it finishes ([`Effect`]), and AI -//! agents in the open window behind the ArtCraft Launcher's switch ([`agents`], feature `agents`). It +//! agents in the open window behind the ArtCraft Launcher's switch ([`agents`]: its settings on +//! every target, the switch, the connection file and the CLI's side with feature `agents`). It //! needs no UI toolkit; the window's own requests over egui (`ui.screenshot`, `ui.resize`) are //! `craft-control-egui`. #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] diff --git a/crates/control/tests/agents.rs b/crates/control/tests/agents.rs index c5e39251a..95a4651eb 100644 --- a/crates/control/tests/agents.rs +++ b/crates/control/tests/agents.rs @@ -246,7 +246,11 @@ fn an_open_app_takes_the_call_and_keeps_its_client_until_it_restarts() { // Even without consent: an app publishes its connection only while it accepts agents. let live = TestLive::new(config(dir.path(), Consent::default(), &made)); let w = window(live.resolve()); - assert_eq!((w.port, w.pid, w.token.as_str(), w.addr()), (c.port, c.pid, TOKEN, c.addr()), "the token is trimmed and lower-cased"); + assert_eq!( + (w.port, w.pid, w.token.as_str(), w.addr()), + (c.port, c.pid, TOKEN.to_ascii_uppercase().as_str(), c.addr()), + "the token is trimmed, otherwise as written" + ); window(live.resolve()); assert_eq!(made.connects.load(Ordering::Relaxed), 1, "the same window keeps its client"); assert!(matches!(live.current(), Some(Route::Window(_)))); @@ -333,8 +337,8 @@ fn a_crashed_apps_connection_file_counts_as_closed() { assert_eq!(find_window(dir.path(), "Test").unwrap(), None); } -/// A token file that isn't a token, is too big or is missing fails the call and names the app; -/// nothing is sent to the window. +/// A token file that isn't a token, is too big, is missing, isn't a regular file or (on Unix) +/// others can read fails the call and names the app; nothing is sent to the window. #[test] fn a_bad_token_file_fails_the_call() { let dir = temp_dir("token"); @@ -345,6 +349,23 @@ fn a_bad_token_file_fails_the_call() { let err = TestLive::new(config(dir.path(), Consent::default(), &made)).resolve().err().unwrap(); assert!(err.starts_with("Test's agent token: "), "{err}"); } + // Any token the app's server accepts is passed on: upper case, dashes. + write_token(&dir.path().join(TOKEN_FILE), "AB12-cd34-EF56-0000-1111-2222-3333-4444"); + assert_eq!(find_window(dir.path(), "Test").unwrap().unwrap().token, "AB12-cd34-EF56-0000-1111-2222-3333-4444"); + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + let token = dir.path().join(TOKEN_FILE); + write_token(&token, TOKEN); + std::fs::set_permissions(&token, std::fs::Permissions::from_mode(0o644)).unwrap(); + let err = find_window(dir.path(), "Test").err().unwrap(); + assert!(err.contains("readable by group or others"), "{err}"); + // A FIFO would block a plain open until something writes to it. + std::fs::remove_file(&token).unwrap(); + assert!(std::process::Command::new("mkfifo").arg(&token).status().unwrap().success()); + let err = find_window(dir.path(), "Test").err().unwrap(); + assert!(err.contains("not a regular file"), "{err}"); + } std::fs::remove_file(dir.path().join(TOKEN_FILE)).unwrap(); assert!(find_window(dir.path(), "Test").is_err()); assert_eq!(made.connects.load(Ordering::Relaxed), 0); @@ -362,7 +383,7 @@ fn the_apps_errors_reach_the_agent() { |w: &Window| Ok(w.clone()), |_: &HeadlessFolders| Err("no such folder".into()), ); - assert_eq!(TestLive::new(cfg).resolve().err().unwrap(), "the automation roots can't be used: no such folder"); + assert_eq!(TestLive::new(cfg).resolve().err().unwrap(), "Test can't use the automation roots: no such folder"); let (_listener, _c) = publish(dir.path()); let cfg: LiveConfig = LiveConfig::new( @@ -373,7 +394,7 @@ fn the_apps_errors_reach_the_agent() { |f: &HeadlessFolders| Ok(f.clone()), ); let live = TestLive::new(cfg); - assert_eq!(live.resolve().err().unwrap(), "refused"); + assert_eq!(live.resolve().err().unwrap(), "couldn't reach Test's window: refused"); assert!(live.current().is_none(), "a failed connect leaves no route"); } @@ -438,18 +459,26 @@ fn calls_queued_behind_a_failed_start_share_its_error() { let made = Arc::new(Made::default()); let launches = Arc::new(AtomicUsize::new(0)); let mut cfg = config(dir.path(), allowed(WhenAppClosed::Launch), &made); - let n = launches.clone(); - // The app is started but never accepts agents within the timeout. + let entered = Arc::new(AtomicUsize::new(0)); + let (n, e) = (launches.clone(), entered.clone()); + // The app is started but never accepts agents within the timeout. The start waits until every + // call is under way and then a while longer, so a call that hasn't reached its lookup by the + // time the start ends is very unlikely (there is no hook between the two). cfg.launch = Some(Box::new(move || { n.fetch_add(1, Ordering::Relaxed); + assert!(wait_for(|| e.load(Ordering::Relaxed) == 4), "every call starts"); + std::thread::sleep(Duration::from_millis(250)); Ok(()) })); cfg.launch_timeout = Duration::from_millis(150); let live = Arc::new(TestLive::new(cfg)); let calls: Vec<_> = (0..4) .map(|_| { - let live = live.clone(); - std::thread::spawn(move || live.resolve()) + let (live, entered) = (live.clone(), entered.clone()); + std::thread::spawn(move || { + entered.fetch_add(1, Ordering::Relaxed); + live.resolve() + }) }) .collect(); let answers: Vec<_> = calls.into_iter().map(|c| c.join().unwrap()).collect(); @@ -461,3 +490,83 @@ fn calls_queued_behind_a_failed_start_share_its_error() { assert!(live.resolve().is_err()); assert_eq!(launches.load(Ordering::Relaxed), 2, "a later call starts the app again"); } + +/// Allow Agent Control off refuses agents on the CLI's side too, as the app does by not +/// listening: no start, and only the command's folders. +#[test] +fn allow_agent_control_off_counts_as_not_allowed() { + let dir = temp_dir("aac-off"); + let made = Arc::new(Made::default()); + let mut s = settings(WhenAppClosed::Launch, "/app-in", "/app-out"); + s.allow_agent_control = false; + let mut cfg = config(dir.path(), Consent::new(true, s), &made); + cfg.launch = Some(Box::new(|| panic!("nothing may start the app"))); + cfg.read_roots = paths(&["/cli-in"]); + let f = headless_folders(TestLive::new(cfg).resolve()); + assert_eq!((f.read, f.write), (paths(&["/cli-in"]), None)); +} + +/// A window route is dropped once no app accepts agents, so a dead client isn't kept or handed +/// back. +#[test] +fn a_window_that_went_away_is_forgotten() { + let dir = temp_dir("gone"); + let made = Arc::new(Made::default()); + let live = TestLive::new(config(dir.path(), allowed(WhenAppClosed::Error), &made)); + let (listener, c) = publish(dir.path()); + window(live.resolve()); + drop(listener); + remove_connection(dir.path(), c.pid); + assert!(live.resolve().is_err(), "the app is closed and the choice is an error"); + assert!(live.current().is_none(), "the dead window is gone"); +} + +/// A headless session with the app's agent folders ends when the person stops letting agents in; +/// one with only the command's folders stays. +#[test] +fn a_headless_session_with_the_apps_folders_ends_with_consent() { + let dir = temp_dir("revoke"); + let made = Arc::new(Made::default()); + let on = Arc::new(AtomicBool::new(true)); + let gate = on.clone(); + let (b, c) = (made.clone(), made.clone()); + let cfg: LiveConfig = LiveConfig::new( + "Test", + dir.path().to_path_buf(), + move |_: &Path| Consent::new(gate.load(Ordering::Relaxed), settings(WhenAppClosed::Headless, "/app-in", "/app-out")), + move |w: &Window| { + b.connects.fetch_add(1, Ordering::Relaxed); + Ok(w.clone()) + }, + move |f: &HeadlessFolders| { + c.sessions.fetch_add(1, Ordering::Relaxed); + Ok(f.clone()) + }, + ); + let live = TestLive::new(cfg); + assert_eq!(headless_folders(live.resolve()).read, paths(&["/app-in"])); + on.store(false, Ordering::Relaxed); + assert_eq!(headless_folders(live.resolve()), HeadlessFolders::default(), "the app's folders went with the consent"); + on.store(true, Ordering::Relaxed); + assert_eq!(headless_folders(live.resolve()), HeadlessFolders::default(), "a session without the app's folders stays"); + assert_eq!(made.sessions.load(Ordering::Relaxed), 2); +} + +/// A huge launch timeout or poll is cut down rather than overflowing the deadline or blocking. +#[test] +fn a_huge_launch_timeout_or_poll_neither_panics_nor_hangs() { + let dir = temp_dir("huge"); + let made = Arc::new(Made::default()); + let mut cfg = config(dir.path(), allowed(WhenAppClosed::Launch), &made); + let (d, app) = (dir.path().to_path_buf(), Arc::new(Mutex::new(None))); + let slot = app.clone(); + cfg.launch = Some(Box::new(move || { + *slot.lock().unwrap() = Some(publish(&d).0); + Ok(()) + })); + cfg.launch_timeout = Duration::MAX; + cfg.poll = Duration::MAX; + let started = Instant::now(); + window(TestLive::new(cfg).resolve()); + assert!(started.elapsed() < Duration::from_secs(5), "{:?}", started.elapsed()); +}