Fix startup failure from fd exhaustion when launched via Finder (#500)

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

crates/yaak-models/src/blob_manager.rs

@@ -5,7 +5,6 @@ use log::{debug, info};
 use r2d2::Pool;
 use r2d2_sqlite::SqliteConnectionManager;
 use rusqlite::{OptionalExtension, params};
-use std::sync::{Arc, Mutex};
 
 static BLOB_MIGRATIONS_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/blob_migrations");
 
@@ -25,23 +24,21 @@ impl BodyChunk {
 }
 
 /// Manages the blob database connection pool.
+// Pool is internally synchronized — don't wrap it in a Mutex. A Mutex held across the
+// blocking `get()` serializes every blob access behind the slowest waiter, freezing the
+// whole app whenever the pool is exhausted.
 #[derive(Debug, Clone)]
 pub struct BlobManager {
-    pool: Arc<Mutex<Pool<SqliteConnectionManager>>>,
+    pool: Pool<SqliteConnectionManager>,
 }
 
 impl BlobManager {
     pub fn new(pool: Pool<SqliteConnectionManager>) -> Self {
-        Self { pool: Arc::new(Mutex::new(pool)) }
+        Self { pool }
     }
 
     pub fn connect(&self) -> BlobContext {
-        let conn = self
-            .pool
-            .lock()
-            .expect("Failed to gain lock on blob DB")
-            .get()
-            .expect("Failed to get blob DB connection from pool");
+        let conn = self.pool.get().expect("Failed to get blob DB connection from pool");
         BlobContext { conn }
     }
 }

crates/yaak-models/src/lib.rs

@@ -54,11 +54,15 @@ pub fn init_standalone(
         create_dir_all(parent)?;
     }
 
-    // Main database pool
+    // Main database pool. Sized for concurrent in-flight queries, not concurrent app
+    // features — connections are held per-statement, so even heavy fan-out (e.g. many
+    // gRPC streams) only needs a handful at once. Keep max_size modest: WAL connections
+    // hold ~3 file descriptors each, and macOS GUI apps get a 256 fd soft limit.
     info!("Initializing app database {db_path:?}");
     let manager = sqlite_file_manager(db_path);
     let pool = Pool::builder()
-        .max_size(100)
+        .max_size(20)
+        .min_idle(Some(2))
         .connection_timeout(Duration::from_secs(10))
         .build(manager)
         .map_err(|e| Error::Database(e.to_string()))?;
@@ -70,7 +74,8 @@ pub fn init_standalone(
     // Blob database pool
     let blob_manager = sqlite_file_manager(blob_path);
     let blob_pool = Pool::builder()
-        .max_size(50)
+        .max_size(10)
+        .min_idle(Some(1))
         .connection_timeout(Duration::from_secs(10))
         .build(blob_manager)
         .map_err(|e| Error::Database(e.to_string()))?;

crates/yaak-models/src/query_manager.rs

@@ -4,27 +4,25 @@ use crate::util::ModelPayload;
 use r2d2::Pool;
 use r2d2_sqlite::SqliteConnectionManager;
 use rusqlite::TransactionBehavior;
-use std::sync::{Arc, Mutex, mpsc};
+use std::sync::mpsc;
 use yaak_database::{ConnectionOrTx, DbContext};
 
+// Pool is internally synchronized — don't wrap it in a Mutex. A Mutex held across the
+// blocking `get()` serializes every DB access behind the slowest waiter, freezing the
+// whole app whenever the pool is exhausted.
 #[derive(Debug, Clone)]
 pub struct QueryManager {
-    pool: Arc<Mutex<Pool<SqliteConnectionManager>>>,
+    pool: Pool<SqliteConnectionManager>,
     events_tx: mpsc::Sender<ModelPayload>,
 }
 
 impl QueryManager {
     pub fn new(pool: Pool<SqliteConnectionManager>, events_tx: mpsc::Sender<ModelPayload>) -> Self {
-        QueryManager { pool: Arc::new(Mutex::new(pool)), events_tx }
+        QueryManager { pool, events_tx }
     }
 
     pub fn connect(&self) -> ClientDb<'_> {
-        let conn = self
-            .pool
-            .lock()
-            .expect("Failed to gain lock on DB")
-            .get()
-            .expect("Failed to get a new DB connection from the pool");
+        let conn = self.pool.get().expect("Failed to get a new DB connection from the pool");
         let ctx = DbContext::new(ConnectionOrTx::Connection(conn));
         ClientDb::new(ctx, self.events_tx.clone())
     }
@@ -33,12 +31,7 @@ impl QueryManager {
     where
         F: FnOnce(&ClientDb) -> T,
     {
-        let conn = self
-            .pool
-            .lock()
-            .expect("Failed to gain lock on DB for transaction")
-            .get()
-            .expect("Failed to get new DB connection from the pool");
+        let conn = self.pool.get().expect("Failed to get new DB connection from the pool");
 
         let ctx = DbContext::new(ConnectionOrTx::Connection(conn));
         let db = ClientDb::new(ctx, self.events_tx.clone());
@@ -53,12 +46,7 @@ impl QueryManager {
     where
         E: From<crate::error::Error>,
     {
-        let mut conn = self
-            .pool
-            .lock()
-            .expect("Failed to gain lock on DB for transaction")
-            .get()
-            .expect("Failed to get new DB connection from the pool");
+        let mut conn = self.pool.get().expect("Failed to get new DB connection from the pool");
         let tx = conn
             .transaction_with_behavior(TransactionBehavior::Immediate)
             .expect("Failed to start DB transaction");