feat(gui): respawn daemon if it dies between probe and connect

The is_service_running() probe answers "is a daemon listening
right now"; the GUI's IPC connect happens after GTK initialization
finishes, milliseconds-to-seconds later. A daemon that crashed
during that window would leave the GUI hanging in connect()'s
retry loop forever.

Two changes close the gap:

- lan-mouse-ipc: add `try_connect()`, a one-shot non-retrying
  connect that exposes the underlying I/O error so callers can
  branch on "no daemon" vs "real failure".
- lan-mouse-gtk: when main.rs has flagged the daemon as
  externally managed (we skipped spawning a child), `build_ui`
  probes with try_connect first; on failure it spawns a fresh
  daemon (fire-and-forget — matches the externally-managed
  daemon semantics) and falls back to the retrying connect()
  to bind against the new instance.

The else branch (we *did* spawn a child) keeps the existing
retrying connect() so the normal startup window where the daemon
hasn't bound yet still works as before.

Author: jondkinney

lan-mouse-gtk/src/lib.rs

@@ -84,7 +84,11 @@ pub(crate) fn request_quit_with_backstop(app: &adw::Application) {
     app.quit();
 }
 
-pub fn run(gui_lock: Option<GuiLock>, local_commit: [u8; 8]) -> Result<(), GtkError> {
+pub fn run(
+    gui_lock: Option<GuiLock>,
+    local_commit: [u8; 8],
+    external_daemon: bool,
+) -> Result<(), GtkError> {
     log::debug!("running gtk frontend");
     LOCAL_COMMIT
         .set(local_commit)
@@ -114,20 +118,23 @@ pub fn run(gui_lock: Option<GuiLock>, local_commit: [u8; 8]) -> Result<(), GtkEr
     let ret = std::thread::Builder::new()
         .stack_size(8 * 1024 * 1024) // https://gitlab.gnome.org/GNOME/gtk/-/commit/52dbb3f372b2c3ea339e879689c1de535ba2c2c3 -> caused crash on windows
         .name("gtk".into())
-        .spawn(move || gtk_main(show_rx))
+        .spawn(move || gtk_main(show_rx, external_daemon))
         .unwrap()
         .join()
         .unwrap();
     #[cfg(not(windows))]
-    let ret = gtk_main(show_rx);
+    let ret = gtk_main(show_rx, external_daemon);
 
     match ret {
         glib::ExitCode::SUCCESS => Ok(()),
         e => Err(GtkError::NonZeroExitCode(e.value())),
     }
 }
 
-fn gtk_main(show_rx: Option<async_channel::Receiver<()>>) -> glib::ExitCode {
+fn gtk_main(
+    show_rx: Option<async_channel::Receiver<()>>,
+    external_daemon: bool,
+) -> glib::ExitCode {
     #[cfg(target_os = "macos")]
     {
         configure_macos_bundle_environment();
@@ -145,7 +152,7 @@ fn gtk_main(show_rx: Option<async_channel::Receiver<()>>) -> glib::ExitCode {
         setup_actions(app);
         setup_menu(app);
     });
-    app.connect_activate(move |app| build_ui(app, show_rx.clone()));
+    app.connect_activate(move |app| build_ui(app, show_rx.clone(), external_daemon));
 
     let args: Vec<&'static str> = vec![];
     app.run_with_args(&args)
@@ -257,7 +264,11 @@ fn setup_menu(app: &adw::Application) {
     app.set_menubar(Some(&menu))
 }
 
-fn build_ui(app: &Application, show_rx: Option<async_channel::Receiver<()>>) {
+fn build_ui(
+    app: &Application,
+    show_rx: Option<async_channel::Receiver<()>>,
+    external_daemon: bool,
+) {
     // Defense in depth: if `activate` fires a second time in the same
     // process — the GApplication DBus single-instance hand-off does
     // this on Linux, and `kAEReopenApplication` does this on macOS —
@@ -268,7 +279,44 @@ fn build_ui(app: &Application, show_rx: Option<async_channel::Receiver<()>>) {
     }
 
     log::debug!("connecting to lan-mouse-socket");
-    let (mut frontend_rx, frontend_tx) = match lan_mouse_ipc::connect() {
+    // Two paths into the IPC socket:
+    //
+    // - main.rs spawned a daemon child (external_daemon == false):
+    //   use the retrying connect(), which handles the racy startup
+    //   window where the daemon hasn't bound yet.
+    //
+    // - main.rs detected an existing daemon and skipped spawning
+    //   (external_daemon == true): probe with try_connect; if it
+    //   fails (the daemon died between is_service_running and now)
+    //   spawn a fresh one ourselves and fall back to the retrying
+    //   connect(). The respawned daemon is fire-and-forget — the
+    //   GUI no longer manages its lifecycle, matching the
+    //   externally-managed-daemon semantics that put us on this
+    //   branch in the first place.
+    let conn_result = if external_daemon {
+        match lan_mouse_ipc::try_connect() {
+            Ok(conn) => Ok(conn),
+            Err(probe_err) => {
+                log::warn!(
+                    "could not attach to existing daemon ({probe_err}) — spawning a new one"
+                );
+                if let Err(spawn_err) = process::Command::new(
+                    env::current_exe().expect("could not determine executable path"),
+                )
+                .args(env::args().skip(1))
+                .arg("daemon")
+                .spawn()
+                {
+                    log::error!("failed to spawn replacement daemon: {spawn_err}");
+                    process::exit(1);
+                }
+                lan_mouse_ipc::connect()
+            }
+        }
+    } else {
+        lan_mouse_ipc::connect()
+    };
+    let (mut frontend_rx, frontend_tx) = match conn_result {
         Ok(conn) => conn,
         Err(e) => {
             log::error!("{e}");

lan-mouse-ipc/src/connect.rs

@@ -47,13 +47,52 @@ impl FrontendRequestWriter {
 
 pub fn connect() -> Result<(FrontendEventReader, FrontendRequestWriter), ConnectionError> {
     let rx = wait_for_service()?;
+    make_connection(rx)
+}
+
+/// One-shot connect with no retry. Use when the caller has already
+/// probed the IPC socket via [`crate::is_service_running`] and is
+/// prepared to take a recovery path on failure (e.g. spawn a fresh
+/// daemon and then call [`connect`]).
+#[cfg(unix)]
+pub fn try_connect() -> Result<(FrontendEventReader, FrontendRequestWriter), ConnectionError> {
+    let socket_path = crate::default_socket_path()?;
+    let rx = UnixStream::connect(&socket_path)?;
+    make_connection(rx)
+}
+
+#[cfg(windows)]
+pub fn try_connect() -> Result<(FrontendEventReader, FrontendRequestWriter), ConnectionError> {
+    let rx = TcpStream::connect("127.0.0.1:5252")?;
+    make_connection(rx)
+}
+
+#[cfg(unix)]
+fn make_connection(
+    rx: UnixStream,
+) -> Result<(FrontendEventReader, FrontendRequestWriter), ConnectionError> {
+    let tx = rx.try_clone()?;
+    let buf_reader = BufReader::new(rx);
+    let lines = buf_reader.lines();
+    let line_writer = LineWriter::new(tx);
+    Ok((
+        FrontendEventReader { lines },
+        FrontendRequestWriter { line_writer },
+    ))
+}
+
+#[cfg(windows)]
+fn make_connection(
+    rx: TcpStream,
+) -> Result<(FrontendEventReader, FrontendRequestWriter), ConnectionError> {
     let tx = rx.try_clone()?;
     let buf_reader = BufReader::new(rx);
     let lines = buf_reader.lines();
     let line_writer = LineWriter::new(tx);
-    let reader = FrontendEventReader { lines };
-    let writer = FrontendRequestWriter { line_writer };
-    Ok((reader, writer))
+    Ok((
+        FrontendEventReader { lines },
+        FrontendRequestWriter { line_writer },
+    ))
 }
 
 /// wait for the lan-mouse socket to come online

lan-mouse-ipc/src/lib.rs

@@ -21,7 +21,7 @@ mod connect_async;
 mod gui_lock;
 mod listen;
 
-pub use connect::{FrontendEventReader, FrontendRequestWriter, connect};
+pub use connect::{FrontendEventReader, FrontendRequestWriter, connect, try_connect};
 pub use connect_async::{AsyncFrontendEventReader, AsyncFrontendRequestWriter, connect_async};
 pub use gui_lock::{GuiLock, GuiLockError};
 pub use listen::AsyncFrontendListener;

src/main.rs

@@ -113,13 +113,14 @@ fn run() -> Result<(), LanMouseError> {
                 // case where a previous GUI's daemon outlived its
                 // parent. The GUI then attaches to the existing
                 // daemon and leaves it running on exit.
-                let mut service = if lan_mouse_ipc::is_service_running() {
+                let external_daemon = lan_mouse_ipc::is_service_running();
+                let mut service = if external_daemon {
                     log::info!("daemon already running; attaching to existing instance");
                     None
                 } else {
                     Some(start_service()?)
                 };
-                let res = lan_mouse_gtk::run(gui_lock, config::local_commit());
+                let res = lan_mouse_gtk::run(gui_lock, config::local_commit(), external_daemon);
 
                 // Bound the daemon-child cleanup so a wedged daemon
                 // (CGEventTap stuck on macOS, hung syscall, etc.)