Bump version to 1.0.0-rc17

Cargo.lock

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

Cargo.toml

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

src/bin/dosh-client.rs

@@ -260,7 +260,7 @@ async fn main() -> Result<()> {
         return run_file_cat_command(&args);
     }
     if args.server.as_deref() == Some("update") {
-        return run_update(&config, update_check_requested(&args.command)?);
+        return run_update(&config, parse_update_options(&args.command)?);
     }
     if args.server.as_deref() == Some("setup") {
         return run_setup_command(&config, &args).await;
@@ -2842,14 +2842,85 @@ fn run_remote_script(
     Ok(())
 }
 
-fn update_check_requested(command: &[String]) -> Result<bool> {
-    match command {
-        [] => Ok(false),
-        [flag] if flag == "--check" || flag == "-n" => Ok(true),
-        _ => Err(anyhow!("usage: dosh update [--check]")),
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum UpdateRole {
+    Auto,
+    Client,
+    Server,
+    Both,
+}
+
+impl UpdateRole {
+    fn installer_arg(self) -> &'static str {
+        match self {
+            UpdateRole::Auto => {
+                if local_server_install_detected() {
+                    "both"
+                } else {
+                    "client"
+                }
+            }
+            UpdateRole::Client => "client",
+            UpdateRole::Server => "server",
+            UpdateRole::Both => "both",
+        }
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct UpdateOptions {
+    check_only: bool,
+    role: UpdateRole,
+}
+
+fn parse_update_options(command: &[String]) -> Result<UpdateOptions> {
+    let mut options = UpdateOptions {
+        check_only: false,
+        role: UpdateRole::Auto,
+    };
+    for arg in command {
+        match arg.as_str() {
+            "--check" | "-n" => options.check_only = true,
+            "--client" => options.role = update_role_flag(options.role, UpdateRole::Client)?,
+            "--server" => options.role = update_role_flag(options.role, UpdateRole::Server)?,
+            "--both" => options.role = update_role_flag(options.role, UpdateRole::Both)?,
+            _ => {
+                return Err(anyhow!(
+                    "usage: dosh update [--check] [--client|--server|--both]"
+                ));
+            }
+        }
+    }
+    Ok(options)
+}
+
+fn update_role_flag(current: UpdateRole, requested: UpdateRole) -> Result<UpdateRole> {
+    if current != UpdateRole::Auto && current != requested {
+        return Err(anyhow!("choose only one of --client, --server, or --both"));
+    }
+    Ok(requested)
+}
+
+fn local_server_install_detected() -> bool {
+    if cfg!(windows) {
+        return false;
+    }
+    let service = dirs::home_dir()
+        .map(|home| home.join(".config/systemd/user/dosh-server.service"))
+        .filter(|path| path.exists())
+        .is_some();
+    if service {
+        return true;
+    }
+    let Ok(exe) = std::env::current_exe() else {
+        return false;
+    };
+    let Some(bin_dir) = exe.parent() else {
+        return false;
+    };
+    bin_dir.join("dosh-server").exists() || bin_dir.join("dosh-server.exe").exists()
+}
+
 fn release_artifact_name() -> &'static str {
     match (std::env::consts::OS, std::env::consts::ARCH) {
         ("macos", "aarch64") => "dosh-macos-aarch64.tar.gz",
@@ -2968,7 +3039,7 @@ fn url_reachable(url: &str) -> Result<bool> {
     Ok(status.success())
 }
 
-fn run_update(config: &dosh::config::ClientConfig, check_only: bool) -> Result<()> {
+fn run_update(config: &dosh::config::ClientConfig, options: UpdateOptions) -> Result<()> {
     let repo = config
         .update_repo
         .clone()
@@ -2976,12 +3047,14 @@ fn run_update(config: &dosh::config::ClientConfig, check_only: bool) -> Result<(
     let raw_base = raw_base_from_repo(&repo);
     let installer = format!("{raw_base}/raw/branch/main/install.sh");
     let artifact = release_artifact_name();
-    if check_only {
+    let installer_role = options.role.installer_arg();
+    if options.check_only {
         let local_version = env!("CARGO_PKG_VERSION");
         let latest_tag = latest_release_tag(&repo)?;
         println!("dosh {local_version}");
         println!("repo: {repo}");
         println!("installer: {installer}");
+        println!("role: {installer_role}");
         match latest_tag.as_deref() {
             Some(tag) => {
                 let latest_version = release_version_from_tag(tag);
@@ -3018,12 +3091,13 @@ fn run_update(config: &dosh::config::ClientConfig, check_only: bool) -> Result<(
         .join("source");
     let use_prebuilt = std::env::var("DOSH_USE_PREBUILT").unwrap_or_else(|_| "1".to_string());
     let mut script = format!(
-        "curl -fsSL {} | DOSH_REPO={} DOSH_PORT={} DOSH_UPDATE_CACHE={} DOSH_UPDATE_QUIET=1 DOSH_USE_PREBUILT={} sh -s -- client",
+        "curl -fsSL {} | DOSH_REPO={} DOSH_PORT={} DOSH_UPDATE_CACHE={} DOSH_UPDATE_QUIET=1 DOSH_USE_PREBUILT={} sh -s -- {}",
         shell_word(&installer),
         shell_word(&repo),
         config.update_port.unwrap_or(config.dosh_port),
         shell_word(&update_cache.display().to_string()),
-        shell_word(&use_prebuilt)
+        shell_word(&use_prebuilt),
+        shell_word(installer_role)
     );
     if config.server != "user@example.com" {
         script.push_str(&format!(" --server {}", shell_word(&config.server)));
@@ -7565,11 +7639,12 @@ mod tests {
         FRAME_GAP_RESYNC_AFTER_MS, FrameBuffer, LocalForward, MAX_PENDING_USER_INPUT_BYTES,
         POST_SUBMIT_ALL_INPUT_HOLD, PendingStreamOpen, PredictMode, Predictor,
         RESTART_STATUS_SCRIPT, RemoteForward, STARTUP_INPUT_HOLD, SshConfig, StartupGateMode,
-        StatusAction, auth_allows, cache_key, cache_server_prefix, cleanup_stream_state,
-        clear_cached_credentials, ensure_tui_safe_status_overlay, input_contains_focus_in,
-        input_matches_escape, is_local_status_target, is_resume_response_for_client,
-        latest_release_download_url, load_first_native_identity_with_prompt, parse_dynamic_forward,
-        parse_escape_key, parse_local_forward, parse_remote_forward, parse_ssh_config,
+        StatusAction, UpdateOptions, UpdateRole, auth_allows, cache_key, cache_server_prefix,
+        cleanup_stream_state, clear_cached_credentials, ensure_tui_safe_status_overlay,
+        input_contains_focus_in, input_matches_escape, is_local_status_target,
+        is_resume_response_for_client, latest_release_download_url,
+        load_first_native_identity_with_prompt, parse_dynamic_forward, parse_escape_key,
+        parse_local_forward, parse_remote_forward, parse_ssh_config, parse_update_options,
         post_submit_hold_duration, queue_pending_user_input, raw_contains_host_table,
         recv_response_until, refresh_live_addr, release_tag_download_url,
         release_tag_from_effective_url, release_version_from_tag, render_status_clear,
@@ -7580,8 +7655,7 @@ mod tests {
         should_repaint_idle_alternate_screen, split_after_command_submit, ssh_destination_host,
         ssh_username, ssh_with_user, startup_command, status_ssh_target, strip_stale_mouse_reports,
         strip_terminal_focus_reports, terminal_private_mode_transition, toml_bare_key_or_quoted,
-        update_check_requested, update_version_status, upsert_managed_block, valid_forward_host,
-        vscode_safe_alias,
+        update_version_status, upsert_managed_block, valid_forward_host, vscode_safe_alias,
     };
     use dosh::config::{ClientConfig, CommandExtension, HostConfig};
     use dosh::native::EnvVar;
@@ -8695,12 +8769,37 @@ mod tests {
     }
 
     #[test]
-    fn update_check_accepts_only_check_flag() {
-        assert!(!update_check_requested(&[]).unwrap());
-        assert!(update_check_requested(&["--check".to_string()]).unwrap());
-        assert!(update_check_requested(&["-n".to_string()]).unwrap());
-        assert!(update_check_requested(&["--wat".to_string()]).is_err());
-        assert!(update_check_requested(&["--check".to_string(), "extra".to_string()]).is_err());
+    fn update_options_accept_check_and_role_flags() {
+        assert_eq!(
+            parse_update_options(&[]).unwrap(),
+            UpdateOptions {
+                check_only: false,
+                role: UpdateRole::Auto,
+            }
+        );
+        assert_eq!(
+            parse_update_options(&["--check".to_string()]).unwrap(),
+            UpdateOptions {
+                check_only: true,
+                role: UpdateRole::Auto,
+            }
+        );
+        assert_eq!(
+            parse_update_options(&["-n".to_string(), "--server".to_string()]).unwrap(),
+            UpdateOptions {
+                check_only: true,
+                role: UpdateRole::Server,
+            }
+        );
+        assert_eq!(
+            parse_update_options(&["--both".to_string()]).unwrap(),
+            UpdateOptions {
+                check_only: false,
+                role: UpdateRole::Both,
+            }
+        );
+        assert!(parse_update_options(&["--wat".to_string()]).is_err());
+        assert!(parse_update_options(&["--client".to_string(), "--server".to_string()]).is_err());
     }
 
     #[test]

src/bin/dosh-server.rs

@@ -53,6 +53,7 @@ const STREAM_RETIRED_TOMBSTONES: usize = 16 * 1024;
 /// have accumulated since the last mirror. Keeps the atomic write off the
 /// per-packet hot path while bounding how much fresh output a crash can lose.
 const SCREEN_PERSIST_BYTES: usize = 4096;
+const SCREEN_PERSIST_MAX_AGE: Duration = Duration::from_millis(250);
 const IMPLICIT_EMPTY_SESSION_GRACE_SECS: u64 = 300;
 
 /// Sentinel `target_host` sent to the client on a server-initiated `StreamOpen`
@@ -251,7 +252,7 @@ async fn serve(config_path: Option<std::path::PathBuf>) -> Result<()> {
     if config.persist_sessions {
         let flush_state = Arc::clone(&state);
         tokio::spawn(async move {
-            let mut interval = tokio::time::interval(Duration::from_secs(2));
+            let mut interval = tokio::time::interval(SCREEN_PERSIST_MAX_AGE);
             loop {
                 interval.tick().await;
                 flush_persistent_screens(&flush_state);
@@ -376,6 +377,10 @@ struct Session {
     /// `output_seq` at the last successful screen mirror, so the periodic flush
     /// skips sessions whose screen has not changed.
     last_persisted_seq: u64,
+    /// Last time this session's screen was considered for a mirror. Combined
+    /// with the byte threshold so low-throughput prompt/TUI updates persist
+    /// quickly without writing on every packet in high-throughput bursts.
+    last_screen_persist_at: Instant,
 }
 
 #[derive(Clone)]
@@ -511,6 +516,7 @@ impl ServerState {
                 persistent,
                 bytes_since_persist: 0,
                 last_persisted_seq: 0,
+                last_screen_persist_at: Instant::now() - SCREEN_PERSIST_MAX_AGE,
             },
         );
         Ok(())
@@ -648,6 +654,7 @@ impl ServerState {
                     persistent: true,
                     bytes_since_persist: 0,
                     last_persisted_seq: output_seq,
+                    last_screen_persist_at: Instant::now(),
                 },
             );
             eprintln!(
@@ -3451,16 +3458,20 @@ async fn broadcast_output(
             session.recent.pop_front();
         }
         // For a persistent session, mirror the screen to disk periodically so a
-        // post-restart reattach repaints. Throttled by accumulated bytes to keep
-        // the (atomic) write off the per-packet hot path. The actual file write
-        // happens after the lock is dropped.
+        // post-restart reattach repaints. Throttled by accumulated bytes or a
+        // short wall-clock age so low-throughput prompt/TUI changes persist
+        // quickly while large bursts still avoid per-packet disk writes. The
+        // actual file write happens after the lock is dropped.
         if session.persistent {
             session.bytes_since_persist = session
                 .bytes_since_persist
                 .saturating_add(output.bytes.len());
-            if session.bytes_since_persist >= SCREEN_PERSIST_BYTES {
+            let now = Instant::now();
+            if session.bytes_since_persist >= SCREEN_PERSIST_BYTES
+                || now.duration_since(session.last_screen_persist_at) >= SCREEN_PERSIST_MAX_AGE
+            {
                 session.bytes_since_persist = 0;
-                session.last_persisted_seq = output_seq;
+                session.last_screen_persist_at = now;
                 let screen = session.parser.screen();
                 persist_screen = Some((
                     output.session.clone(),
@@ -3519,6 +3530,8 @@ async fn broadcast_output(
             persist::save_screen(&sessions_dir, &name, cols, rows, output_seq, &snapshot)
         {
             eprintln!("screen persist for {name} failed: {err:#}");
+        } else {
+            mark_screen_persisted(state, &name, output_seq);
         }
     }
     for (endpoint, packet) in sends {
@@ -3800,8 +3813,8 @@ fn flush_persistent_screens(state: &Arc<Mutex<ServerState>>) {
             if !session.persistent || session.output_seq == session.last_persisted_seq {
                 continue;
             }
-            session.last_persisted_seq = session.output_seq;
             session.bytes_since_persist = 0;
+            session.last_screen_persist_at = Instant::now();
             let screen = session.parser.screen();
             to_write.push((
                 name.clone(),
@@ -3818,10 +3831,19 @@ fn flush_persistent_screens(state: &Arc<Mutex<ServerState>>) {
             persist::save_screen(&sessions_dir, &name, cols, rows, output_seq, &snapshot)
         {
             eprintln!("screen flush for {name} failed: {err:#}");
+        } else {
+            mark_screen_persisted(state, &name, output_seq);
         }
     }
 }
 
+fn mark_screen_persisted(state: &Arc<Mutex<ServerState>>, name: &str, output_seq: u64) {
+    let mut locked = state.lock().expect("server state poisoned");
+    if let Some(session) = locked.sessions.get_mut(name) {
+        session.last_persisted_seq = session.last_persisted_seq.max(output_seq);
+    }
+}
+
 fn cleanup_disconnected_clients(state: &Arc<Mutex<ServerState>>) {
     // Sessions removed here are dropped after the lock is released so their
     // shells are killed (PtyHandle::drop) without holding up the event loop.
@@ -4382,6 +4404,7 @@ mod tests {
                 persistent: false,
                 bytes_since_persist: 0,
                 last_persisted_seq: 0,
+                last_screen_persist_at: Instant::now(),
             },
         );
         state.client_index.insert(client_id, "test".to_string());
@@ -4445,6 +4468,7 @@ mod tests {
                 persistent: false,
                 bytes_since_persist: 0,
                 last_persisted_seq: 0,
+                last_screen_persist_at: Instant::now(),
             },
         );
         state.client_index.insert(client_id, "test".to_string());
@@ -4520,6 +4544,7 @@ mod tests {
                 persistent: false,
                 bytes_since_persist: 0,
                 last_persisted_seq: 0,
+                last_screen_persist_at: Instant::now(),
             },
         );
         state.client_index.insert(client_id, "test".to_string());
@@ -4689,6 +4714,7 @@ mod tests {
                 persistent: false,
                 bytes_since_persist: 0,
                 last_persisted_seq: 0,
+                last_screen_persist_at: Instant::now(),
             },
         );
         // Keep the O(1) conn_id index in sync, matching `insert_client`.
@@ -4785,6 +4811,7 @@ mod tests {
                 persistent: false,
                 bytes_since_persist: 0,
                 last_persisted_seq: 0,
+                last_screen_persist_at: Instant::now(),
             },
         );
         state.client_index.insert(client_id, "test".to_string());