feat(tui): refactor into modular architecture with async ping support

Split monolithic tui/app.rs (721 lines) and tui/ui.rs (572 lines) into
a well-organized module structure:

  - models.rs:     enums, small types (Tab, AppMode, EditState, PingStatus, ...)
  - state.rs:      App struct and state management with mpsc ping channel
  - input.rs:      keyboard handlers dispatched per tab/mode
  - event_loop.rs: terminal setup/teardown and main loop
  - ui/mod.rs:     draw dispatcher routing to tab views and overlays
  - ui/header.rs, list.rs, detail.rs, status.rs, overlays.rs, history.rs, config.rs, helpers.rs

New features:
  - Tab-based navigation (Connections, History, Config)
  - Add new connection form (a key)
  - Session history view with filters
  - Environment management in Config tab
  - Connection grouping by tag (f key)
  - Quick-connect bar (: key)
  - Multi-select and batch delete (Space, Ctrl+A, x)
  - SSH command preview (p key)
  - Async TCP ping with colored indicators (P key)
    - Green dot for reachable (with round-trip time)
    - Red dot for unreachable
    - Yellow circle for in-progress
  - Shared ping service (services/ping.rs) using tokio TcpStream

Bump version to 1.4.1.

Author: abdoufermat5

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bayesian-ssh"
-version = "1.4.0"
+version = "1.4.1"
 edition = "2021"
 authors = ["Abdoufermat5"]
 description = "A fast and lightweight SSH session manager with Kerberos support"

src/cli/commands/tui.rs

@@ -2,7 +2,8 @@
 
 use crate::config::AppConfig;
 use crate::services::SshService;
-use crate::tui::app::{run_tui, PendingAction};
+use crate::tui::event_loop::run_tui;
+use crate::tui::models::PendingAction;
 use anyhow::Result;
 
 /// Execute the TUI command

src/services/mod.rs

@@ -1,3 +1,4 @@
+pub mod ping;
 pub mod ssh;
 
 pub use ssh::*;

src/services/ping.rs

@@ -0,0 +1,33 @@
+//! Lightweight TCP-level ping for SSH host reachability checks.
+//!
+//! Uses `tokio::net::TcpStream::connect` with a timeout to test whether
+//! a host:port is reachable.  This avoids spawning an external `ssh`
+//! process and is suitable for background checks in the TUI.
+
+use std::time::{Duration, Instant};
+use tokio::net::TcpStream;
+use tokio::time::timeout;
+
+/// Result of a TCP ping attempt.
+#[derive(Debug, Clone)]
+pub enum PingResult {
+    /// Host is reachable; includes the round-trip time.
+    Reachable(Duration),
+    /// Host did not respond within the timeout or the connection was refused.
+    Unreachable,
+}
+
+/// Attempt a TCP connection to `host:port` with the given `timeout_secs`.
+///
+/// For connections that go through a bastion host, callers should ping the
+/// bastion (`bastion_host:22`) rather than the final target since the
+/// target is typically not directly reachable.
+pub async fn tcp_ping(host: &str, port: u16, timeout_secs: u64) -> PingResult {
+    let addr = format!("{}:{}", host, port);
+    let start = Instant::now();
+
+    match timeout(Duration::from_secs(timeout_secs), TcpStream::connect(&addr)).await {
+        Ok(Ok(_stream)) => PingResult::Reachable(start.elapsed()),
+        _ => PingResult::Unreachable,
+    }
+}