feat(linux): connection health pill in header bar

EntryInner gains a ConnectionHealth field (Healthy or
Reconnecting{attempt}). The monitor task writes Reconnecting at the
start of the backoff loop and on every retry, then back to Healthy
after a successful reconnect.

DatabaseService.active_health() exposes the active connection's
state. App polls every 1s via glib::timeout_add_seconds_local and
updates a label in the header bar — green "Connected" pill when
Healthy, yellow "Reconnecting (attempt N)" pill while in the retry
loop, hidden when no active connection.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: datlechin

linux/crates/app/src/services/connection_monitor.rs

@@ -7,7 +7,7 @@ use tablepro_core::Connection;
 use tablepro_ssh::SshTunnel;
 
 use super::connection_service;
-use super::database_service::{EntryInner, ReconnectParams};
+use super::database_service::{ConnectionHealth, EntryInner, ReconnectParams};
 
 const PING_INTERVAL: Duration = Duration::from_secs(30);
 const BACKOFF_INITIAL: Duration = Duration::from_secs(5);
@@ -45,6 +45,7 @@ async fn reconnect_loop(
 ) -> Result<(), ()> {
     let mut delay = BACKOFF_INITIAL;
     let mut attempt: u32 = 1;
+    set_health(inner, ConnectionHealth::Reconnecting { attempt });
     loop {
         tokio::select! {
             _ = cancel.cancelled() => return Err(()),
@@ -54,12 +55,14 @@ async fn reconnect_loop(
         match try_reconnect(params).await {
             Ok((conn, tunnel)) => {
                 swap_connection(inner, conn, tunnel);
+                set_health(inner, ConnectionHealth::Healthy);
                 tracing::info!(attempt, "reconnect succeeded");
                 return Ok(());
             }
             Err(e) => {
                 tracing::warn!(error = %e, attempt, delay_secs = delay.as_secs(), "reconnect failed; backing off");
                 attempt += 1;
+                set_health(inner, ConnectionHealth::Reconnecting { attempt });
                 delay = next_delay(delay);
             }
         }
@@ -88,6 +91,12 @@ fn swap_connection(inner: &Arc<Mutex<EntryInner>>, conn: Box<dyn Connection>, tu
     }
 }
 
+fn set_health(inner: &Arc<Mutex<EntryInner>>, health: ConnectionHealth) {
+    if let Ok(mut g) = inner.lock() {
+        g.health = health;
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

linux/crates/app/src/services/database_service.rs

@@ -18,6 +18,13 @@ pub fn instance() -> &'static DatabaseService {
 pub(super) struct EntryInner {
     pub(super) connection: Arc<dyn Connection>,
     pub(super) tunnel: Option<SshTunnel>,
+    pub(super) health: ConnectionHealth,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ConnectionHealth {
+    Healthy,
+    Reconnecting { attempt: u32 },
 }
 
 pub struct ReconnectParams {
@@ -59,6 +66,7 @@ impl DatabaseService {
         let inner = Arc::new(Mutex::new(EntryInner {
             connection: arc,
             tunnel,
+            health: ConnectionHealth::Healthy,
         }));
         let cancel = CancellationToken::new();
         let monitor = tokio::spawn(connection_monitor::run(inner.clone(), params, cancel.clone()));
@@ -91,6 +99,14 @@ impl DatabaseService {
         *self.active.lock().expect("database_service lock")
     }
 
+    pub fn active_health(&self) -> Option<ConnectionHealth> {
+        let id = self.active_id()?;
+        let entries = self.connections.lock().expect("database_service lock");
+        let entry = entries.get(&id)?;
+        let inner = entry.inner.lock().expect("entry inner lock");
+        Some(inner.health.clone())
+    }
+
     pub fn is_active_read_only(&self) -> bool {
         let id = match self.active_id() {
             Some(id) => id,

linux/crates/app/src/ui/app.rs

@@ -13,6 +13,7 @@ use super::edit_dialog::{EditDialog, EditDialogInit, EditDialogOutput};
 use super::editor::SqlEditor;
 use super::grid::build_column_view;
 use super::insert_dialog::{InsertDialog, InsertDialogInit, InsertDialogOutput};
+use crate::services::database_service::ConnectionHealth;
 use crate::services::{connection_service, database_service};
 use crate::sql_dialect::{placeholder_for, quote_ident};
 
@@ -27,6 +28,8 @@ pub struct App {
     connections_popover: gtk::Popover,
     edit_button: gtk::Button,
     disconnect_button: gtk::Button,
+    health_pill: gtk::Label,
+    health_state: Option<ConnectionHealth>,
     table_search: gtk::SearchEntry,
     paginator_label: gtk::Label,
     prev_button: gtk::Button,
@@ -81,6 +84,7 @@ pub enum AppMsg {
     DeleteConnection(Uuid),
     OpenEditor,
     Disconnect,
+    PollHealth,
 }
 
 #[relm4::component(pub)]
@@ -115,6 +119,12 @@ impl SimpleComponent for App {
                         set_popover = &gtk::Popover {},
                     },
 
+                    #[name = "health_pill"]
+                    pack_end = &gtk::Label {
+                        set_visible: false,
+                        set_margin_end: 6,
+                    },
+
                     #[name = "edit_button"]
                     pack_end = &gtk::Button {
                         set_icon_name: "edit-symbolic",
@@ -311,6 +321,8 @@ impl SimpleComponent for App {
             connections_popover: widgets.connections_popover.clone(),
             edit_button: widgets.edit_button.clone(),
             disconnect_button: widgets.disconnect_button.clone(),
+            health_pill: widgets.health_pill.clone(),
+            health_state: None,
             table_search: widgets.table_search.clone(),
             paginator_label,
             prev_button,
@@ -333,6 +345,13 @@ impl SimpleComponent for App {
             connected: false,
         };
         sender.input(AppMsg::ReloadConnections);
+
+        let poll_sender = sender.clone();
+        glib::timeout_add_seconds_local(1, move || {
+            poll_sender.input(AppMsg::PollHealth);
+            glib::ControlFlow::Continue
+        });
+
         ComponentParts { model, widgets }
     }
 
@@ -672,6 +691,14 @@ impl SimpleComponent for App {
                 self.editor = Some(editor);
             }
 
+            AppMsg::PollHealth => {
+                let current = database_service::instance().active_health();
+                if current != self.health_state {
+                    self.refresh_health_pill(current.clone());
+                    self.health_state = current;
+                }
+            }
+
             AppMsg::DeleteConnection(id) => {
                 let sender_clone = sender.clone();
                 sender.command(move |_, shutdown| {
@@ -754,6 +781,27 @@ impl App {
         });
     }
 
+    fn refresh_health_pill(&self, health: Option<ConnectionHealth>) {
+        let pill = &self.health_pill;
+        pill.remove_css_class("success");
+        pill.remove_css_class("warning");
+        match health {
+            None => {
+                pill.set_visible(false);
+            }
+            Some(ConnectionHealth::Healthy) => {
+                pill.set_visible(true);
+                pill.set_label("Connected");
+                pill.add_css_class("success");
+            }
+            Some(ConnectionHealth::Reconnecting { attempt }) => {
+                pill.set_visible(true);
+                pill.set_label(&format!("Reconnecting (attempt {attempt})"));
+                pill.add_css_class("warning");
+            }
+        }
+    }
+
     fn refresh_crud_buttons(&self) {
         let read_only = database_service::instance().is_active_read_only();
         self.insert_button.set_visible(!read_only);