Keep sessions alive through UDP churn

Cargo.lock

@@ -436,7 +436,7 @@ dependencies = [
 
 [[package]]
 name = "dosh"
-version = "1.0.0-rc19"
+version = "1.0.0-rc21"
 dependencies = [
  "anyhow",
  "base64",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "dosh"
-version = "1.0.0-rc19"
+version = "1.0.0-rc21"
 edition = "2024"
 license = "MIT"
 

README.md

@@ -98,6 +98,16 @@ cache_attach_tickets = true
 disconnect_status = true
 ```
 
+Example host entry:
+
+```toml
+[prod]
+ssh = "prod"
+ssh_config = "prod" # OpenSSH alias for IdentityFile, ProxyJump, SendEnv, etc.
+dosh_host = "prod.example.com"
+port = 50000
+```
+
 ## Rust Library
 
 Dosh exposes a Rust transport for encrypted, reconnecting application streams.

src/bin/dosh-client.rs

@@ -36,7 +36,7 @@ use dosh::transport::{
     DoshTransport, SessionEvent, SessionRole, SessionTransportConfig, TransportConfig,
     TransportEvent,
 };
-use dosh::udp::is_transient_udp_send_error;
+use dosh::udp::{is_transient_udp_error, is_transient_udp_send_error};
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
 use std::collections::BTreeMap;
@@ -302,8 +302,7 @@ async fn main() -> Result<()> {
         .get(&requested_server)
         .cloned()
         .unwrap_or_default();
-    let raw_server = host.ssh.clone().unwrap_or_else(|| requested_server.clone());
+    let server = ssh_command_target(&requested_server, &host);
-    let server = ssh_with_user(&raw_server, host.user.as_deref());
     let startup_command = resolved_startup_command(&args.command, &config, &host);
     let local_forwards = parse_local_forwards(&args.local_forward)?;
     let remote_forwards = parse_remote_forwards(&args.remote_forward)?;
@@ -655,8 +654,7 @@ fn run_trust_command(config: &dosh::config::ClientConfig, args: &Args) -> Result
 
     let hosts = load_hosts_config(None).unwrap_or_default();
     let host_config = hosts.hosts.get(host).cloned().unwrap_or_default();
-    let raw_server = host_config.ssh.clone().unwrap_or_else(|| host.to_string());
+    let server = ssh_command_target(host, &host_config);
-    let server = ssh_with_user(&raw_server, host_config.user.as_deref());
     let ssh_port = args.ssh_port.or(host_config.ssh_port).or(config.ssh_port);
     let ssh_auth_command = args
         .ssh_auth_command
@@ -701,8 +699,8 @@ async fn run_setup_command(config: &dosh::config::ClientConfig, args: &Args) ->
     for entry in imported {
         match entry.action {
             ImportAction::Added => println!(
-                "[ok] host config: [{}] ssh={} dosh_host={} port={}",
+                "[ok] host config: [{}] ssh={} ssh_config={} dosh_host={} port={}",
-                entry.alias, entry.ssh, entry.dosh_host, entry.port
+                entry.alias, entry.ssh, entry.ssh_config, entry.dosh_host, entry.port
             ),
             ImportAction::Skipped => println!("[ok] host config: [{}] already exists", entry.alias),
         }
@@ -710,8 +708,7 @@ async fn run_setup_command(config: &dosh::config::ClientConfig, args: &Args) ->
 
     let hosts = load_hosts_config(None).unwrap_or_default();
     let host_config = hosts.hosts.get(&host).cloned().unwrap_or_default();
-    let raw_server = host_config.ssh.clone().unwrap_or_else(|| host.clone());
+    let server = ssh_command_target(&host, &host_config);
-    let server = ssh_with_user(&raw_server, host_config.user.as_deref());
     let ssh_port = args.ssh_port.or(host_config.ssh_port).or(config.ssh_port);
     let ssh_auth_command = args
         .ssh_auth_command
@@ -843,9 +840,15 @@ fn run_restart_command(config: &dosh::config::ClientConfig, args: &Args) -> Resu
 }
 
 fn status_ssh_target(requested: &str, host_config: &dosh::config::HostConfig) -> String {
+    ssh_command_target(requested, host_config)
+}
+
+fn ssh_command_target(requested: &str, host_config: &dosh::config::HostConfig) -> String {
     let raw_server = host_config
-        .ssh
+        .ssh_config
-        .clone()
+        .as_ref()
+        .or(host_config.ssh.as_ref())
+        .cloned()
         .unwrap_or_else(|| requested.to_string());
     ssh_with_user(&raw_server, host_config.user.as_deref())
 }
@@ -882,11 +885,7 @@ async fn run_doctor_for_host(
 ) -> Result<()> {
     let hosts = load_hosts_config(None).unwrap_or_default();
     let host_config = hosts.hosts.get(requested).cloned().unwrap_or_default();
-    let raw_server = host_config
+    let server = ssh_command_target(requested, &host_config);
-        .ssh
-        .clone()
-        .unwrap_or_else(|| requested.to_string());
-    let server = ssh_with_user(&raw_server, host_config.user.as_deref());
     let ssh_port = args.ssh_port.or(host_config.ssh_port).or(config.ssh_port);
     let dosh_port = args
         .dosh_port
@@ -1393,8 +1392,7 @@ async fn run_proxy_stdio_command(config: &dosh::config::ClientConfig, args: &Arg
         .get(&requested_server)
         .cloned()
         .unwrap_or_default();
-    let raw_server = host.ssh.clone().unwrap_or_else(|| requested_server.clone());
+    let server = ssh_command_target(&requested_server, &host);
-    let server = ssh_with_user(&raw_server, host.user.as_deref());
     let ssh_port = args.ssh_port.or(host.ssh_port).or(config.ssh_port);
     let resolved_ssh_config = ssh_config(&server, ssh_port).unwrap_or_default();
     let requested_udp_host = args
@@ -1561,11 +1559,7 @@ fn ensure_vscode_ssh_host(
 ) -> Result<GeneratedVscodeHost> {
     let hosts = load_hosts_config(None).unwrap_or_default();
     let host_config = hosts.hosts.get(requested).cloned().unwrap_or_default();
-    let raw_server = host_config
+    let server = ssh_command_target(requested, &host_config);
-        .ssh
-        .clone()
-        .unwrap_or_else(|| requested.to_string());
-    let server = ssh_with_user(&raw_server, host_config.user.as_deref());
     let ssh_port = args.ssh_port.or(host_config.ssh_port).or(config.ssh_port);
     let ssh_config = ssh_config(&server, ssh_port).unwrap_or_default();
     let target_ssh_port = ssh_config.port.or(ssh_port).unwrap_or(22);
@@ -3247,6 +3241,7 @@ enum ImportAction {
 struct ImportedHost {
     alias: String,
     ssh: String,
+    ssh_config: String,
     dosh_host: String,
     port: u16,
     action: ImportAction,
@@ -3260,8 +3255,8 @@ fn run_import_ssh(config: &dosh::config::ClientConfig, aliases: &[String]) -> Re
     for entry in imported {
         match entry.action {
             ImportAction::Added => eprintln!(
-                "dosh import-ssh: added [{}] ssh={} dosh_host={}",
+                "dosh import-ssh: added [{}] ssh={} ssh_config={} dosh_host={}",
-                entry.alias, entry.ssh, entry.dosh_host
+                entry.alias, entry.ssh, entry.ssh_config, entry.dosh_host
             ),
             ImportAction::Skipped => {
                 eprintln!(
@@ -3303,6 +3298,7 @@ fn import_ssh_aliases(
             imported.push(ImportedHost {
                 alias: alias.clone(),
                 ssh: alias.clone(),
+                ssh_config: alias.clone(),
                 dosh_host: udp_host,
                 port: config.dosh_port,
                 action: ImportAction::Skipped,
@@ -3312,6 +3308,7 @@ fn import_ssh_aliases(
         raw.push('\n');
         raw.push_str(&format!("[{}]\n", toml_bare_key_or_quoted(alias)));
         raw.push_str(&format!("ssh = {}\n", toml_string(alias)));
+        raw.push_str(&format!("ssh_config = {}\n", toml_string(alias)));
         raw.push_str(&format!("dosh_host = {}\n", toml_string(&udp_host)));
         raw.push_str(&format!("port = {}\n", config.dosh_port));
         if let Some(user) = &ssh_config.user {
@@ -3326,6 +3323,7 @@ fn import_ssh_aliases(
         imported.push(ImportedHost {
             alias: alias.clone(),
             ssh: alias.clone(),
+            ssh_config: alias.clone(),
             dosh_host: udp_host,
             port: config.dosh_port,
             action: ImportAction::Added,
@@ -4442,9 +4440,14 @@ where
             return Err(anyhow!("timed out waiting for server response"));
         }
         let remaining = wait - elapsed;
-        let (n, _) = tokio::time::timeout(remaining, socket.recv_from(&mut buf))
+        let (n, _) = match tokio::time::timeout(remaining, socket.recv_from(&mut buf))
             .await
-            .context("timed out waiting for server response")??;
+            .context("timed out waiting for server response")?
+        {
+            Ok(value) => value,
+            Err(err) if is_transient_udp_error(&err) => continue,
+            Err(err) => return Err(err.into()),
+        };
         let Ok(packet) = protocol::decode(&buf[..n]) else {
             continue;
         };
@@ -4834,7 +4837,11 @@ async fn run_terminal(
                 }
             }
             recv = socket.recv_from(&mut recv_buf) => {
-                let (n, _) = recv?;
+                let (n, _) = match recv {
+                    Ok(value) => value,
+                    Err(err) if is_transient_udp_error(&err) => continue,
+                    Err(err) => return Err(err.into()),
+                };
                 let Ok(packet) = protocol::decode(&recv_buf[..n]) else {
                     continue;
                 };
@@ -7772,11 +7779,11 @@ mod tests {
         retransmit_stream_opens, rewrite_forward_command, selected_predict_mode, selected_udp_host,
         server_version_mismatch, should_flush_terminal_input_after_contact,
         should_hold_during_startup_gate, should_hold_post_submit_input,
-        should_repaint_idle_alternate_screen, split_after_command_submit, ssh_destination_host,
+        should_repaint_idle_alternate_screen, split_after_command_submit, ssh_command_target,
-        ssh_username, ssh_with_user, startup_command, status_ssh_target, strip_stale_mouse_reports,
+        ssh_destination_host, ssh_username, ssh_with_user, startup_command, status_ssh_target,
-        strip_terminal_focus_reports, terminal_private_mode_transition, toml_bare_key_or_quoted,
+        strip_stale_mouse_reports, strip_terminal_focus_reports, terminal_private_mode_transition,
-        unix_update_script, update_installer_url, update_version_status, upsert_managed_block,
+        toml_bare_key_or_quoted, unix_update_script, update_installer_url, update_version_status,
-        valid_forward_host, vscode_safe_alias, windows_update_script,
+        upsert_managed_block, valid_forward_host, vscode_safe_alias, windows_update_script,
     };
     use dosh::config::{ClientConfig, CommandExtension, HostConfig};
     use dosh::native::EnvVar;
@@ -9017,6 +9024,19 @@ mod tests {
         );
     }
 
+    #[test]
+    fn ssh_command_target_prefers_explicit_ssh_config_alias() {
+        let host = HostConfig {
+            ssh: Some("server.example.com".to_string()),
+            ssh_config: Some("work-alias".to_string()),
+            user: Some("alice".to_string()),
+            ..HostConfig::default()
+        };
+
+        assert_eq!(ssh_command_target("work", &host), "alice@work-alias");
+        assert_eq!(status_ssh_target("work", &host), "alice@work-alias");
+    }
+
     #[test]
     fn status_detects_local_targets() {
         assert!(is_local_status_target("localhost"));

src/bin/dosh-server.rs

@@ -28,7 +28,7 @@ use dosh::protocol::{
     TicketAttachBody, TicketAttachEnvelope, TicketAttachOkEnvelope,
 };
 use dosh::pty::{PtyHandle, PtyOutput, adopt_pty_from_fd, spawn_pty_session};
-use dosh::udp::is_transient_udp_send_error;
+use dosh::udp::{is_transient_udp_error, is_transient_udp_send_error};
 use sha2::{Digest, Sha256};
 use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
 use std::fs;
@@ -262,7 +262,11 @@ async fn serve(config_path: Option<std::path::PathBuf>) -> Result<()> {
 
     let mut buf = vec![0u8; 65535];
     loop {
-        let (n, peer) = socket.recv_from(&mut buf).await?;
+        let (n, peer) = match socket.recv_from(&mut buf).await {
+            Ok(value) => value,
+            Err(err) if is_transient_udp_error(&err) => continue,
+            Err(err) => return Err(err.into()),
+        };
         if let Err(err) = handle_packet(&state, &socket, peer, &buf[..n]).await {
             eprintln!("packet from {peer}: {err:#}");
         }

src/config.rs

@@ -150,6 +150,12 @@ pub struct ClientConfig {
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct HostConfig {
     pub ssh: Option<String>,
+    /// Optional OpenSSH config host name to use for SSH-backed bootstrap,
+    /// trust/setup/doctor checks, and native-auth identity selection. This lets
+    /// a Dosh host keep a separate UDP endpoint while still inheriting
+    /// alias-scoped OpenSSH settings like IdentityFile, ProxyJump, and SendEnv.
+    #[serde(default)]
+    pub ssh_config: Option<String>,
     pub user: Option<String>,
     pub dosh_host: Option<String>,
     pub port: Option<u16>,

src/persist.rs

@@ -23,12 +23,14 @@ use std::io::{Read, Write};
 use std::os::fd::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
 use std::os::unix::net::{UnixListener, UnixStream};
 use std::path::{Path, PathBuf};
+use std::sync::Mutex;
 use std::time::Duration;
 
 /// One-byte commands a server sends to a holder over its control socket after
 /// the holder has handed back the master fd.
 const HOLDER_CMD_SHUTDOWN: u8 = b'X';
 const HOLDER_STARTUP_TIMEOUT: Duration = Duration::from_millis(750);
+static SCREEN_WRITE_LOCK: Mutex<()> = Mutex::new(());
 
 /// Magic written into a holder's `meta` file, bumped if the on-disk layout
 /// changes so a stale holder from an incompatible build is ignored.
@@ -140,13 +142,28 @@ pub fn save_screen(
         // No holder runtime for this session (non-persistent): nothing to do.
         return Ok(());
     }
+    let _guard = SCREEN_WRITE_LOCK
+        .lock()
+        .map_err(|_| anyhow!("screen persistence lock poisoned"))?;
+    let path = screen_path(&dir);
+    if existing_screen_output_seq(&path).is_some_and(|existing| existing >= output_seq) {
+        return Ok(());
+    }
     let mut buf = Vec::with_capacity(snapshot.len() + 32);
     buf.extend_from_slice(&cols.to_be_bytes());
     buf.extend_from_slice(&rows.to_be_bytes());
     buf.extend_from_slice(&output_seq.to_be_bytes());
     buf.extend_from_slice(&(snapshot.len() as u32).to_be_bytes());
     buf.extend_from_slice(snapshot);
-    atomic_write(&screen_path(&dir), &buf)
+    atomic_write(&path, &buf)
+}
+
+fn existing_screen_output_seq(path: &Path) -> Option<u64> {
+    let data = std::fs::read(path).ok()?;
+    if data.len() < 12 {
+        return None;
+    }
+    Some(u64::from_be_bytes(data[4..12].try_into().ok()?))
 }
 
 /// A restored screen for a re-adopted session.
@@ -619,6 +636,20 @@ mod tests {
         assert_eq!(loaded.snapshot, snap);
     }
 
+    #[test]
+    fn save_screen_never_overwrites_newer_snapshot_with_older_seq() {
+        let tmp = tempfile::tempdir().unwrap();
+        let sessions_dir = tmp.path();
+        ensure_runtime_dir(sessions_dir, "work").unwrap();
+
+        save_screen(sessions_dir, "work", 80, 24, 10, b"new-screen").unwrap();
+        save_screen(sessions_dir, "work", 80, 24, 9, b"old-screen").unwrap();
+
+        let loaded = load_screen(sessions_dir, "work").expect("screen restored");
+        assert_eq!(loaded.output_seq, 10);
+        assert_eq!(loaded.snapshot, b"new-screen");
+    }
+
     #[test]
     fn load_screen_absent_is_none() {
         let tmp = tempfile::tempdir().unwrap();

src/udp.rs

@@ -1,6 +1,6 @@
 //! UDP error classification shared by Dosh clients, servers, and embedders.
 
-pub fn is_transient_udp_send_error(err: &std::io::Error) -> bool {
+pub fn is_transient_udp_error(err: &std::io::Error) -> bool {
     matches!(
         err.kind(),
         std::io::ErrorKind::Interrupted
@@ -9,6 +9,10 @@ pub fn is_transient_udp_send_error(err: &std::io::Error) -> bool {
     ) || err.raw_os_error().is_some_and(is_transient_udp_os_error)
 }
 
+pub fn is_transient_udp_send_error(err: &std::io::Error) -> bool {
+    is_transient_udp_error(err)
+}
+
 #[cfg(unix)]
 fn is_transient_udp_os_error(code: i32) -> bool {
     matches!(
@@ -48,20 +52,22 @@ fn is_transient_udp_os_error(_code: i32) -> bool {
 
 #[cfg(test)]
 mod tests {
-    use super::is_transient_udp_send_error;
+    use super::{is_transient_udp_error, is_transient_udp_send_error};
 
     #[test]
-    fn classifies_portable_transient_send_errors() {
+    fn classifies_portable_transient_udp_errors() {
         for kind in [
             std::io::ErrorKind::Interrupted,
             std::io::ErrorKind::TimedOut,
             std::io::ErrorKind::WouldBlock,
         ] {
-            assert!(is_transient_udp_send_error(&std::io::Error::from(kind)));
+            let err = std::io::Error::from(kind);
+            assert!(is_transient_udp_error(&err));
+            assert!(is_transient_udp_send_error(&err));
         }
-        assert!(!is_transient_udp_send_error(&std::io::Error::from(
+        let fatal = std::io::Error::from(std::io::ErrorKind::PermissionDenied);
-            std::io::ErrorKind::PermissionDenied,
+        assert!(!is_transient_udp_error(&fatal));
-        )));
+        assert!(!is_transient_udp_send_error(&fatal));
     }
 
     #[cfg(unix)]
@@ -78,9 +84,9 @@ mod tests {
             libc::ENETUNREACH,
             libc::ETIMEDOUT,
         ] {
-            assert!(is_transient_udp_send_error(
+            let err = std::io::Error::from_raw_os_error(code);
-                &std::io::Error::from_raw_os_error(code)
+            assert!(is_transient_udp_error(&err));
-            ));
+            assert!(is_transient_udp_send_error(&err));
         }
     }
 
@@ -90,9 +96,9 @@ mod tests {
         for code in [
             10049, 10050, 10051, 10052, 10054, 10060, 10061, 10064, 10065,
         ] {
-            assert!(is_transient_udp_send_error(
+            let err = std::io::Error::from_raw_os_error(code);
-                &std::io::Error::from_raw_os_error(code)
+            assert!(is_transient_udp_error(&err));
-            ));
+            assert!(is_transient_udp_send_error(&err));
         }
     }
 }