[WIP] feat(multi-client): Multi-client support for the application

With this change, helix becomes a multi-client application. `hx` will
automatically start the server process if necessary, and connect to it.
Buffers and language servers run as subprocesses of the server and are
used by all clients.

The client/server protocol is very simple. The server listens on a Unix
socket. The client opens the socket and sends a serialized ClientInfo to
the server, which contains the command line arguments, working directory
and some other information. The terminal file descriptor (and the stdin
file descriptor, if stdin is not a terminal) are then sent to the server
using SCM_RIGHTS. The server uses the tty file descriptor to render the
UI and receive user input exactly as it does today afer opening /dev/tty,
and uses the stdin file descriptor to create a scratch buffer.

The client listens for relevant signals such as SIGWINCH, SIGTSTP and
SIGCONT. When the client receives a signal, it sends a single byte signal
number to the server. The server responds to receiving a byte on the
socket similarly to how Helix handles signals today. One exception is
that in response to a SIGTSTP, the server sends SIGSTOP to the client's
process group instead of its own process group. This way, the server
keeps running while the client process (and the other processes in its
process group) is suspended.

When a client terminates (e.g. after :q), the server sends a single byte
exit code to the client, and the client exits using the exit code.

TODO:
- Unbreak the integration tests.
- Unbreak the Windows build. For the time being, the native Windows build will
  not support multi-client. Windows users who want multi-client can use WSL.
- Unbreak per-workspace .helix/config.toml support.
- Wait until Helix switches to Termina (helix-editor#13307), and then reimplement this
  on top of Termina. For now this depends on a forked version of Crossterm which
  is available at: https://github.com/pcc/crossterm/tree/client-server-rebase
  From a brief look at the Termina code it seems easier to extend
  Termina to support this than it was to extend Crossterm.

Author: pcc

Cargo.lock

@@ -60,3 +60,6 @@ repository = "https://github.com/helix-editor/helix"
 homepage = "https://helix-editor.com"
 license = "MPL-2.0"
 rust-version = "1.82"
+
+[patch.crates-io]
+crossterm = { git = "ssh://github.com/braydnm/crossterm.git" }

Cargo.toml

@@ -4,6 +4,8 @@ use std::{
     ops::{Add, AddAssign, Sub, SubAssign},
 };
 
+use serde::{Deserialize, Serialize};
+
 use helix_stdx::rope::RopeSliceExt;
 
 use crate::{
@@ -16,7 +18,7 @@ use crate::{
 };
 
 /// Represents a single point in a text buffer. Zero indexed.
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 pub struct Position {
     pub row: usize,
     pub col: usize,

helix-core/src/position.rs

@@ -21,12 +21,13 @@ bitflags.workspace = true
 once_cell = "1.21"
 regex-automata = "0.4.9"
 unicode-segmentation.workspace = true
+tokio = { version = "1.38.0", features = ["net"] }
 
 [target.'cfg(windows)'.dependencies]
 windows-sys = { version = "0.60", features = ["Win32_Foundation", "Win32_Security", "Win32_Security_Authorization", "Win32_Storage_FileSystem", "Win32_System_Threading"] }
 
 [target.'cfg(unix)'.dependencies]
-rustix = { version = "1.0", features = ["fs"] }
+rustix = { version = "1.0", features = ["fs", "net"] }
 
 [dev-dependencies]
 tempfile.workspace = true

helix-stdx/Cargo.toml

@@ -3,5 +3,6 @@ pub mod faccess;
 pub mod path;
 pub mod range;
 pub mod rope;
+pub mod socket;
 
 pub use range::Range;

helix-stdx/src/lib.rs

@@ -0,0 +1,36 @@
+use rustix::fd::AsFd;
+use rustix::net::{
+    recvmsg, sendmsg, RecvAncillaryBuffer, RecvAncillaryMessage, RecvFlags, SendAncillaryBuffer,
+    SendAncillaryMessage, SendFlags,
+};
+use std::fs::File;
+use std::io::IoSlice;
+use std::io::{self, IoSliceMut};
+use std::mem::MaybeUninit;
+
+pub fn write_fd<Fd: AsFd>(socket: Fd, file: &File) -> io::Result<()> {
+    let mut space = [MaybeUninit::uninit(); rustix::cmsg_space!(ScmRights(1))];
+    let mut buf = SendAncillaryBuffer::new(&mut space);
+    let fd_arr = [file.as_fd()];
+    buf.push(SendAncillaryMessage::ScmRights(&fd_arr));
+    sendmsg(socket, &[IoSlice::new(&[0])], &mut buf, SendFlags::empty())?;
+    Ok(())
+}
+
+pub fn read_fd<Fd: AsFd>(socket: Fd) -> io::Result<File> {
+    let mut space = [MaybeUninit::uninit(); rustix::cmsg_space!(ScmRights(1))];
+    let mut buf = RecvAncillaryBuffer::new(&mut space);
+    let mut recv_buf = [0];
+    recvmsg(
+        socket,
+        &mut [IoSliceMut::new(&mut recv_buf)],
+        &mut buf,
+        RecvFlags::empty(),
+    )?;
+    if let Some(RecvAncillaryMessage::ScmRights(mut fd)) = buf.drain().next() {
+        if let Some(fd) = fd.next() {
+            return Ok(fd.into());
+        }
+    }
+    Err(io::Error::new(io::ErrorKind::Other, "did not receive fd"))
+}

helix-stdx/src/socket.rs

@@ -90,6 +90,9 @@ serde = { version = "1.0", features = ["derive"] }
 # ripgrep for global search
 grep-regex = "0.1.13"
 grep-searcher = "0.1.14"
+rmp-serde = "1.3.0"
+tokio-util = { version = "0.7.15", features = ["io", "io-util"] }
+async-stream = "0.3.6"
 
 [target.'cfg(not(windows))'.dependencies]  # https://github.com/vorner/signal-hook/issues/100
 signal-hook-tokio = { version = "0.3", features = ["futures-v0_3"] }