refactor: drop stale and redundant dependencies (#199)

Audit the full direct dependency set in `Cargo.toml`, then remove or replace crates that were dead, redundant with the standard library, or duplicated with an existing dependency. Five crates (`arrayvec`, `ctrlc`, `directories`, `signal-hook 0.4.4`, plus the macOS `objc2`/`block2`/`dispatch2` chain pulled in by `ctrlc`) are now completely gone from the build graph; three more (`lazy_static`, `once_cell`, `fastrand`) remain transitively but are no longer directly referenced by our code.

Replacements:

- `lazy_static!` → `std::sync::LazyLock` in `src/ui/tui/progress.rs` (edition 2024 already mandates Rust 1.85+).
- `once_cell::sync::Lazy` / `OnceCell` → `std::sync::LazyLock` / `OnceLock` across `executor/output_sync.rs`, `pty/terminal.rs`, `utils/logging.rs`, `ssh/ssh_config/env_cache/global.rs`, `ssh/config_cache/global.rs`.
- `fastrand::u64(range)` → `rand::random_range(range)` in the three forwarding reconnect-jitter sites; `rand` 0.10 was already a direct dependency.
- `directories::ProjectDirs` / `BaseDirs` → `dirs::config_dir` / `dirs::home_dir`, unifying on `dirs` which was already used in 16 other sites and produces equivalent platform paths.
- `ctrlc::set_handler` → `tokio::signal::ctrl_c` inside a `tokio::spawn`, guarded by `Handle::try_current` to preserve the previous best-effort semantics in non-runtime contexts. The only caller (`execute_traditional`) is already async, and the matching test runs under `#[tokio::test]`.
- `signal-hook = "0.4.4"` → `"0.3"` so we share the same instance `crossterm` already pulls in via `signal-hook-mio`. Our usage (`Signals::new`, `Signals::forever`, `consts::SIGWINCH`) has identical signatures across both major lines, so no source change was needed — only the `Cargo.toml` pin.

The `arrayvec` crate was declared but unused anywhere in the source tree, so it is simply dropped.

Build, full `cargo test -p bssh` (1303 tests), `cargo clippy --all-targets`, and `cargo fmt --check` all pass. `Cargo.lock` loses 76 lines including the entire `signal-hook 0.4.4` subtree.

Author: inureyes

Cargo.lock

@@ -37,30 +37,24 @@ futures = "0.3.32"
 async-trait = "0.1.89"
 indicatif = "0.18.4"
 rpassword = "7.4.0"
-directories = "6.0.0"
 dirs = "6.0"
 chrono = { version = "0.4.44", features = ["serde"] }
 glob = "0.3.3"
 whoami = "2.1.1"
 owo-colors = "4.3.0"
 unicode-width = "0.2.2"
 terminal_size = "0.4.4"
-once_cell = "1.21.4"
 zeroize = { version = "1.8.2", features = ["derive"] }
 secrecy = { version = "0.10.3", features = ["serde"] }
 rustyline = "18.0.0"
 crossterm = "0.29"
 ratatui = "0.30"
 regex = "1.12.3"
-lazy_static = "1.5"
-ctrlc = "3.5.2"
-signal-hook = "0.4.4"
+signal-hook = "0.3"
 nix = { version = "0.31", features = ["fs", "poll", "process", "signal", "term"] }
-arrayvec = "0.7.6"
 smallvec = "1.15.1"
 lru = "0.17.0"
 uuid = { version = "1.23.1", features = ["v4"] }
-fastrand = "2.4.1"
 tokio-util = "0.7.18"
 socket2 = "0.6"
 shell-words = "1.1.1"
@@ -85,7 +79,6 @@ security-framework = "3.7.0"
 [dev-dependencies]
 tempfile = "3.27.0"
 mockito = "1.7.2"
-once_cell = "1.21.4"
 tokio-test = "0.4"
 serial_test = "3.4"
 insta = "1.47"

Cargo.toml

@@ -33,21 +33,29 @@ pub fn reset_interrupt() {
     INTERRUPTED.store(false, Ordering::Relaxed);
 }
 
-/// Set up signal handlers for interactive mode
+/// Set up signal handlers for interactive mode.
+///
+/// Spawns a tokio task that waits for a Ctrl+C signal and flips both the
+/// global interrupt flag and the returned shutdown flag. Callers must invoke
+/// this from within a tokio runtime; without one the spawn is skipped and the
+/// shutdown flag is returned unarmed (matching the prior best-effort semantics).
 pub fn setup_signal_handlers() -> Result<Arc<AtomicBool>> {
     let shutdown = Arc::new(AtomicBool::new(false));
     let shutdown_clone = Arc::clone(&shutdown);
 
-    // Handle Ctrl+C
-    // Note: set_handler can only be called once per process, so we ignore errors in tests
-    if let Err(e) = ctrlc::set_handler(move || {
-        info!("Received Ctrl+C signal");
-        INTERRUPTED.store(true, Ordering::Relaxed);
-        shutdown_clone.store(true, Ordering::Relaxed);
-    }) {
-        // In tests, this might already be registered
-        debug!("Could not set Ctrl-C handler: {}", e);
-        // Return the shutdown flag anyway for use in the code
+    if tokio::runtime::Handle::try_current().is_ok() {
+        tokio::spawn(async move {
+            match signal::ctrl_c().await {
+                Ok(()) => {
+                    info!("Received Ctrl+C signal");
+                    INTERRUPTED.store(true, Ordering::Relaxed);
+                    shutdown_clone.store(true, Ordering::Relaxed);
+                }
+                Err(e) => debug!("Failed to install Ctrl-C handler: {}", e),
+            }
+        });
+    } else {
+        debug!("No tokio runtime active; Ctrl-C handler not installed");
     }
 
     Ok(shutdown)

src/commands/interactive_signal.rs

@@ -15,7 +15,6 @@
 //! Configuration loading and priority management.
 
 use anyhow::{Context, Result};
-use directories::ProjectDirs;
 use std::env;
 use std::path::{Path, PathBuf};
 use tokio::fs;
@@ -222,8 +221,8 @@ impl Config {
                 .join("bssh")
                 .join("config.yaml");
             return Ok(xdg_config);
-        } else if let Some(proj_dirs) = ProjectDirs::from("", "", "bssh") {
-            let xdg_config = proj_dirs.config_dir().join("config.yaml");
+        } else if let Some(config_dir) = dirs::config_dir() {
+            let xdg_config = config_dir.join("bssh").join("config.yaml");
             return Ok(xdg_config);
         }
 

src/config/loader.rs

@@ -15,15 +15,14 @@
 //! Thread-safe output synchronization for preventing race conditions
 //! when multiple nodes write to stdout/stderr simultaneously.
 
-use once_cell::sync::Lazy;
 use std::io::{self, Write};
-use std::sync::Mutex;
+use std::sync::{LazyLock, Mutex};
 
 /// Global stdout mutex to prevent interleaved output
-static STDOUT_MUTEX: Lazy<Mutex<io::Stdout>> = Lazy::new(|| Mutex::new(io::stdout()));
+static STDOUT_MUTEX: LazyLock<Mutex<io::Stdout>> = LazyLock::new(|| Mutex::new(io::stdout()));
 
 /// Global stderr mutex to prevent interleaved output
-static STDERR_MUTEX: Lazy<Mutex<io::Stderr>> = Lazy::new(|| Mutex::new(io::stderr()));
+static STDERR_MUTEX: LazyLock<Mutex<io::Stderr>> = LazyLock::new(|| Mutex::new(io::stderr()));
 
 /// Thread-safe println! that prevents output interleaving
 ///

src/executor/output_sync.rs

@@ -193,7 +193,7 @@ impl DynamicForwarder {
                     );
 
                     // Add jitter to avoid thundering herd
-                    let jitter = Duration::from_millis(fastrand::u64(
+                    let jitter = Duration::from_millis(rand::random_range(
                         0..=retry_delay.as_millis() as u64 / 4,
                     ));
                     retry_delay += jitter;

src/forwarding/dynamic/forwarder.rs

@@ -232,7 +232,7 @@ impl LocalForwarder {
                     );
 
                     // Add jitter to avoid thundering herd
-                    let jitter = Duration::from_millis(fastrand::u64(
+                    let jitter = Duration::from_millis(rand::random_range(
                         0..=retry_delay.as_millis() as u64 / 4,
                     ));
                     retry_delay += jitter;

src/forwarding/local.rs

@@ -241,7 +241,7 @@ impl RemoteForwarder {
                     );
 
                     // Add jitter to avoid thundering herd
-                    let jitter = Duration::from_millis(fastrand::u64(
+                    let jitter = Duration::from_millis(rand::random_range(
                         0..=retry_delay.as_millis() as u64 / 4,
                     ));
                     retry_delay += jitter;

src/forwarding/remote.rs

@@ -16,7 +16,7 @@
 
 use std::io::Write;
 use std::sync::{
-    Arc, Mutex,
+    Arc, LazyLock, Mutex,
     atomic::{AtomicBool, Ordering},
 };
 
@@ -26,11 +26,10 @@ use crossterm::{
     execute,
     terminal::{disable_raw_mode, enable_raw_mode},
 };
-use once_cell::sync::Lazy;
 
 /// Global terminal cleanup synchronization
 /// Ensures only one cleanup attempt happens even with multiple guards
-static TERMINAL_MUTEX: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(()));
+static TERMINAL_MUTEX: LazyLock<Mutex<()>> = LazyLock::new(|| Mutex::new(()));
 static RAW_MODE_ACTIVE: AtomicBool = AtomicBool::new(false);
 
 /// Terminal state information that needs to be preserved and restored

src/pty/terminal.rs

@@ -14,11 +14,11 @@
 
 use super::config::CacheConfig;
 use super::manager::SshConfigCache;
-use once_cell::sync::Lazy;
+use std::sync::LazyLock;
 use tracing::debug;
 
 /// Global SSH config cache instance
-pub static GLOBAL_CACHE: Lazy<SshConfigCache> = Lazy::new(|| {
+pub static GLOBAL_CACHE: LazyLock<SshConfigCache> = LazyLock::new(|| {
     let config = CacheConfig::from_env();
 
     debug!(