feat: add SSH config aliases and PostgreSQL extensions

This commit is contained in:
zergmk2 authored and GitHub committed 2026-07-05 20:29:49 +08:00
1 parent 8b035d0989
commit f800d80f90
35 files changed
+1191 -33

No files matched your search

+52 -2
View File
@@ -26,8 +26,8 @@ use crate::sql::starts_with_executable_sql_keyword;
use crate::types::{
ColumnInfo, CompletionAssistantCandidate, CompletionAssistantCandidateKind, CompletionAssistantMatchMode,
CompletionAssistantObjectKind, CompletionAssistantRequest, CompletionAssistantResponse, DatabaseInfo,
ForeignKeyInfo, FunctionInfo, IndexInfo, ObjectInfo, ObjectStatistics, OwnerInfo, QueryResult, RuleInfo,
SchemaInfo, SequenceInfo, TableInfo, TriggerInfo,
ExtensionInfo, ForeignKeyInfo, FunctionInfo, IndexInfo, ObjectInfo, ObjectStatistics, OwnerInfo, QueryResult,
RuleInfo, SchemaInfo, SequenceInfo, TableInfo, TriggerInfo,
};
fn pg_temporal_to_json_value(row: &Row, idx: usize) -> Option<serde_json::Value> {
@@ -2845,6 +2845,56 @@ pub async fn list_rules(pool: &Pool, schema: &str) -> Result<Vec<RuleInfo>, Stri
.collect())
}
pub async fn list_extensions(pool: &Pool, schema: &str) -> Result<Vec<ExtensionInfo>, String> {
let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
let stmt = client
.prepare_cached(
"SELECT e.extname, COALESCE(e.extversion, '') AS extversion, d.description, n.nspname \
FROM pg_catalog.pg_extension e \
JOIN pg_catalog.pg_namespace n ON n.oid = e.extnamespace \
LEFT JOIN pg_catalog.pg_description d ON d.objoid = e.oid AND d.classoid = 'pg_extension'::regclass \
WHERE n.nspname = $1 \
ORDER BY e.extname",
)
.await
.map_err(|e| e.to_string())?;
let rows = client.query(&stmt, &[&schema]).await.map_err(|e| e.to_string())?;
Ok(rows
.iter()
.map(|row| ExtensionInfo {
name: row.get::<_, String>(0),
version: row.get::<_, String>(1),
comment: row.try_get::<_, Option<String>>(2).ok().flatten().filter(|s| !s.is_empty()),
schema: Some(schema.to_string()),
})
.collect())
}
pub async fn list_available_extensions(pool: &Pool) -> Result<Vec<ExtensionInfo>, String> {
let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
let stmt = client
.prepare_cached(
"SELECT name, default_version, comment \
FROM pg_catalog.pg_available_extensions \
WHERE installed_version IS NULL \
ORDER BY name",
)
.await
.map_err(|e| e.to_string())?;
let rows = client.query(&stmt, &[]).await.map_err(|e| e.to_string())?;
Ok(rows
.iter()
.map(|row| ExtensionInfo {
name: row.get::<_, String>(0),
version: row.get::<_, String>(1),
comment: row.try_get::<_, Option<String>>(2).ok().flatten().filter(|s| !s.is_empty()),
schema: None,
})
.collect())
}
pub async fn list_owners(pool: &Pool, schema: &str) -> Result<Vec<OwnerInfo>, String> {
let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
let stmt = client.prepare_cached(POSTGRES_OWNERS_SQL).await.map_err(|e| e.to_string())?;
+28 -4
View File
@@ -1,6 +1,8 @@
use std::borrow::Cow;
use std::collections::HashMap;
use std::fs;
use crate::path_utils::expand_tilde;
use std::sync::Arc;
use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
@@ -66,6 +68,7 @@ async fn connect_and_authenticate(
ssh_key_passphrase: &str,
use_ssh_agent: bool,
ssh_agent_sock_path: &str,
auth_method: &str,
connect_timeout_secs: u64,
) -> Result<Handle<SshClient>, String> {
let config = Arc::new(ssh_client_config());
@@ -88,8 +91,19 @@ async fn connect_and_authenticate(
return Ok(session);
}
// When auth_method is "none" and the probe was rejected, fail early
// instead of falling back to other credential methods.
if auth_method == "none" {
return Err("SSH authentication failed: server rejected the connection without credentials".to_string());
}
// "none" was rejected — fall back to the configured credential method.
if !ssh_key_path.is_empty() {
// When auth_method is set, only try the matching method.
let try_key = auth_method.is_empty() && !ssh_key_path.is_empty() || auth_method == "key";
let try_password = auth_method.is_empty() && !ssh_password.is_empty() || auth_method == "password";
let try_agent = auth_method.is_empty() && use_ssh_agent || auth_method == "agent";
if try_key {
// Validate SSH key file path
validate_file_path(ssh_key_path, |_| false)?;
@@ -112,7 +126,7 @@ async fn connect_and_authenticate(
if !auth_res.success() {
return Err("SSH public key authentication failed".to_string());
}
} else if !ssh_password.is_empty() {
} else if try_password {
let auth_res = tokio::time::timeout(connect_timeout, session.authenticate_password(ssh_user, ssh_password))
.await
.map_err(|_| format!("SSH password auth timed out ({connect_timeout_secs}s)"))?
@@ -120,7 +134,7 @@ async fn connect_and_authenticate(
if !auth_res.success() {
return Err("SSH password authentication failed".to_string());
}
} else if use_ssh_agent {
} else if try_agent {
match try_authenticate_with_agent(&mut session, ssh_user, ssh_agent_sock_path, &connect_timeout).await {
Ok(()) => {}
Err(agent_err) => return Err(agent_err),
@@ -215,7 +229,8 @@ async fn try_authenticate_with_agent(
}
fn load_ssh_private_key(path: &str, passphrase: Option<&str>) -> Result<PrivateKey, String> {
let secret = fs::read_to_string(path).map_err(|e| e.to_string())?;
let expanded = expand_tilde(path);
let secret = fs::read_to_string(&expanded).map_err(|e| e.to_string())?;
match decode_secret_key(&secret, passphrase) {
Ok(key) => Ok(key),
Err(err) if is_ssh_key_character_encoding_error(&err.to_string()) => {
@@ -460,6 +475,7 @@ async fn tunnel_reconnect_loop(
ssh_key_passphrase: String,
use_ssh_agent: bool,
ssh_agent_sock_path: String,
auth_method: String,
connect_timeout_secs: u64,
listener: TcpListener,
remote_host: String,
@@ -495,6 +511,7 @@ async fn tunnel_reconnect_loop(
&ssh_key_passphrase,
use_ssh_agent,
&ssh_agent_sock_path,
&auth_method,
connect_timeout_secs,
)
.await
@@ -565,6 +582,7 @@ impl TunnelManager {
ssh_key_passphrase: &str,
use_ssh_agent: bool,
ssh_agent_sock_path: &str,
auth_method: &str,
connect_timeout_secs: u64,
remote_host: &str,
remote_port: u16,
@@ -588,6 +606,7 @@ impl TunnelManager {
ssh_key_passphrase,
use_ssh_agent,
ssh_agent_sock_path,
auth_method,
connect_timeout_secs,
remote_host,
remote_port,
@@ -658,6 +677,7 @@ impl TunnelManager {
&hop.key_passphrase,
hop.use_ssh_agent,
&hop.ssh_agent_sock_path,
&hop.auth_method,
effective_hop_timeout(hop),
&target_host,
target_port,
@@ -718,6 +738,7 @@ async fn spawn_tunnel(
ssh_key_passphrase: &str,
use_ssh_agent: bool,
ssh_agent_sock_path: &str,
auth_method: &str,
connect_timeout_secs: u64,
remote_host: &str,
remote_port: u16,
@@ -739,6 +760,7 @@ async fn spawn_tunnel(
ssh_key_passphrase,
use_ssh_agent,
ssh_agent_sock_path,
auth_method,
connect_timeout_secs,
)
.await?;
@@ -753,6 +775,7 @@ async fn spawn_tunnel(
ssh_key_passphrase.to_string(),
use_ssh_agent,
ssh_agent_sock_path.to_string(),
auth_method.to_string(),
connect_timeout_secs,
listener,
remote_host.to_string(),
@@ -851,6 +874,7 @@ mod tests {
expose_lan: false,
use_ssh_agent: false,
ssh_agent_sock_path: String::new(),
auth_method: "password".to_string(),
}
}
+118 -10
View File
@@ -16,6 +16,25 @@ impl LayerEndpoint {
}
}
/// Resolves any `~/.ssh/config` aliases on SSH layers before endpoints are
/// computed. Both `.endpoint()` read sites below (the current layer's own
/// connect target, and an earlier layer's forward target when this layer is
/// the *next* one in the chain) must see the resolved host/port rather than
/// a literal alias string, so resolution happens once up front instead of
/// only at the `start_tunnel` call site.
fn resolve_ssh_layers(
layers: &[TransportLayerConfig],
resolve: impl Fn(&crate::models::connection::SshTunnelConfig) -> crate::models::connection::SshTunnelConfig,
) -> Vec<TransportLayerConfig> {
layers
.iter()
.map(|layer| match layer {
TransportLayerConfig::Ssh(ssh) => TransportLayerConfig::Ssh(resolve(ssh)),
other => other.clone(),
})
.collect()
}
/// Starts an ordered transport layer chain and returns the final local port.
///
/// Each layer listens on a local port. The next layer connects to that local
@@ -34,6 +53,9 @@ pub async fn start_transport_layers(
}
validate_transport_layers(layers)?;
let layers = resolve_ssh_layers(layers, crate::ssh_config::resolve_ssh_tunnel_config);
let layers = layers.as_slice();
let mut next_connect_endpoint: Option<LayerEndpoint> = None;
let mut final_local_port = 0;
@@ -52,21 +74,22 @@ pub async fn start_transport_layers(
};
let local_port = match layer {
TransportLayerConfig::Ssh(ssh) => ssh_tunnels
TransportLayerConfig::Ssh(resolved) => ssh_tunnels
.start_tunnel(
&layer_id,
&connect_endpoint.host,
connect_endpoint.port,
&ssh.user,
&ssh.password,
&ssh.key_path,
&ssh.key_passphrase,
ssh.use_ssh_agent,
&ssh.ssh_agent_sock_path,
effective_ssh_connect_timeout_secs(ssh.connect_timeout_secs),
&resolved.user,
&resolved.password,
&resolved.key_path,
&resolved.key_passphrase,
resolved.use_ssh_agent,
&resolved.ssh_agent_sock_path,
&resolved.auth_method,
effective_ssh_connect_timeout_secs(resolved.connect_timeout_secs),
&target_endpoint.host,
target_endpoint.port,
is_last && ssh.expose_lan,
is_last && resolved.expose_lan,
)
.await
.map_err(|err| format!("SSH layer {} failed: {err}", index + 1))?,
@@ -164,6 +187,22 @@ fn plan_transport_layers(
remote_port: u16,
local_ports: &[u16],
) -> Vec<PlannedTransportLayer> {
plan_transport_layers_with_resolver(layers, remote_host, remote_port, local_ports, |ssh| ssh.clone())
}
/// Same as `plan_transport_layers`, but takes an explicit SSH-alias resolver
/// so tests can exercise `~/.ssh/config` resolution without touching the real
/// filesystem (mirrors `start_transport_layers`'s use of `resolve_ssh_layers`).
#[cfg(test)]
fn plan_transport_layers_with_resolver(
layers: &[TransportLayerConfig],
remote_host: &str,
remote_port: u16,
local_ports: &[u16],
resolve: impl Fn(&crate::models::connection::SshTunnelConfig) -> crate::models::connection::SshTunnelConfig,
) -> Vec<PlannedTransportLayer> {
let layers = resolve_ssh_layers(layers, resolve);
let layers = layers.as_slice();
let mut planned = Vec::new();
let mut next_connect_endpoint: Option<(String, u16)> = None;
for (index, layer) in layers.iter().enumerate() {
@@ -198,7 +237,10 @@ fn plan_transport_layers(
#[cfg(test)]
mod tests {
use super::{plan_transport_layers, validate_transport_layers, PlannedLayerType, PlannedTransportLayer};
use super::{
plan_transport_layers, plan_transport_layers_with_resolver, validate_transport_layers, PlannedLayerType,
PlannedTransportLayer,
};
use crate::models::connection::{
HttpTunnelConfig, ProxyTunnelConfig, ProxyType, SshTunnelConfig, TransportLayerConfig,
};
@@ -218,6 +260,7 @@ mod tests {
expose_lan: false,
use_ssh_agent: false,
ssh_agent_sock_path: String::new(),
auth_method: "password".to_string(),
})
}
@@ -295,6 +338,71 @@ mod tests {
assert!(err.contains("HTTP tunnel must be the first transport layer"));
}
#[test]
fn single_ssh_hop_with_config_alias_connects_to_resolved_host_and_port() {
// RF-001 regression: a single SSH layer whose `host` is a
// `~/.ssh/config` alias must dial the resolved HostName/Port, not
// the literal alias string.
let layers = vec![ssh_layer("ssh-a", "myserver", 22)];
let planned = plan_transport_layers_with_resolver(&layers, "db.internal", 5432, &[], |ssh| {
assert_eq!(ssh.host, "myserver");
let mut resolved = ssh.clone();
resolved.host = "10.0.0.5".to_string();
resolved.port = 2222;
resolved
});
assert_eq!(
planned,
vec![PlannedTransportLayer {
layer_type: PlannedLayerType::Ssh,
connect_host: "10.0.0.5".to_string(),
connect_port: 2222,
remote_host: "db.internal".to_string(),
remote_port: 5432,
}]
);
}
#[test]
fn earlier_hop_forwards_to_resolved_alias_of_next_ssh_hop() {
// RF-002 regression: when hop N+1 is an SSH layer addressed by a
// config alias, hop N's forward target must be the resolved
// HostName/Port, not the literal alias (which the remote host at
// hop N cannot resolve).
let layers = vec![ssh_layer("ssh-a", "bastion-a", 22), ssh_layer("ssh-b", "myserver", 22)];
let planned = plan_transport_layers_with_resolver(&layers, "db.internal", 5432, &[41001], |ssh| {
let mut resolved = ssh.clone();
if ssh.host == "myserver" {
resolved.host = "10.0.0.5".to_string();
resolved.port = 2222;
}
resolved
});
assert_eq!(
planned,
vec![
PlannedTransportLayer {
layer_type: PlannedLayerType::Ssh,
connect_host: "bastion-a".to_string(),
connect_port: 22,
remote_host: "10.0.0.5".to_string(),
remote_port: 2222,
},
PlannedTransportLayer {
layer_type: PlannedLayerType::Ssh,
connect_host: "127.0.0.1".to_string(),
connect_port: 41001,
remote_host: "db.internal".to_string(),
remote_port: 5432,
},
]
);
}
#[test]
fn http_tunnel_first_layer_targets_next_layer() {
let layers = vec![