Bump version to 0.16.0

Author: ruphy

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "sshdb"
-version = "0.15.0"
+version = "0.16.0"
 edition = "2021"
 description = "Keyboard-first SSH library and launcher TUI."
 authors = ["Riccardo Iaconelli <[email protected]>"]

Cargo.toml

@@ -3,7 +3,7 @@
 
 use std::path::PathBuf;
 
-use anyhow::{anyhow, Context, Result};
+use anyhow::{anyhow, bail, Context, Result};
 use crossterm::event::{Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers};
 use fuzzy_matcher::skim::SkimMatcherV2;
 use fuzzy_matcher::FuzzyMatcher;
@@ -48,14 +48,16 @@ pub struct BastionDropdownState {
     pub search_filter: String,
     pub filtered_indices: Vec<usize>,
     pub selected: usize,
+    exclude_host: Option<String>,
 }
 
 impl BastionDropdownState {
-    pub fn new(config: &Config) -> Self {
+    pub fn new(config: &Config, exclude_host: Option<&str>) -> Self {
         let mut state = Self {
             search_filter: String::new(),
             filtered_indices: Vec::new(),
             selected: 0,
+            exclude_host: exclude_host.map(|s| s.to_string()),
         };
         state.rebuild_filter(config);
         state
@@ -64,10 +66,19 @@ impl BastionDropdownState {
     pub fn rebuild_filter(&mut self, config: &Config) {
         let matcher = SkimMatcherV2::default();
         if self.search_filter.is_empty() {
-            self.filtered_indices = (0..config.hosts.len()).collect();
+            self.filtered_indices = config
+                .hosts
+                .iter()
+                .enumerate()
+                .filter(|(_, h)| self.exclude_host.as_deref() != Some(&h.name))
+                .map(|(i, _)| i)
+                .collect();
         } else {
             let mut scored: Vec<(i64, usize)> = Vec::new();
             for (i, host) in config.hosts.iter().enumerate() {
+                if self.exclude_host.as_deref() == Some(&host.name) {
+                    continue;
+                }
                 let haystack = format!(
                     "{} {} {} {}",
                     host.name,
@@ -96,6 +107,7 @@ pub struct FormState {
     pub fields: Vec<FormField>,
     pub index: usize,
     pub bastion_dropdown: Option<BastionDropdownState>,
+    editing_host_name: Option<String>,
 }
 
 impl FormState {
@@ -206,6 +218,7 @@ impl FormState {
             fields,
             index: 0,
             bastion_dropdown: None,
+            editing_host_name: host.map(|h| h.name.clone()),
         }
     }
 
@@ -453,7 +466,7 @@ impl FormState {
         } else {
             5
         };
-        let mut dropdown = BastionDropdownState::new(config);
+        let mut dropdown = BastionDropdownState::new(config, self.editing_host_name.as_deref());
         // Initialize search filter with current field value
         if let Some(f) = self.fields.get(bastion_field_idx) {
             dropdown.search_filter = f.value.clone();
@@ -1028,9 +1041,18 @@ impl App {
                         match form.build_host() {
                             Ok(host) => {
                                 let action = form.kind;
-                                self.save_host(action, host)?;
-                                self.form = None;
-                                self.mode = Mode::Normal;
+                                match self.save_host(action, host) {
+                                    Ok(_) => {
+                                        self.form = None;
+                                        self.mode = Mode::Normal;
+                                    }
+                                    Err(e) => {
+                                        self.status = Some(StatusLine {
+                                            text: e.to_string(),
+                                            kind: StatusKind::Error,
+                                        });
+                                    }
+                                }
                             }
                             Err(e) => {
                                 self.status = Some(StatusLine {
@@ -1190,6 +1212,23 @@ impl App {
     }
 
     fn save_host(&mut self, kind: FormKind, host: Host) -> Result<()> {
+        let mut validation_config = self.config.clone();
+        match kind {
+            FormKind::Add => validation_config.hosts.push(host.clone()),
+            FormKind::Edit => {
+                if let Some(idx) = self.current_index() {
+                    validation_config.hosts[idx] = host.clone();
+                } else {
+                    self.status = Some(StatusLine {
+                        text: "No host selected to edit.".into(),
+                        kind: StatusKind::Warn,
+                    });
+                    return Ok(());
+                }
+            }
+        }
+        Self::validate_bastions(&validation_config)?;
+
         match kind {
             FormKind::Add => {
                 self.push_history();
@@ -1221,6 +1260,34 @@ impl App {
         Ok(())
     }
 
+    fn validate_bastions(config: &Config) -> Result<()> {
+        for host in &config.hosts {
+            if let Some(bastion_name) = &host.bastion {
+                if bastion_name == &host.name {
+                    bail!("Host '{}' cannot use itself as bastion.", host.name);
+                }
+
+                let mut seen: Vec<String> = vec![host.name.clone()];
+                let mut current = bastion_name.as_str();
+                loop {
+                    if seen.iter().any(|h| h == current) {
+                        bail!(
+                            "Circular bastion reference detected involving '{}'.",
+                            current
+                        );
+                    }
+                    let Some(bastion) = config.find_host(current) else {
+                        break;
+                    };
+                    seen.push(current.to_string());
+                    let Some(next) = &bastion.bastion else { break };
+                    current = next;
+                }
+            }
+        }
+        Ok(())
+    }
+
     fn current_index(&self) -> Option<usize> {
         self.filtered_indices.get(self.selected).cloned()
     }
@@ -1518,6 +1585,41 @@ mod tests {
         assert_eq!(spec.remote_command.as_deref(), Some("uptime"));
     }
 
+    #[test]
+    fn rejects_self_bastion() {
+        let app = test_app();
+        let mut config = app.config.clone();
+        if let Some(host) = config.hosts.first_mut() {
+            host.bastion = Some(host.name.clone());
+        }
+        let err = App::validate_bastions(&config).unwrap_err();
+        assert!(err.to_string().contains("cannot use itself as bastion"));
+    }
+
+    #[test]
+    fn rejects_circular_bastions() {
+        let app = test_app();
+        let mut config = app.config.clone();
+        if let Some(jump) = config.hosts.iter_mut().find(|h| h.name == "jump-eu") {
+            jump.bastion = Some("staging-db".into());
+        }
+        let err = App::validate_bastions(&config).unwrap_err();
+        assert!(err
+            .to_string()
+            .to_lowercase()
+            .contains("circular bastion reference"));
+    }
+
+    #[test]
+    fn allows_unknown_bastion_name() {
+        let app = test_app();
+        let mut config = app.config.clone();
+        if let Some(host) = config.hosts.first_mut() {
+            host.bastion = Some("external.example.com".into());
+        }
+        App::validate_bastions(&config).unwrap();
+    }
+
     #[test]
     fn quick_connect_adds_or_reuses() {
         let mut app = test_app();
@@ -1531,4 +1633,17 @@ mod tests {
         app.quick_connect(spec).unwrap();
         assert_eq!(app.config.hosts.len(), initial + 1);
     }
+
+    #[test]
+    fn bastion_dropdown_excludes_current_host() {
+        let config = Config::sample();
+        let host = config.hosts[0].clone();
+        let mut form = FormState::new(FormKind::Edit, Some(&host), &config);
+        form.open_bastion_dropdown(&config);
+        let dropdown = form.bastion_dropdown.as_ref().expect("dropdown opened");
+        assert!(dropdown
+            .filtered_indices
+            .iter()
+            .all(|i| config.hosts[*i].name != host.name));
+    }
 }

src/app.rs

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // SPDX-FileCopyrightText: 2024 Riccardo Iaconelli <[email protected]>
 
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 
-use anyhow::{Context, Result};
+use anyhow::Result;
 
 use crate::model::{Config, Host};
 
@@ -121,9 +121,9 @@ fn build_bastion_string(
     }
     visited.push(bastion_name.to_string());
 
-    let bastion = config
-        .find_host(bastion_name)
-        .with_context(|| format!("bastion host '{}' not found", bastion_name))?;
+    let Some(bastion) = config.find_host(bastion_name) else {
+        return Ok(bastion_name.to_string());
+    };
 
     let mut chains = Vec::new();
     if let Some(nested) = &bastion.bastion {
@@ -167,11 +167,14 @@ fn select_key(host_key: Option<&str>, default_key: Option<&str>) -> Option<Strin
         return None;
     }
 
-    // fall back to common keys when no agent is present
-    if let Some(cand) = FALLBACKS.first() {
-        return Some(expand_tilde(cand));
+    // fall back to common keys when no agent is present; prefer an existing one
+    for cand in FALLBACKS {
+        let expanded = expand_tilde(cand);
+        if Path::new(&expanded).exists() {
+            return Some(expanded);
+        }
     }
-    None
+    FALLBACKS.first().map(|cand| expand_tilde(cand))
 }
 
 fn expand_tilde(path: &str) -> String {
@@ -216,6 +219,27 @@ mod tests {
         assert!(preview.contains("-L 8080:localhost:80"));
     }
 
+    #[test]
+    fn allows_free_text_bastion() {
+        let mut config = Config::default();
+        let host = Host {
+            name: "prod".into(),
+            address: "10.0.0.1".into(),
+            user: Some("deploy".into()),
+            port: None,
+            key_path: None,
+            tags: vec![],
+            options: vec![],
+            remote_command: None,
+            description: None,
+            bastion: Some("proxy.example.com".into()),
+        };
+        config.hosts.push(host.clone());
+        let preview = command_preview(&host, &config, None, None);
+        assert!(preview.contains("-J proxy.example.com"));
+        assert!(preview.contains("[email protected]"));
+    }
+
     #[test]
     fn expands_tilde() {
         let out = expand_tilde("~/abc");

src/ssh.rs

@@ -1,8 +1,8 @@
 class Sshdb < Formula
   desc "Keyboard-first SSH library and launcher TUI"
   homepage "https://github.com/ruphy/sshdb"
-  url "https://github.com/ruphy/sshdb/archive/refs/tags/v0.15.0.tar.gz"
-  sha256 "f0fed6beb31bc95fd75b7ed9e1dd0cd11a5588e3934b27d8b469049c91a27e57"
+  url "https://github.com/ruphy/sshdb/archive/refs/tags/v0.16.0.tar.gz"
+  sha256 "PLACEHOLDER_SHA256_WILL_BE_UPDATED_AFTER_RELEASE"
   license "GPL-3.0-or-later"
   depends_on "rust" => :build