Skip to content

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.rs
index 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: &openb
let 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(&current, &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();