Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.
fix(desktop): preserve setup on reopen and avoid false quit warnings (#562)
David McKay234559674f40
diff --git a/desktop/src-tauri/src/main.rs b/desktop/src-tauri/src/main.rsindex e6a2bddd..9da1bbcf 100644--- a/desktop/src-tauri/src/main.rs+++ b/desktop/src-tauri/src/main.rs@@ -1283,6 +1283,17 @@ fn down_owned_containers(shell: &Shell, root: &Path) -> Result<(), String> {}}+/// Merely viewing setup does not give this session containers to shut down.+/// Start records ownership before Compose up, including partial failures. Quit must still+/// retire those runs, but an old Compose file alone is not a failed shutdown by this session.+/// Explicit Stop keeps the unknown-runtime error so it cannot claim an unverified cleanup.+fn down_containers_on_quit(shell: &Shell, root: &Path) -> Result<(), String> {+ if shell.containers.lock().unwrap().is_none() {+ return Ok(());+ }+ down_owned_containers(shell, root)+}+/// Reclaim held replacements before consulting durable inventory. Keep the handles and pidfile/// if any phase fails, so the next Stop or Start can retry with the same ownership evidence.fn cleanup_host_children<C>(@@ -1991,33 +2002,37 @@ fn remember_setup_url<R: tauri::Runtime>(app: &tauri::AppHandle<R>) -> Result<()Ok(())}+fn setup_destination<R: tauri::Runtime>(app: &tauri::AppHandle<R>) -> Result<tauri::Url, String> {+ // Use the intended setup destination even before the initial page has finished loading.+ let setup = app.state::<Shell>().setup_url.lock().unwrap().clone();+ match setup {+ Some(setup) => setup+ .parse()+ .map_err(|error| format!("{setup} is not a URL: {error}")),+ None => configured_setup_url(app.config(), tauri::is_dev(), cfg!(windows)),+ }+}+/// Put the setup screen back, when there is something to set up again.#[tauri::command]fn show_setup<R: tauri::Runtime>(app: tauri::AppHandle<R>) -> Result<(), String> {let window = app.get_webview_window("main").ok_or("the OpenBot window is not there")?;- // Use the intended setup destination even before the initial page has finished loading.- let setup = app- .state::<Shell>()- .setup_url- .lock()- .unwrap()- .clone()- .map(Ok)- .unwrap_or_else(|| {- configured_setup_url(app.config(), tauri::is_dev(), cfg!(windows))- .map(|url| url.to_string())- })?;window- .navigate(- setup- .parse()- .map_err(|error| format!("{setup} is not a URL: {error}"))?,- )+ .navigate(setup_destination(&app)?).map_err(|error| format!("could not go back to setup: {error}"))}+/// Both pages are single-page apps. Keep their route and in-memory state on restore.+/// Compare the authority explicitly: tauri:// has an opaque URL origin.+fn same_window_app(current: &tauri::Url, destination: &tauri::Url) -> bool {+ destination.host_str().is_some()+ && current.scheme() == destination.scheme()+ && current.host_str() == destination.host_str()+ && current.port_or_known_default() == destination.port_or_known_default()+}+fn show_setup_and_focus<R: tauri::Runtime>(app: tauri::AppHandle<R>) -> Result<(), String> {show_setup(app.clone())?;let window = app@@ -2745,15 +2760,21 @@ fn restore_window_on<R: tauri::Runtime>(app: &tauri::AppHandle<R>, ports: &openblet root = cleanup_root(&shell, &stack::default_root());// Restore has the same deployment ownership requirement as the setup page's passive probe.// A successful app-port response alone may belong to another installation or application.- if let Some(url) = (!recovery_required_or_pending_quit_notice(&shell, &root))+ let destination = if let Some(url) = (!recovery_required_or_pending_quit_notice(&shell, &root)).then(|| owned_app_url(&root, ports)).flatten(){- if let Ok(parsed) = url.parse() {- let _ = window.navigate(parsed);- }+ url.parse().ok()} else {- let _ = show_setup(app.clone());+ setup_destination(app).ok()+ };+ if let Some(destination) = destination {+ let already_showing = window+ .url()+ .is_ok_and(|current| same_window_app(¤t, &destination));+ if !already_showing {+ let _ = window.navigate(destination);+ }}let _ = window.show();let _ = window.unminimize();@@ -3021,7 +3042,7 @@ fn main() {&shell,&stack::default_root(),stack::stop_processes_under,- |root| down_owned_containers(&shell, root),+ |root| down_containers_on_quit(&shell, root),)},QuitDiagnostics {@@ -4824,7 +4845,7 @@ fn main() {&app.state::<Shell>(),&fallback,stack::stop_processes_under,- |root| down_owned_containers(&app.state::<Shell>(), root),+ |root| down_containers_on_quit(&app.state::<Shell>(), root),)},QuitDiagnostics {@@ -5311,6 +5332,23 @@ fn main() {runtime_affinity("docker_default_stop");}+ #[test]+ fn quit_after_only_viewing_setup_does_not_report_unowned_containers() {+ if crate::test_support::isolated_process(+ "tests::container_root::quit_after_only_viewing_setup_does_not_report_unowned_containers",+ ) {+ return;+ }+ let fixture = Fixture::new();+ remember_selected_root(&fixture.app.state::<Shell>(), &fixture.a);+ assert!(fixture.a.join("docker-compose.yml").exists());+ fixture.quit();+ assert!(+ fixture.commands().is_empty(),+ "viewing setup must not stop another runtime"+ );+ }+#[test]fn runtime_affinity_unknown_legacy_and_repeated_cleanup() {if crate::test_support::isolated_process(@@ -8401,6 +8439,75 @@ fn main() {}}+ #[test]+ fn restore_matches_only_the_destination_app() {+ for destination in [+ "tauri://localhost/",+ "http://tauri.localhost/",+ "https://tauri.localhost/",+ "http://localhost:3020/",+ "http://127.0.0.1:3010/",+ ] {+ let destination: tauri::Url = destination.parse().unwrap();+ assert!(+ same_window_app(&destination, &destination),+ "even identical navigation reloads the page"+ );+ assert!(same_window_app(+ &destination.join("ask?thread=existing#message").unwrap(),+ &destination+ ));+ for unrelated in [+ "about:blank",+ "http://127.0.0.1:9/stale-page",+ "https://example.com/",+ ] {+ assert!(!same_window_app(&unrelated.parse().unwrap(), &destination));+ }+ }+ assert!(!same_window_app(+ &"http://localhost:3020/".parse().unwrap(),+ &"http://localhost:3010/".parse().unwrap()+ ));+ assert!(!same_window_app(+ &"http://tauri.localhost/".parse().unwrap(),+ &"https://tauri.localhost/".parse().unwrap()+ ));+ }++ #[test]+ fn restore_window_preserves_setup_location_when_runtime_is_unavailable() {+ let f = RestoreFixture::new();+ for setup in [+ "tauri://localhost/",+ "http://tauri.localhost/",+ "http://localhost:3020/",+ ] {+ let app = f.app(&f.selected, setup);+ let window = app.get_webview_window("main").unwrap();+ let current = format!("{setup}#credentials");+ window.navigate(current.parse().unwrap()).unwrap();+ window.hide().unwrap();+ restore_window_on(app.handle(), &f.ports);+ assert_eq!(window.url().unwrap().as_str(), current);+ assert!(window.is_visible().unwrap());+ }+ }++ #[test]+ fn restore_window_preserves_owned_app_route() {+ let f = RestoreFixture::new();+ let app = f.app(&f.owned, "tauri://localhost/");+ let window = app.get_webview_window("main").unwrap();+ let current = format!(+ "http://127.0.0.1:{}/ask?thread=existing#message",+ f.ports.app+ );+ window.navigate(current.parse().unwrap()).unwrap();+ restore_window_on(app.handle(), &f.ports);+ assert_eq!(window.url().unwrap().as_str(), current);+ }+#[test]fn restore_window_refuses_answering_other_deployment_and_shows_recorded_setup() {let f = RestoreFixture::new();