feat(gui): skip transient daemon child when daemon already running

The GUI startup path always spawned a `lan-mouse daemon` child
process and immediately killed it on exit. If a daemon was already
running — e.g. because the user had launched `lan-mouse daemon`
standalone — the spawned child died early with `AlreadyRunning`,
producing a noisy "service already running!" line and a brief
phantom process in the tree.

Probe the IPC socket via `lan-mouse-ipc::is_service_running` before
spawning. If something's already listening, attach to it and skip
the child entirely; the existing SIGINT/wait/SIGKILL teardown is
gated on a `Some(child)` so an externally managed daemon outlives
the GUI as expected.

The probe is a one-shot connect; a stale socket file with no
listener returns false and the daemon's own bind path cleans the
file up.

Inspired by the approach in feschber#407, layered on top of feschber#436's
dedicated GuiLock so the singleton guarantee remains atomic and
cross-platform — this just removes the transient-child noise on
the headless-daemon-then-GUI path.

Author: jondkinney

lan-mouse-ipc/src/lib.rs

@@ -425,3 +425,19 @@ pub fn default_socket_path() -> Result<PathBuf, SocketPathError> {
         .join("Caches")
         .join(LAN_MOUSE_SOCKET_NAME))
 }
+
+/// One-shot probe: is a daemon already listening on the IPC socket?
+/// A stale socket file with no listener returns `false` (the daemon's
+/// own listener bind path will clean it up).
+#[cfg(unix)]
+pub fn is_service_running() -> bool {
+    let Ok(socket_path) = default_socket_path() else {
+        return false;
+    };
+    std::os::unix::net::UnixStream::connect(socket_path).is_ok()
+}
+
+#[cfg(windows)]
+pub fn is_service_running() -> bool {
+    std::net::TcpStream::connect("127.0.0.1:5252").is_ok()
+}

src/main.rs

@@ -107,15 +107,28 @@ fn run() -> Result<(), LanMouseError> {
                     }
                 };
 
-                let mut service = start_service()?;
+                // Skip the transient daemon child if a daemon is
+                // already listening on the IPC socket — covers both
+                // an externally-started `lan-mouse daemon` and the
+                // 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() {
+                    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());
 
                 // Bound the daemon-child cleanup so a wedged daemon
                 // (CGEventTap stuck on macOS, hung syscall, etc.)
                 // can't freeze the GUI on quit. SIGINT first, give it
-                // a few seconds to exit cleanly, then SIGKILL.
+                // a few seconds to exit cleanly, then SIGKILL. Only
+                // runs when *we* spawned the daemon — an externally
+                // managed daemon outlives the GUI.
                 #[cfg(unix)]
-                {
+                if let Some(service) = service.as_mut() {
                     let pid = service.id() as libc::pid_t;
                     unsafe {
                         libc::kill(pid, libc::SIGINT);
@@ -141,7 +154,7 @@ fn run() -> Result<(), LanMouseError> {
                     }
                 }
                 #[cfg(not(unix))]
-                {
+                if let Some(service) = service.as_mut() {
                     let _ = service.kill();
                     let _ = service.wait();
                 }