feat: add resource limits management and network client integration

- Introduced a new module for managing process resource limits, specifically for raising the open file limit on Unix systems.
- Added a `NetworkClients` struct to handle reusable outbound HTTP clients, improving network request management.
- Updated various components, including `ControlService` and `CursorProxy`, to utilize the new network client structure for better client handling.
- Enhanced the API router to accept network clients, ensuring consistent client usage across different services.
- Added tests to validate the integration of network clients and resource limits functionality.

apps/desktop/src-tauri/Cargo.toml

@@ -14,6 +14,7 @@ tauri-build = { version = "2", features = [] }
 [dependencies]
 axum = "0.8"
 cursor-server = { path = "../../../server" }
+libc = "0.2"
 rfd = "0.15"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

apps/desktop/src-tauri/src/desktop.rs

@@ -149,6 +149,23 @@ pub fn run() -> ExitCode {
             return ExitCode::FAILURE;
         }
     };
+    #[cfg(unix)]
+    {
+        let open_file_limit = match crate::resource_limits::raise_open_file_limit() {
+            Ok(limit) => limit,
+            Err(error) => {
+                diagnostics.report_fatal(&error);
+                return ExitCode::FAILURE;
+            }
+        };
+        tracing::info!(
+            requested = crate::resource_limits::REQUESTED_OPEN_FILE_LIMIT,
+            previous = open_file_limit.previous,
+            effective = open_file_limit.effective,
+            hard = open_file_limit.hard,
+            "open file limit configured"
+        );
+    }
     tracing::info!(
         version = env!("CARGO_PKG_VERSION"),
         os = std::env::consts::OS,

apps/desktop/src-tauri/src/lib.rs

@@ -1,6 +1,7 @@
 mod desktop;
 #[cfg(not(dev))]
 mod frontend;
+mod resource_limits;
 mod startup;
 mod tray;
 

apps/desktop/src-tauri/src/resource_limits.rs

@@ -0,0 +1,56 @@
+//! Configures process resource limits before the desktop runtime starts.
+
+#[cfg(unix)]
+use std::io;
+
+#[cfg(unix)]
+pub(crate) const REQUESTED_OPEN_FILE_LIMIT: u64 = 65_536;
+
+#[cfg(unix)]
+pub(crate) struct OpenFileLimit {
+    pub(crate) previous: u64,
+    pub(crate) effective: u64,
+    pub(crate) hard: u64,
+}
+
+#[cfg(unix)]
+pub(crate) fn raise_open_file_limit() -> io::Result<OpenFileLimit> {
+    let mut limits = libc::rlimit {
+        rlim_cur: 0,
+        rlim_max: 0,
+    };
+    // SAFETY: `limits` points to writable memory for one `rlimit` value.
+    if unsafe { libc::getrlimit(libc::RLIMIT_NOFILE, &mut limits) } != 0 {
+        return Err(io::Error::last_os_error());
+    }
+
+    let previous = limits.rlim_cur;
+    let target = limits
+        .rlim_max
+        .min(REQUESTED_OPEN_FILE_LIMIT as libc::rlim_t);
+    if previous < target {
+        let requested = libc::rlimit {
+            rlim_cur: target,
+            rlim_max: limits.rlim_max,
+        };
+        // SAFETY: `requested` is a valid `rlimit` value and does not raise the hard limit.
+        if unsafe { libc::setrlimit(libc::RLIMIT_NOFILE, &requested) } != 0 {
+            return Err(io::Error::last_os_error());
+        }
+    }
+
+    let mut effective = libc::rlimit {
+        rlim_cur: 0,
+        rlim_max: 0,
+    };
+    // SAFETY: `effective` points to writable memory for one `rlimit` value.
+    if unsafe { libc::getrlimit(libc::RLIMIT_NOFILE, &mut effective) } != 0 {
+        return Err(io::Error::last_os_error());
+    }
+
+    Ok(OpenFileLimit {
+        previous: previous as u64,
+        effective: effective.rlim_cur as u64,
+        hard: effective.rlim_max as u64,
+    })
+}