feat(KAN-52): add server selection and isolated native sessions

native/src-tauri/src/lib.rs

@@ -1,9 +1,39 @@
+mod locale;
+mod server;
+
+use locale::en;
+use server::{validate_url, Server, DEFAULT_SERVER};
+use std::{path::PathBuf, sync::Mutex, time::Duration};
 use tauri::{
+    menu::{MenuBuilder, SubmenuBuilder},
     webview::{NewWindowResponse, PageLoadEvent},
     AppHandle, Manager, Url, WebviewUrl, WebviewWindowBuilder, WindowEvent,
 };
 
-const SERVER_URL: &str = "https://kanbangit.de/";
+#[derive(Default)]
+struct Connection {
+    server: Option<Server>,
+    label: Option<String>,
+    revision: u64,
+    ready: bool,
+    phase: &'static str,
+}
+
+impl Connection {
+    fn begin_navigation(&mut self) -> u64 {
+        self.revision += 1;
+        self.phase = "connecting";
+        self.revision
+    }
+
+    fn timeout(&mut self, revision: u64) -> bool {
+        if self.revision != revision || self.phase != "connecting" {
+            return false;
+        }
+        self.phase = "connectionError";
+        true
+    }
+}
 
 fn allows_server_navigation(server: &Url, destination: &Url) -> bool {
     destination.scheme() == "https"
@@ -20,81 +50,298 @@ fn allows_launcher_navigation(destination: &Url) -> bool {
         && destination.password().is_none()
 }
 
+fn configuration_path(app: &AppHandle) -> tauri::Result<PathBuf> {
+    Ok(app.path().app_config_dir()?.join("active-server"))
+}
+
+fn update_launcher(app: &AppHandle) {
+    let state = app.state::<Mutex<Connection>>();
+    let state = state.lock().unwrap();
+    let mut message = Url::parse("tauri://localhost/").unwrap();
+    message
+        .query_pairs_mut()
+        .append_pair(
+            "server",
+            state
+                .server
+                .as_ref()
+                .map_or(DEFAULT_SERVER, |server| server.url.as_str()),
+        )
+        .append_pair("phase", state.phase)
+        .append_pair("ready", if state.ready { "true" } else { "false" });
+    if let Some(window) = app.get_webview_window("launcher") {
+        let _ = window.eval(format!(
+            "window.updateLauncher?.('{}')",
+            message.query().unwrap()
+        ));
+    }
+}
+
 fn show_launcher(app: &AppHandle) {
+    update_launcher(app);
     if let Some(window) = app.get_webview_window("launcher") {
         let _ = window.show();
         let _ = window.set_focus();
     }
 }
 
-fn open_workspace(app: &AppHandle) -> tauri::Result<()> {
-    if let Some(window) = app.get_webview_window("workspace") {
-        window.show()?;
-        window.set_focus()?;
-        return Ok(());
-    }
-
-    let server = Url::parse(SERVER_URL).expect("The built-in server URL must be valid");
-    let window = WebviewWindowBuilder::new(app, "workspace", WebviewUrl::External(server.clone()))
-        .title("KanbanGit")
-        .inner_size(1280.0, 850.0)
-        .min_inner_size(375.0, 600.0)
-        .center()
-        .on_navigation(move |destination| allows_server_navigation(&server, destination))
-        .on_new_window(|_, _| NewWindowResponse::Deny)
-        .on_page_load(|window, payload| {
-            if payload.event() == PageLoadEvent::Finished {
-                if let Some(launcher) = window.app_handle().get_webview_window("launcher") {
-                    let _ = launcher.hide();
-                }
-                #[cfg(debug_assertions)]
-                eprintln!(
-                    "KanbanGit workspace page loaded: {}",
-                    payload.url().origin().ascii_serialization()
-                );
-            }
-        })
-        .build()?;
-
+fn begin_navigation(app: &AppHandle, label: &str) {
+    let state = app.state::<Mutex<Connection>>();
+    let revision = {
+        let mut state = state.lock().unwrap();
+        if state.label.as_deref() != Some(label) {
+            return;
+        }
+        state.begin_navigation()
+    };
+    update_launcher(app);
     let handle = app.clone();
-    window.on_window_event(move |event| {
-        if matches!(event, WindowEvent::Destroyed) {
+    std::thread::spawn(move || {
+        std::thread::sleep(Duration::from_secs(15));
+        let state = handle.state::<Mutex<Connection>>();
+        let timed_out = state.lock().unwrap().timeout(revision);
+        if timed_out {
             show_launcher(&handle);
         }
     });
+}
+
+fn open_workspace(app: &AppHandle, input: &str) -> Result<(), &'static str> {
+    let url = validate_url(input)?;
+    let state = app.state::<Mutex<Connection>>();
+    let (server, old_label, label) = {
+        let mut state = state.lock().unwrap();
+        let same_server = state
+            .server
+            .as_ref()
+            .is_some_and(|server| server.url == url);
+        if same_server && state.ready {
+            if let Some(window) = state
+                .label
+                .as_ref()
+                .and_then(|label| app.get_webview_window(label))
+            {
+                window.show().map_err(|_| "connectionError")?;
+                window.set_focus().map_err(|_| "connectionError")?;
+                return Ok(());
+            }
+        }
+        let server = if same_server {
+            state.server.clone().unwrap()
+        } else {
+            Server::new(url).map_err(|_| "storageError")?
+        };
+        server
+            .save(&configuration_path(app).map_err(|_| "storageError")?)
+            .map_err(|_| "storageError")?;
+        let old_label = state.label.take();
+        state.server = Some(server.clone());
+        state.ready = false;
+        state.revision += 1;
+        let label = format!("workspace-{}", state.revision);
+        state.label = Some(label.clone());
+        (server, old_label, label)
+    };
+    if let Some(window) = old_label.and_then(|label| app.get_webview_window(&label)) {
+        window.close().map_err(|_| "connectionError")?;
+    }
+    begin_navigation(app, &label);
+    let handle = app.clone();
+    let navigation_label = label.clone();
+    let server_url = server.url.clone();
+    let window = WebviewWindowBuilder::new(app, &label, WebviewUrl::External(server.url))
+        .title(en::APP_NAME)
+        .inner_size(1280.0, 850.0)
+        .min_inner_size(375.0, 600.0)
+        .center()
+        .visible(false)
+        .data_store_identifier(server.profile)
+        .on_navigation(move |destination| {
+            if !allows_server_navigation(&server_url, destination) {
+                return false;
+            }
+            begin_navigation(&handle, &navigation_label);
+            true
+        })
+        .on_new_window(|_, _| NewWindowResponse::Deny)
+        .on_page_load(|window, payload| {
+            if payload.event() != PageLoadEvent::Finished {
+                return;
+            }
+            let app = window.app_handle();
+            let state = app.state::<Mutex<Connection>>();
+            let should_show = {
+                let mut state = state.lock().unwrap();
+                if state.label.as_deref() != Some(window.label()) {
+                    return;
+                }
+                let first_load = !state.ready;
+                state.ready = true;
+                state.phase = "connected";
+                first_load
+            };
+            update_launcher(app);
+            if should_show {
+                let _ = window.show();
+                let _ = window.set_focus();
+                if let Some(launcher) = app.get_webview_window("launcher") {
+                    let _ = launcher.hide();
+                }
+            }
+        })
+        .build()
+        .map_err(|_| "connectionError")?;
+    let handle = app.clone();
+    window.on_window_event(move |event| {
+        if matches!(event, WindowEvent::Destroyed) {
+            let state = handle.state::<Mutex<Connection>>();
+            let current = {
+                let mut state = state.lock().unwrap();
+                if state.label.as_deref() == Some(&label) {
+                    state.label = None;
+                    state.ready = false;
+                    state.revision += 1;
+                    state.phase = "idle";
+                    true
+                } else {
+                    false
+                }
+            };
+            if current {
+                show_launcher(&handle);
+            }
+        }
+    });
     Ok(())
 }
 
+fn handle_launcher_action(app: &AppHandle, destination: &Url) {
+    let result = match destination.path() {
+        "/action/open" => {
+            let input = destination
+                .query_pairs()
+                .find(|(key, _)| key == "server")
+                .map(|(_, value)| value.into_owned())
+                .unwrap_or_default();
+            open_workspace(app, &input)
+        }
+        "/action/resume" => {
+            let label = app
+                .state::<Mutex<Connection>>()
+                .lock()
+                .unwrap()
+                .label
+                .clone();
+            if let Some(window) = label.and_then(|label| app.get_webview_window(&label)) {
+                let _ = window.show();
+                let _ = window.set_focus();
+            }
+            Ok(())
+        }
+        _ => Ok(()),
+    };
+    if let Err(error) = result {
+        app.state::<Mutex<Connection>>().lock().unwrap().phase = error;
+        show_launcher(app);
+    }
+}
+
 pub fn context<R: tauri::Runtime>() -> tauri::Context<R> {
     tauri::generate_context!()
 }
 
 pub fn builder() -> tauri::Builder<tauri::Wry> {
     tauri::Builder::default().setup(|app| {
-        let handle = app.handle().clone();
-        WebviewWindowBuilder::new(app, "launcher", WebviewUrl::App("index.html".into()))
-            .title("KanbanGit")
-            .inner_size(560.0, 520.0)
-            .min_inner_size(375.0, 480.0)
-            .center()
-            .on_navigation(move |destination| {
-                if allows_launcher_navigation(destination) {
-                    return true;
-                }
-                if destination.as_str() == SERVER_URL {
-                    let handle = handle.clone();
-                    // Defer window creation until the navigation callback has returned.
-                    let _ = handle.clone().run_on_main_thread(move || {
-                        if let Err(error) = open_workspace(&handle) {
-                            eprintln!("Could not open the workspace: {error}");
-                            show_launcher(&handle);
-                        }
-                    });
-                }
-                false
-            })
-            .on_new_window(|_, _| NewWindowResponse::Deny)
+        let (server, phase) = match Server::load(&configuration_path(app.handle())?) {
+            Ok(server) => (server, "idle"),
+            Err(_) => (None, "storageError"),
+        };
+        app.manage(Mutex::new(Connection {
+            server,
+            phase,
+            ..Default::default()
+        }));
+        let menu = MenuBuilder::new(app)
+            .item(
+                &SubmenuBuilder::new(app, en::APP_NAME)
+                    .text("server-settings", en::SERVER_SETTINGS)
+                    .separator()
+                    .quit()
+                    .build()?,
+            )
+            .item(
+                &SubmenuBuilder::new(app, en::EDIT)
+                    .undo()
+                    .redo()
+                    .separator()
+                    .cut()
+                    .copy()
+                    .paste()
+                    .select_all()
+                    .build()?,
+            )
             .build()?;
+        app.set_menu(menu)?;
+        app.on_menu_event(|app, event| {
+            if event.id().as_ref() == "server-settings" {
+                show_launcher(app);
+            }
+        });
+        let handle = app.handle().clone();
+        let launcher =
+            WebviewWindowBuilder::new(app, "launcher", WebviewUrl::App("index.html".into()))
+                .title(en::APP_NAME)
+                .inner_size(560.0, 720.0)
+                .min_inner_size(375.0, 640.0)
+                .center()
+                .on_navigation(move |destination| {
+                    if !allows_launcher_navigation(destination) {
+                        return false;
+                    }
+                    if destination.path().starts_with("/action/") {
+                        let handle = handle.clone();
+                        let destination = destination.clone();
+                        let _ = handle.clone().run_on_main_thread(move || {
+                            handle_launcher_action(&handle, &destination)
+                        });
+                        return false;
+                    }
+                    matches!(destination.path(), "" | "/" | "/index.html")
+                })
+                .on_new_window(|_, _| NewWindowResponse::Deny)
+                .on_page_load(|window, payload| {
+                    if payload.event() == PageLoadEvent::Finished {
+                        let app = window.app_handle().clone();
+                        update_launcher(&app);
+                        std::thread::spawn(move || {
+                            let handle = app.clone();
+                            let _ = app.run_on_main_thread(move || {
+                                let server = handle
+                                    .state::<Mutex<Connection>>()
+                                    .lock()
+                                    .unwrap()
+                                    .server
+                                    .clone();
+                                if let Some(server) = server {
+                                    if let Err(error) = open_workspace(&handle, server.url.as_str())
+                                    {
+                                        handle.state::<Mutex<Connection>>().lock().unwrap().phase =
+                                            error;
+                                        show_launcher(&handle);
+                                    }
+                                }
+                            });
+                        });
+                    }
+                })
+                .build()?;
+        let window = launcher.clone();
+        launcher.on_window_event(move |event| {
+            if let WindowEvent::CloseRequested { api, .. } = event {
+                api.prevent_close();
+                let _ = window.hide();
+            }
+        });
         Ok(())
     })
 }
@@ -109,72 +356,75 @@ mod tests {
     use super::*;
 
     #[test]
-    fn server_allows_application_routes_on_the_same_https_origin() {
-        let server = Url::parse(SERVER_URL).unwrap();
+    fn navigation_is_limited_to_the_selected_https_origin() {
+        let server = validate_url("https://example.com:8443/app/").unwrap();
         for path in [
-            "/",
             "/login",
             "/two-factor-challenge",
-            "/projects/1?ticket=51#details",
+            "/projects/1?ticket=52#details",
         ] {
             assert!(allows_server_navigation(
                 &server,
                 &server.join(path).unwrap()
             ));
         }
-    }
-
-    #[test]
-    fn server_rejects_origin_changes_downgrades_credentials_and_local_content() {
-        let server = Url::parse(SERVER_URL).unwrap();
         for destination in [
-            "http://kanbangit.de/",
-            "https://kanbangit.de:444/",
-            "https://kanbangit.de.example.com/",
+            "http://example.com:8443/",
             "https://example.com/",
-            "https://user:password@kanbangit.de/",
-            "https://user@kanbangit.de/",
-            "tauri://localhost/index.html",
+            "https://other.example.com:8443/",
+            "https://user:secret@example.com:8443/",
+            "tauri://localhost/action/open?server=https://evil.test",
             "file:///etc/passwd",
             "data:text/html,hello",
             "javascript:alert(1)",
         ] {
-            assert!(
-                !allows_server_navigation(&server, &Url::parse(destination).unwrap()),
-                "{destination}"
-            );
-        }
-    }
-
-    #[test]
-    fn launcher_only_loads_bundled_pages() {
-        assert!(allows_launcher_navigation(
-            &Url::parse("tauri://localhost/index.html").unwrap()
-        ));
-        for destination in [
-            SERVER_URL,
-            "https://localhost/",
-            "http://localhost:1420/",
-            "tauri://other/index.html",
-            "tauri://user@localhost/index.html",
-        ] {
-            assert!(!allows_launcher_navigation(
+            assert!(!allows_server_navigation(
+                &server,
                 &Url::parse(destination).unwrap()
             ));
         }
     }
 
     #[test]
-    fn remote_pages_cannot_invoke_native_window_webview_or_path_commands() {
+    fn launcher_actions_are_restricted_to_the_bundled_origin() {
+        assert!(allows_launcher_navigation(
+            &Url::parse("tauri://localhost/action/open").unwrap()
+        ));
+        for input in [
+            DEFAULT_SERVER,
+            "https://localhost/",
+            "tauri://other/index.html",
+            "tauri://user@localhost/index.html",
+        ] {
+            assert!(!allows_launcher_navigation(&Url::parse(input).unwrap()));
+        }
+    }
+
+    #[test]
+    fn stale_timeouts_do_not_replace_newer_connections_or_loaded_forms() {
+        let mut state = Connection::default();
+        let first = state.begin_navigation();
+        let second = state.begin_navigation();
+        assert!(!state.timeout(first));
+        state.ready = true;
+        assert!(state.timeout(second));
+        assert!(state.ready);
+        assert!(!state.timeout(second));
+        let third = state.begin_navigation();
+        state.phase = "connected";
+        assert!(!state.timeout(third));
+    }
+
+    #[test]
+    fn remote_pages_cannot_invoke_native_commands() {
         let app = tauri::test::mock_builder().build(context()).unwrap();
         let window = WebviewWindowBuilder::new(
             &app,
-            "workspace",
-            WebviewUrl::External(Url::parse(SERVER_URL).unwrap()),
+            "workspace-1",
+            WebviewUrl::External(Url::parse(DEFAULT_SERVER).unwrap()),
         )
         .build()
         .unwrap();
-
         for command in [
             "plugin:window|close",
             "plugin:webview|create_webview_window",
@@ -186,14 +436,17 @@ mod tests {
                     cmd: command.into(),
                     callback: tauri::ipc::CallbackFn(0),
                     error: tauri::ipc::CallbackFn(1),
-                    url: Url::parse(SERVER_URL).unwrap(),
+                    url: Url::parse(DEFAULT_SERVER).unwrap(),
                     body: tauri::ipc::InvokeBody::default(),
                     headers: Default::default(),
                     invoke_key: tauri::test::INVOKE_KEY.into(),
                 },
             );
-            let error = response.expect_err("Remote native commands must be rejected");
-            assert!(error.as_str().unwrap().contains("not allowed"), "{error}");
+            assert!(response
+                .unwrap_err()
+                .as_str()
+                .unwrap()
+                .contains("not allowed"));
         }
     }
 
@@ -201,14 +454,11 @@ mod tests {
     fn packaged_app_exposes_no_native_capabilities_or_global_api() {
         let config: serde_json::Value =
             serde_json::from_str(include_str!("../tauri.conf.json")).unwrap();
+        assert_eq!(config["bundle"]["macOS"]["minimumSystemVersion"], "14.0");
         assert_eq!(config["app"]["withGlobalTauri"], false);
         assert_eq!(
             config["app"]["security"]["capabilities"],
             serde_json::json!([])
         );
-        let capabilities = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("capabilities");
-        assert!(
-            !capabilities.exists() || std::fs::read_dir(capabilities).unwrap().next().is_none()
-        );
     }
 }

native/src-tauri/src/locale.rs

@@ -0,0 +1,5 @@
+pub mod en {
+    pub const APP_NAME: &str = "KanbanGit";
+    pub const SERVER_SETTINGS: &str = "Server settings…";
+    pub const EDIT: &str = "Edit";
+}

native/src-tauri/src/server.rs

@@ -0,0 +1,137 @@
+use std::{fs, io, io::Read, path::Path};
+use tauri::Url;
+
+pub const DEFAULT_SERVER: &str = "https://kanbangit.de/";
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Server {
+    pub url: Url,
+    pub profile: [u8; 16],
+}
+
+pub fn validate_url(input: &str) -> Result<Url, &'static str> {
+    let input = input.trim();
+    if !input
+        .get(..8)
+        .is_some_and(|prefix| prefix.eq_ignore_ascii_case("https://"))
+        || input
+            .chars()
+            .any(|character| character.is_control() || character == '\\')
+    {
+        return Err("invalidServer");
+    }
+    let mut url = Url::parse(input).map_err(|_| "invalidServer")?;
+    if url.scheme() != "https"
+        || url.host_str().is_none()
+        || !url.username().is_empty()
+        || url.password().is_some()
+        || url.query().is_some()
+        || url.fragment().is_some()
+    {
+        return Err("invalidServer");
+    }
+    if !url.path().ends_with('/') {
+        url.set_path(&format!("{}/", url.path()));
+    }
+    Ok(url)
+}
+
+impl Server {
+    pub fn new(url: Url) -> io::Result<Self> {
+        let mut profile = [0; 16];
+        fs::File::open("/dev/urandom")?.read_exact(&mut profile)?;
+        Ok(Self { url, profile })
+    }
+
+    pub fn load(path: &Path) -> io::Result<Option<Self>> {
+        let contents = match fs::read_to_string(path) {
+            Ok(contents) => contents,
+            Err(error) if error.kind() == io::ErrorKind::NotFound => return Ok(None),
+            Err(error) => return Err(error),
+        };
+        let invalid = || io::Error::new(io::ErrorKind::InvalidData, "Invalid server configuration");
+        let (url, profile) = contents.split_once('\n').ok_or_else(invalid)?;
+        let url = validate_url(url).map_err(|_| invalid())?;
+        if profile.len() != 32 || !profile.is_ascii() {
+            return Err(invalid());
+        }
+        let mut bytes = [0; 16];
+        for (index, byte) in bytes.iter_mut().enumerate() {
+            *byte = u8::from_str_radix(&profile[index * 2..index * 2 + 2], 16)
+                .map_err(|_| invalid())?;
+        }
+        Ok(Some(Self {
+            url,
+            profile: bytes,
+        }))
+    }
+
+    pub fn save(&self, path: &Path) -> io::Result<()> {
+        if let Some(parent) = path.parent() {
+            fs::create_dir_all(parent)?;
+        }
+        let profile: String = self
+            .profile
+            .iter()
+            .map(|byte| format!("{byte:02x}"))
+            .collect();
+        let temporary = path.with_extension("tmp");
+        fs::write(&temporary, format!("{}\n{profile}", self.url))?;
+        fs::rename(temporary, path)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn validates_and_normalizes_installation_addresses() {
+        assert_eq!(
+            validate_url(" HTTPS://Example.com:443/kanban ")
+                .unwrap()
+                .as_str(),
+            "https://example.com/kanban/"
+        );
+        assert!(validate_url("https://[::1]:8443/").is_ok());
+        for input in [
+            "http://example.com",
+            "https:example.com",
+            "https://user:secret@example.com",
+            "https://user@example.com",
+            "https://example.com/?token=secret",
+            "https://example.com/#secret",
+            "https://exa\nmple.com",
+            "https://example.com\\other",
+            "file:///tmp/test",
+            "javascript:alert(1)",
+            "",
+        ] {
+            assert!(validate_url(input).is_err(), "{input}");
+        }
+    }
+
+    #[test]
+    fn configuration_round_trip_preserves_only_the_address_and_profile() {
+        let server = Server::new(validate_url(DEFAULT_SERVER).unwrap()).unwrap();
+        let path =
+            std::env::temp_dir().join(format!("kanbangit-server-{:x?}/active", server.profile));
+        assert_eq!(Server::load(&path).unwrap(), None);
+        server.save(&path).unwrap();
+        assert_eq!(Server::load(&path).unwrap(), Some(server.clone()));
+        let other = Server::new(validate_url("https://other.example.com:444/").unwrap()).unwrap();
+        assert_ne!(server.profile, other.profile);
+        other.save(&path).unwrap();
+        assert_eq!(Server::load(&path).unwrap(), Some(other));
+        for contents in [
+            "http://example.com/\n00000000000000000000000000000000",
+            "invalid",
+            "https://example.com/\nshort",
+            "https://example.com/\nzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz",
+        ] {
+            fs::write(&path, contents).unwrap();
+            assert!(Server::load(&path).is_err());
+        }
+        fs::remove_dir_all(path.parent().unwrap()).unwrap();
+    }
+}