25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
feat(ssh): follow Include directives in ~/.ssh/config
zipge432304dbc51
diff --git a/Cargo.lock b/Cargo.lockindex 3aa488362d..ddba15accc 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -2371,12 +2371,14 @@ dependencies = ["bytes","dbx-platform","dbx-types",+ "glob","portpicker","reqwest 0.12.28","russh","serde","serde_json","sqlparser",+ "tempfile","tokio","tokio-util","uuid",diff --git a/agents/drivers/duckdb/Cargo.lock b/agents/drivers/duckdb/Cargo.lockindex a9a8d301cc..5d1bd2c2d7 100644--- a/agents/drivers/duckdb/Cargo.lock+++ b/agents/drivers/duckdb/Cargo.lock@@ -1467,6 +1467,7 @@ dependencies = ["bytes","dbx-platform","dbx-types",+ "glob","portpicker","reqwest","russh",@@ -2373,6 +2374,12 @@ dependencies = ["polyval 0.7.3",]+[[package]]+name = "glob"+version = "0.3.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b"+[[package]]name = "half"version = "2.7.1"diff --git a/crates/dbx-driver-support/Cargo.toml b/crates/dbx-driver-support/Cargo.tomlindex b3a9bc4c6b..e8959339b0 100644--- a/crates/dbx-driver-support/Cargo.toml+++ b/crates/dbx-driver-support/Cargo.toml@@ -13,6 +13,7 @@ test-support = ["dbx-platform/test-support"]dbx-platform = { path = "../dbx-platform" }dbx-types = { path = "../dbx-types", default-features = false }bytes = "1"+glob = "0.3"portpicker = "0.1.1"reqwest = { version = "0.12", default-features = false, features = ["rustls-tls"] }russh = "0.60"@@ -24,4 +25,5 @@ tokio-util = { version = "0.7", features = ["rt"] }uuid = { version = "1", features = ["v4"] }[dev-dependencies]+tempfile = "3"tokio = { version = "1", features = ["macros", "rt-multi-thread", "test-util"] }diff --git a/crates/dbx-driver-support/src/ssh_config.rs b/crates/dbx-driver-support/src/ssh_config.rsindex 5096a55504..0ac31b0dc5 100644--- a/crates/dbx-driver-support/src/ssh_config.rs+++ b/crates/dbx-driver-support/src/ssh_config.rs@@ -1,3 +1,7 @@+use std::collections::HashSet;+use std::path::{Path, PathBuf};++use glob::{glob_with, MatchOptions};use serde::Serialize;use crate::models::connection::SshTunnelConfig;@@ -24,16 +28,15 @@ pub struct SshConfigHostEntry {pub proxy_jump: Option<String>,}-/// Reads and parses `~/.ssh/config`. Returns an empty list (not an error) if-/// the file does not exist, since that's a normal state for users without-/// an SSH config.+/// Reads and parses `~/.ssh/config`, following `Include` directives the way+/// OpenSSH does. Returns an empty list (not an error) if the file does not+/// exist, since that's a normal state for users without an SSH config.pub fn list_hosts() -> Result<Vec<SshConfigHostEntry>, String> {- let path = expand_tilde("~/.ssh/config");- match std::fs::read_to_string(&path) {- Ok(content) => Ok(parse_ssh_config(&content)),- Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(Vec::new()),- Err(err) => Err(format!("Failed to read {path}: {err}")),- }+ let path = PathBuf::from(expand_tilde("~/.ssh/config"));+ let base_dir = path.parent().map(Path::to_path_buf).unwrap_or_else(|| PathBuf::from(expand_tilde("~/.ssh")));+ let mut loader = SshConfigLoader::new(base_dir);+ loader.load_file(&path, 0, true)?;+ Ok(loader.entries)}pub fn find_host(alias: &str) -> Option<SshConfigHostEntry> {@@ -158,90 +161,168 @@ fn apply_host_entry(ssh: &SshTunnelConfig, entry: SshConfigHostEntry) -> SshTunnresolved}-/// Parses a minimal subset of OpenSSH client config syntax: `Host`, `HostName`,-/// `Port`, `User`, `IdentityFile`, `ProxyJump`. Wildcard host patterns-/// (containing `*` or `?`) are skipped since they aren't usable as a literal-/// alias in the host field. `Include` and other directives are not-/// supported, and `ProxyJump`'s comma-separated multi-hop form is read as a-/// single alias (its first hop).-fn parse_ssh_config(content: &str) -> Vec<SshConfigHostEntry> {- let mut entries: Vec<SshConfigHostEntry> = Vec::new();- let mut current_aliases: Vec<String> = Vec::new();+/// OpenSSH gives up after 16 nested `Include`s; mirror that so a config that+/// includes itself can never recurse without bound.+const MAX_INCLUDE_DEPTH: usize = 16;++/// Accumulates `Host` entries while walking a config file and, in place, the+/// files its `Include` directives pull in — OpenSSH treats an include as text+/// substitution at that exact position, so directive order (and therefore+/// first-match-wins for duplicate aliases) is preserved.+struct SshConfigLoader {+ entries: Vec<SshConfigHostEntry>,+ current_aliases: Vec<String>,+ /// Canonical paths already parsed, so include cycles terminate.+ visited: HashSet<PathBuf>,+ /// Directory that relative `Include` patterns resolve against (`~/.ssh`).+ base_dir: PathBuf,+}++impl SshConfigLoader {+ fn new(base_dir: PathBuf) -> Self {+ Self { entries: Vec::new(), current_aliases: Vec::new(), visited: HashSet::new(), base_dir }+ }- for raw_line in content.lines() {- let line = strip_comment(raw_line).trim();- if line.is_empty() {- continue;+ /// Reads `path` and folds its directives into this loader's entries.+ ///+ /// `strict` propagates read failures (used for the top-level config, where+ /// an unreadable file is a real error); included files follow OpenSSH and+ /// are skipped silently when they are missing or unreadable.+ fn load_file(&mut self, path: &Path, depth: usize, strict: bool) -> Result<(), String> {+ let identity = std::fs::canonicalize(path).unwrap_or_else(|_| path.to_path_buf());+ if !self.visited.insert(identity) {+ return Ok(());}- let Some((keyword, value)) = split_directive(line) else {- continue;+ let content = match std::fs::read_to_string(path) {+ Ok(content) => content,+ Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(()),+ Err(err) => {+ return if strict { Err(format!("Failed to read {}: {err}", path.display())) } else { Ok(()) };+ }};-- match keyword.to_ascii_lowercase().as_str() {- "host" => {- current_aliases = value- .split_whitespace()- .filter(|alias| !alias.contains('*') && !alias.contains('?'))- .map(str::to_string)- .collect();- for alias in ¤t_aliases {- entries.push(SshConfigHostEntry {- alias: alias.clone(),- host_name: None,- port: None,- user: None,- identity_file: None,- proxy_jump: None,- });- }+ self.parse_lines(&content, true, depth)+ }++ /// Parses a minimal subset of OpenSSH client config syntax: `Host`,+ /// `HostName`, `Port`, `User`, `IdentityFile`, `ProxyJump`, `Include`.+ /// Wildcard host patterns (containing `*` or `?`) are skipped since they+ /// aren't usable as a literal alias in the host field. `ProxyJump`'s+ /// comma-separated multi-hop form is read as a single alias (its first+ /// hop). Unknown directives are ignored.+ fn parse_lines(&mut self, content: &str, follow_includes: bool, depth: usize) -> Result<(), String> {+ for raw_line in content.lines() {+ let line = strip_comment(raw_line).trim();+ if line.is_empty() {+ continue;}- "hostname" => set_current_field(&mut entries, ¤t_aliases, |entry| {- entry.host_name = Some(value.to_string());- }),- "port" => {- if let Ok(port) = value.parse::<u16>() {- set_current_field(&mut entries, ¤t_aliases, |entry| {- entry.port = Some(port);- });+ let Some((keyword, value)) = split_directive(line) else {+ continue;+ };++ if keyword.eq_ignore_ascii_case("include") {+ if follow_includes && depth < MAX_INCLUDE_DEPTH {+ for included in self.include_paths(value) {+ self.load_file(&included, depth + 1, false)?;+ }}+ continue;}- "user" => set_current_field(&mut entries, ¤t_aliases, |entry| {- entry.user = Some(value.to_string());- }),- "identityfile" => set_current_field(&mut entries, ¤t_aliases, |entry| {- entry.identity_file = Some(value.to_string());- }),- "proxyjump" => {- if let Some(first_hop) = value.split(',').next().map(str::trim).filter(|hop| !hop.is_empty()) {- // A `user@host:port` jump target names an alias-incompatible- // literal host; only a plain alias is resolvable here.- if !first_hop.contains('@') && !first_hop.contains(':') {- let first_hop = first_hop.to_string();- set_current_field(&mut entries, ¤t_aliases, |entry| {- entry.proxy_jump = Some(first_hop.clone());++ match keyword.to_ascii_lowercase().as_str() {+ "host" => {+ let aliases: Vec<String> = value+ .split_whitespace()+ .filter(|alias| !alias.contains('*') && !alias.contains('?'))+ .map(str::to_string)+ .collect();+ for alias in &aliases {+ self.entries.push(SshConfigHostEntry {+ alias: alias.clone(),+ host_name: None,+ port: None,+ user: None,+ identity_file: None,+ proxy_jump: None,});}+ self.current_aliases = aliases;}+ "hostname" => self.set_current_field(|entry| {+ entry.host_name = Some(value.to_string());+ }),+ "port" => {+ if let Ok(port) = value.parse::<u16>() {+ self.set_current_field(|entry| {+ entry.port = Some(port);+ });+ }+ }+ "user" => self.set_current_field(|entry| {+ entry.user = Some(value.to_string());+ }),+ "identityfile" => self.set_current_field(|entry| {+ entry.identity_file = Some(value.to_string());+ }),+ "proxyjump" => {+ if let Some(first_hop) = value.split(',').next().map(str::trim).filter(|hop| !hop.is_empty()) {+ // A `user@host:port` jump target names an alias-incompatible+ // literal host; only a plain alias is resolvable here.+ if !first_hop.contains('@') && !first_hop.contains(':') {+ let first_hop = first_hop.to_string();+ self.set_current_field(|entry| {+ entry.proxy_jump = Some(first_hop.clone());+ });+ }+ }+ }+ _ => {}}- _ => {}}+ Ok(())+ }++ /// Expands one `Include` line into the files it names, mirroring OpenSSH:+ /// `~` is expanded, relative patterns resolve against `base_dir`, glob+ /// wildcards are honored, and patterns that match nothing (missing files)+ /// are skipped instead of failing the whole config.+ fn include_paths(&self, value: &str) -> Vec<PathBuf> {+ let options = MatchOptions { require_literal_leading_dot: true, ..MatchOptions::default() };+ let mut paths = Vec::new();+ for pattern in value.split_whitespace() {+ let expanded = expand_tilde(pattern);+ let candidate =+ if Path::new(&expanded).is_absolute() { PathBuf::from(expanded) } else { self.base_dir.join(expanded) };+ let Ok(matches) = glob_with(&candidate.to_string_lossy(), options) else {+ continue;+ };+ let mut files: Vec<PathBuf> = matches.filter_map(Result::ok).collect();+ // glob order is filesystem-dependent; sorting keeps host ordering+ // (and therefore duplicate-alias resolution) reproducible.+ files.sort();+ paths.extend(files);+ }+ paths}- entries-}--fn set_current_field(- entries: &mut [SshConfigHostEntry],- current_aliases: &[String],- apply: impl Fn(&mut SshConfigHostEntry),-) {- for entry in entries.iter_mut() {- if current_aliases.contains(&entry.alias) {- apply(entry);+ fn set_current_field(&mut self, apply: impl Fn(&mut SshConfigHostEntry)) {+ let aliases = self.current_aliases.as_slice();+ for entry in self.entries.iter_mut() {+ if aliases.contains(&entry.alias) {+ apply(entry);+ }}}}+/// Parses config text that stands on its own (tests, snippets): `Include` is+/// not followed because there is no file context to resolve it against.+#[cfg(test)]+fn parse_ssh_config(content: &str) -> Vec<SshConfigHostEntry> {+ let mut loader = SshConfigLoader::new(PathBuf::new());+ let _ = loader.parse_lines(content, false, 0);+ loader.entries+}+fn strip_comment(line: &str) -> &str {match line.find('#') {Some(index) => &line[..index],@@ -496,3 +577,165 @@ mod tests {assert_eq!(chain.last().unwrap().host, "1.1.1.1");}}++#[cfg(test)]+mod include_tests {+ use super::*;+ use tempfile::TempDir;++ /// Writes `content` to `dir/relative`, creating parent directories.+ fn write_config(dir: &Path, relative: &str, content: &str) -> PathBuf {+ let path = dir.join(relative);+ if let Some(parent) = path.parent() {+ std::fs::create_dir_all(parent).expect("create parent dirs");+ }+ std::fs::write(&path, content).expect("write config file");+ path+ }++ /// Loads `path` with `base_dir` as the include root, exactly like+ /// `list_hosts` does with `~/.ssh`.+ fn hosts_from(path: &Path, base_dir: &Path) -> Vec<SshConfigHostEntry> {+ let mut loader = SshConfigLoader::new(base_dir.to_path_buf());+ loader.load_file(path, 0, true).expect("load config");+ loader.entries+ }++ fn aliases(entries: &[SshConfigHostEntry]) -> Vec<&str> {+ entries.iter().map(|entry| entry.alias.as_str()).collect()+ }++ #[test]+ fn follows_relative_glob_includes_in_sorted_order() {+ let dir = TempDir::new().unwrap();+ let main = write_config(+ dir.path(),+ "config",+ "Host direct\n HostName 10.0.0.1\nInclude conf.d/*\nHost local\n HostName 10.0.0.2\n",+ );+ write_config(+ dir.path(),+ "conf.d/10-proxy.conf",+ "Host abc\n HostName 10.0.1.1\n User ops\n ProxyCommand nc %h %p\n",+ );+ write_config(dir.path(), "conf.d/20-extra.conf", "Host zzz\n HostName 10.0.1.2\n");++ let entries = hosts_from(&main, dir.path());++ // Includes are substituted in place, so hosts land between `direct`+ // and `local`; glob results are sorted for reproducibility.+ assert_eq!(aliases(&entries), vec!["direct", "abc", "zzz", "local"]);+ let abc = &entries[1];+ assert_eq!(abc.host_name, Some("10.0.1.1".to_string()));+ assert_eq!(abc.user, Some("ops".to_string()));+ // ProxyCommand is not a supported directive (issue #10454 tracks the+ // missing host resolution, not this), so it must not leak into the+ // resolved tunnel config.+ assert_eq!(abc.proxy_jump, None);+ }++ #[test]+ fn include_accepts_absolute_paths_and_multiple_patterns_on_one_line() {+ let dir = TempDir::new().unwrap();+ let sibling = write_config(dir.path(), "elsewhere/absolute.conf", "Host abs\n HostName 10.0.2.1\n");+ let main = write_config(+ dir.path(),+ "config",+ &format!("Include conf.d/first.conf {}\nHost tail\n HostName 10.0.2.9\n", sibling.display()),+ );+ write_config(dir.path(), "conf.d/first.conf", "Host rel\n HostName 10.0.2.2\n");++ let entries = hosts_from(&main, dir.path());++ assert_eq!(aliases(&entries), vec!["rel", "abs", "tail"]);+ }++ #[test]+ fn missing_include_targets_are_skipped_without_failing() {+ let dir = TempDir::new().unwrap();+ let main = write_config(dir.path(), "config", "Include conf.d/*\nHost only\n HostName 10.0.3.1\n");++ let entries = hosts_from(&main, dir.path());++ assert_eq!(aliases(&entries), vec!["only"]);+ }++ #[test]+ fn nested_includes_are_followed_recursively() {+ let dir = TempDir::new().unwrap();+ let main = write_config(dir.path(), "config", "Include conf.d/50-middle.conf\n");+ write_config(+ dir.path(),+ "conf.d/50-middle.conf",+ "Host middle\n HostName 10.0.4.1\nInclude nested/60-leaf.conf\n",+ );+ write_config(dir.path(), "nested/60-leaf.conf", "Host leaf\n HostName 10.0.4.2\n");++ let entries = hosts_from(&main, dir.path());++ assert_eq!(aliases(&entries), vec!["middle", "leaf"]);+ }++ #[test]+ fn include_cycles_terminate() {+ let dir = TempDir::new().unwrap();+ let main = write_config(dir.path(), "config", "Include a.conf\n");+ write_config(dir.path(), "a.conf", "Host a\n HostName 10.0.5.1\nInclude b.conf\n");+ write_config(dir.path(), "b.conf", "Host b\n HostName 10.0.5.2\nInclude a.conf\n");++ let entries = hosts_from(&main, dir.path());++ // Each file is parsed once; the cycle back into a.conf is ignored.+ assert_eq!(aliases(&entries), vec!["a", "b"]);+ }++ #[test]+ fn directives_after_an_include_bind_to_the_last_host_it_declared() {+ // OpenSSH treats Include as text substitution at that exact position,+ // so a keyword following it belongs to the most recent Host — which+ // may have been declared inside the included file. Getting this wrong+ // would misattribute values, so lock the behavior down.+ let dir = TempDir::new().unwrap();+ let main = write_config(+ dir.path(),+ "config",+ "Host first\n HostName 10.0.6.1\nInclude conf.d/inner.conf\n User shared\n",+ );+ write_config(dir.path(), "conf.d/inner.conf", "Host second\n HostName 10.0.6.2\n");++ let entries = hosts_from(&main, dir.path());++ assert_eq!(aliases(&entries), vec!["first", "second"]);+ assert_eq!(entries[0].user, None);+ assert_eq!(entries[1].user, Some("shared".to_string()));+ }++ #[test]+ fn host_declared_in_an_included_file_keeps_receiving_later_directives() {+ let dir = TempDir::new().unwrap();+ let main = write_config(dir.path(), "config", "Include conf.d/inner.conf\n Port 2200\n");+ write_config(dir.path(), "conf.d/inner.conf", "Host included\n HostName 10.0.7.1\n");++ let entries = hosts_from(&main, dir.path());++ assert_eq!(entries.len(), 1);+ assert_eq!(entries[0].port, Some(2200));+ }++ #[test]+ fn tilde_prefixed_include_patterns_do_not_break_the_loader() {+ // `~` resolution itself is covered by dbx-platform's path_utils tests;+ // here we only assert the loader tolerates a home-relative pattern+ // (e.g. `~/.ssh/conf.d/*`) that matches nothing on this machine.+ let dir = TempDir::new().unwrap();+ let main = write_config(+ dir.path(),+ "config",+ "Include ~/.ssh/dbx-no-such-dir-xyz/*\nHost kept\n HostName 10.0.8.1\n",+ );++ let entries = hosts_from(&main, dir.path());++ assert_eq!(aliases(&entries), vec!["kept"]);+ }+}