diff --git a/README.md b/README.md index 8cb8e27..a81568c 100644 --- a/README.md +++ b/README.md @@ -114,6 +114,7 @@ Finish any running work first, since shutdown ends its sessions, then launch | `psyterm` | Open a new local session in a new window | | `psyterm --attach [ID]` | Open a window on an existing session | | `psyterm --remote user@host` | Start a fresh SSH session in an adjacent tab when run from a local psyTerm pane, or a new window when run elsewhere | +| `psyterm --remote --attach` | Reopen the last remote session you detached | | `psyterm --remote user@host --attach [ID]` | Reattach to an existing session on the SSH host | | `psyterm --gui` | Run the GUI in the current process | | `psyterm --list` | Show local sessions, attached window counts, tabs, and panes | @@ -144,6 +145,22 @@ to find remote session IDs. Closing the window and reattaching to the local session restores its mixed tab bar. The **+** button creates a local tab in this workspace. Splitting a remote pane creates another shell on its SSH host. +To detach, hover over a remote tab and click **×**, or focus it and choose +**Detach remote session** in the command palette. If that SSH session has +several tabs, they detach together. Its shells, running jobs, and scrollback +stay on the remote host. **Close pane** still ends the shell in that pane. + +Run `psyterm --remote --attach` from a local pane to bring back that +workspace’s last detached remote session in the tab bar. From outside +psyTerm, the same command reopens the most recently detached remote session +in a window. The local daemon remembers these targets until it exits. +If you detach a nested SSH session, run the command on the host that opened it. +You can also select a session explicitly with `psyterm --remote user@host --attach ID`. + +The workspace’s daemon must be running this build for the tab close button +and remote detach history. Existing protocol-v6 sessions on the SSH host +can stay running. + SSH uses `BatchMode=yes`. Configure key or agent authentication and trust the host key before connecting. The remote host needs a compatible `psyterm` executable on its noninteractive SSH `PATH`. To use a different path, set @@ -181,6 +198,8 @@ run `psyterm --shutdown` on the remote host, for example through SSH. | Jump to oldest history / live screen | Shift+Home / End | Shift+Home / End | Click a tab to switch, `+` to create a tab, or a collapsed pane title to expand it. +Hover over any tab to show its **×** button. On a local tab, it closes the tab +and all its shells. On a remote tab, it detaches the SSH session. Drag, double-click, or triple-click to select text, a word, or a line. Scroll with the mouse wheel or touchpad. Closing the window detaches the GUI and keeps the server sessions running. diff --git a/src/bindings.rs b/src/bindings.rs index 874ca35..f285968 100644 --- a/src/bindings.rs +++ b/src/bindings.rs @@ -207,7 +207,7 @@ mod tests { use crate::commands::{PaletteItemKind, root_items}; use std::mem::discriminant; - for item in root_items(None) { + for item in root_items(None, false) { let (Some(hint), PaletteItemKind::Action(expected)) = (item.shortcut, &item.kind) else { continue; diff --git a/src/chrome.rs b/src/chrome.rs index e569113..21b3a31 100644 --- a/src/chrome.rs +++ b/src/chrome.rs @@ -39,15 +39,16 @@ pub struct ChromeTab { } /// An app-owned titlebar. Callbacks issue server commands; no tab state lives here. -/// The close callback should detach this GUI, leaving server sessions alive. pub fn header( tabs: Vec, reserve_traffic_lights: bool, on_tab: impl Fn(u64, &mut Window, &mut App) + 'static, + on_close_tab: impl Fn(u64, &mut Window, &mut App) + 'static, on_new: impl Fn(&mut Window, &mut App) + 'static, on_close: impl Fn(&mut Window, &mut App) + 'static, ) -> Div { let on_tab = Rc::new(on_tab); + let on_close_tab = Rc::new(on_close_tab); let mut tab_strip = div() .flex() .items_center() @@ -58,9 +59,11 @@ pub fn header( .overflow_hidden(); for tab in tabs { let on_tab = on_tab.clone(); + let on_close_tab = on_close_tab.clone(); let active = tab.active; let id = tab.id; - let (accent, selected_bg, hover_bg, selected_border) = if tab.remote.is_some() { + let remote = tab.remote.is_some(); + let (accent, selected_bg, hover_bg, selected_border) = if remote { (PANE_FOCUS, 0x102d28, 0x112720, 0x285749) } else { (ACCENT, ACTIVE_BACKGROUND, HOVER_BACKGROUND, BORDER) @@ -98,6 +101,7 @@ pub fn header( tab_strip = tab_strip.child( div() .id(ElementId::Name(format!("tab-{id}").into())) + .group("tab") .flex() .items_center() .gap(px(7.)) @@ -106,6 +110,7 @@ pub fn header( .flex_shrink() .min_w_0() .max_w(px(200.)) + .overflow_hidden() .px(px(10.)) .border_1() .border_color(rgb(if active { @@ -134,7 +139,23 @@ pub fn header( .h(px(if active { 22. } else { 12. })) .bg(rgb(accent)), ) - .child(label), + .child(label) + .child( + control("close-tab", "×", !remote, move |window, cx| { + on_close_tab(id, window, cx); + }) + .size(px(22.)) + .opacity(0.) + .group_hover("tab", |style| style.opacity(1.)) + .tooltip(move |_, cx| { + let text = if remote { + "Detach remote session" + } else { + "Close tab and its shells" + }; + cx.new(|_| TabCloseTooltip(text)).into() + }), + ), ); } @@ -174,6 +195,22 @@ pub fn header( ) } +struct TabCloseTooltip(&'static str); + +impl Render for TabCloseTooltip { + fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement { + div() + .px_2() + .py_1() + .bg(rgb(CONTROL_BACKGROUND)) + .border_1() + .border_color(rgb(BORDER)) + .text_size(px(12.)) + .text_color(rgb(TEXT)) + .child(self.0) + } +} + /// Keep SSH aliases as entered, omitting user, URI port and IPv6 brackets. fn remote_hostname(destination: &str) -> &str { let uri = destination.strip_prefix("ssh://"); @@ -264,6 +301,7 @@ mod tests { ], cfg!(target_os = "macos"), |_, _, _| {}, + |_, _, _| {}, |_, _| {}, |_, _| {}, ); diff --git a/src/client.rs b/src/client.rs index 2712bb2..60b1f05 100644 --- a/src/client.rs +++ b/src/client.rs @@ -1,6 +1,8 @@ //! Display-only client transport. No terminal parser, PTY, or shell lives here. -use crate::protocol::{self, ClientMessage, ServerMessage, SessionTarget, Snapshot, SshOptions}; -use anyhow::{Context, Result, bail}; +use crate::protocol::{ + self, ClientMessage, ServerMessage, SessionIdentity, SessionTarget, Snapshot, SshOptions, +}; +use anyhow::{Context, Result, bail, ensure}; use std::{ collections::{HashSet, VecDeque}, io::{self, Read, Write}, @@ -42,10 +44,18 @@ impl Updates { } #[derive(Clone)] -pub struct Client(Arc); +pub struct Client { + connection: Arc, + remote_session: Option>, +} +struct RemoteSession { + identity: SessionIdentity, + live: AtomicBool, +} struct Connection { launcher_socket: PathBuf, remote: Option, + remote_executable: Option, commands: mpsc::Sender, socket: Option, ssh: Mutex>, @@ -90,14 +100,9 @@ impl Client { launcher_socket: &Path, remote: Option<&str>, session: SessionTarget, + options: SshOptions, ) -> Result<(Self, Updates)> { - Self::connect_with( - launcher_socket, - remote, - session, - SshOptions::from_env(), - None, - ) + Self::connect_with(launcher_socket, remote, session, options, None) } pub fn connect_remote( @@ -123,6 +128,13 @@ impl Client { options: SshOptions, cancelled: Option>, ) -> Result<(Self, Updates)> { + let (session, expected) = match session { + SessionTarget::Remembered(identity) => ( + SessionTarget::Attach(Some(identity.session)), + Some(identity), + ), + other => (other, None), + }; let (mut reader, mut writer, socket, mut ssh): (_, Box, _, _) = if let Some(remote) = remote { validate_destination(remote)?; @@ -175,13 +187,14 @@ impl Client { let (commands, receive) = mpsc::channel(); let (signal, notifications) = async_channel::bounded(1); let pending = Arc::new(Mutex::new(Update::default())); - let connection = Self(Arc::new(Connection { + let connection = Arc::new(Connection { launcher_socket: launcher_socket.to_owned(), remote: remote.map(str::to_owned), + remote_executable: options.executable, commands, socket, ssh: Mutex::new(ssh), - })); + }); let diagnostic = stderr.map(ssh_diagnostics).transpose()?; reader.set_read_timeout(Some(Duration::from_millis(150)))?; let mut greeting = GreetingReader { @@ -189,15 +202,34 @@ impl Client { deadline: Instant::now() + Duration::from_secs(if remote.is_some() { 30 } else { 5 }), cancelled: cancelled.as_deref(), }; - if let Err(error) = greet(&mut greeting, &mut writer, session) { - drop(connection); - if let Some(detail) = diagnostic - .and_then(|rx| rx.recv_timeout(Duration::from_millis(150)).ok()) - .filter(|s| !s.is_empty()) - { - bail!("{error:#}: {detail}"); + let first_frame = match greet( + &mut greeting, + &mut writer, + session, + remote.is_some(), + expected, + ) { + Ok(greeting) => greeting, + Err(error) => { + drop(connection); + if let Some(detail) = diagnostic + .and_then(|rx| rx.recv_timeout(Duration::from_millis(150)).ok()) + .filter(|s| !s.is_empty()) + { + bail!("{error:#}: {detail}"); + } + return Err(error); } - return Err(error); + }; + let remote_session = first_frame.as_ref().map(|frame| { + Arc::new(RemoteSession { + identity: frame.lineage[0], + live: AtomicBool::new(!frame.tabs.is_empty()), + }) + }); + if let Some(frame) = first_frame { + pending.lock().unwrap().snapshot = Some(Arc::new(frame)); + let _ = signal.try_send(()); } reader.set_read_timeout(None)?; let errors = pending.clone(); @@ -215,57 +247,15 @@ impl Client { } })?; let incoming = pending.clone(); + let reader_session = remote_session.clone(); thread::Builder::new() .name("psyterm-client-reader".into()) - .spawn(move || { - let mut reader = reader; - loop { - let message = protocol::read_message::(&mut reader); - let mut update = incoming.lock().unwrap(); - match message { - Ok(ServerMessage::Snapshot(snapshot)) => { - if let Err(error) = validate_snapshot(&snapshot) { - update.disconnected = true; - update.error = Some(error.to_string()); - let _ = signal.try_send(()); - break; - } - // A slow window never accumulates a queue of obsolete frames. - update.snapshot = Some(Arc::new(snapshot)); - } - Ok(ServerMessage::Clipboard(text)) => { - if update.clipboard.len() < 16 { - update.clipboard.push_back(text); - } - } - Ok(ServerMessage::Error(error)) => update.error = Some(error), - Ok(ServerMessage::Closing) => { - update.disconnected = true; - update.error = - Some("Server stopped. Shell sessions have ended.".into()); - let _ = signal.try_send(()); - break; - } - Ok(ServerMessage::Pong) => {} - Ok(_) => { - update.error = - Some("Unexpected server response after session handshake".into()); - } - Err(error) => { - update.disconnected = true; - update.error = Some(format!( - "Disconnected — sessions remain on the server. {error:#}" - )); - let _ = signal.try_send(()); - break; - } - } - drop(update); - let _ = signal.try_send(()); - } - })?; + .spawn(move || read_updates(reader, &incoming, signal, reader_session.as_deref()))?; Ok(( - connection, + Self { + connection, + remote_session, + }, Updates { signal: notifications, pending, @@ -274,13 +264,42 @@ impl Client { } pub fn remote(&self) -> Option<&str> { - self.0.remote.as_deref() + self.connection.remote.as_deref() + } + + pub fn remote_identity(&self) -> Option { + self.remote_session.as_ref().map(|session| session.identity) + } + + pub fn remote_executable(&self) -> Option<&str> { + self.connection.remote_executable.as_deref() + } + + /// Remember a direct SSH window on its local launcher before detaching it. + pub fn remember_remote_detach(&self) -> Result<()> { + let destination = self.remote().context("this window is local")?.to_owned(); + let session = self + .remote_session + .as_ref() + .context("missing SSH session identity")?; + if !session.live.load(Ordering::Acquire) { + return Ok(()); + } + crate::launcher::control( + &self.connection.launcher_socket, + ClientMessage::RememberDetachedRemote(protocol::DetachedRemote { + destination, + identity: session.identity, + executable: self.remote_executable().map(str::to_owned), + }), + )?; + Ok(()) } /// Launch through the local daemon even when this terminal connects over SSH. pub fn open_window(&self, remote: Option, cwd: Option) -> Result<()> { crate::launcher::control( - &self.0.launcher_socket, + &self.connection.launcher_socket, ClientMessage::OpenWindow { target: remote, session: SessionTarget::New { cwd }, @@ -290,7 +309,7 @@ impl Client { } pub fn send(&self, message: ClientMessage) -> Result<()> { - self.0 + self.connection .commands .send(message) .context("server transport is closed") @@ -306,6 +325,66 @@ impl Client { } } +fn read_updates( + mut reader: impl Read, + pending: &Mutex, + signal: async_channel::Sender<()>, + remote_session: Option<&RemoteSession>, +) { + loop { + let message = protocol::read_message::(&mut reader); + let mut update = pending.lock().unwrap(); + match message { + Ok(ServerMessage::Snapshot(snapshot)) => { + match validate_snapshot(&snapshot) { + Ok(()) => { + if let Some(session) = remote_session { + session + .live + .store(!snapshot.tabs.is_empty(), Ordering::Release); + } + update.snapshot = Some(Arc::new(snapshot)); + } + Err(error) => { + // Older daemons can briefly mix layouts and grids during SSH + // navigation. A complete frame leaves the stream synchronized. + update.error = Some(format!("Discarded workspace update: {error}")); + } + } + } + Ok(ServerMessage::Clipboard(text)) => { + if update.clipboard.len() < 16 { + update.clipboard.push_back(text); + } + } + Ok(ServerMessage::Error(error)) => update.error = Some(error), + Ok(ServerMessage::Closing) => { + if let Some(session) = remote_session { + session.live.store(false, Ordering::Release); + } + update.disconnected = true; + update.error = Some("Server stopped. Shell sessions have ended.".into()); + } + Ok(ServerMessage::Pong) => {} + Ok(_) => { + update.error = Some("Unexpected server response after session handshake".into()); + } + Err(error) => { + update.disconnected = true; + update.error = Some(format!( + "Disconnected — sessions remain on the server. {error:#}" + )); + } + } + let disconnected = update.disconnected; + drop(update); + let _ = signal.try_send(()); + if disconnected { + break; + } + } +} + /// Drain SSH stderr throughout the connection. Keep a bounded tail to explain /// startup failures in the invoking window as well as in the daemon log. fn ssh_diagnostics(mut stderr: ChildStderr) -> io::Result> { @@ -383,7 +462,9 @@ fn greet( reader: &mut GreetingReader<'_>, writer: &mut impl Write, session: SessionTarget, -) -> Result<()> { + from_ssh: bool, + expected: Option, +) -> Result> { reader.check()?; protocol::write_message( writer, @@ -398,11 +479,37 @@ fn greet( } reader.check()?; protocol::write_message(writer, &ClientMessage::Connect(session))?; - match protocol::read_message::(reader)? { - ServerMessage::Connected { .. } => Ok(()), + let session = match protocol::read_message::(reader)? { + ServerMessage::Connected { session } => session, ServerMessage::Error(error) => bail!("{error}"), _ => bail!("server did not acknowledge the session"), + }; + if !from_ssh && expected.is_none() { + return Ok(None); } + // Session numbers start over after a daemon restart. Check the identity + // before handing a display or an input channel to the attaching client. + let frame = match protocol::read_message::(reader)? { + ServerMessage::Snapshot(frame) => frame, + ServerMessage::Error(error) => bail!("{error}"), + _ => bail!("expected initial SSH session snapshot"), + }; + validate_snapshot(&frame)?; + let identity = frame + .lineage + .first() + .context("missing SSH session identity")?; + ensure!( + identity.session == session, + "incorrect SSH session identity" + ); + if let Some(expected) = expected { + ensure!( + *identity == expected, + "the remembered remote session has ended" + ); + } + Ok(Some(frame)) } fn shell_quote(value: &str) -> String { @@ -502,6 +609,105 @@ fn copy_and_flush(reader: &mut impl Read, writer: &mut impl Write) -> std::io::R #[cfg(test)] mod tests { use super::*; + + #[test] + fn invalid_frame_does_not_disconnect_local_or_remote_workspaces() { + let remote = RemoteSession { + identity: SessionIdentity { + server: [1; 16], + session: 1, + }, + live: AtomicBool::new(true), + }; + for session in [None, Some(&remote)] { + let (client, mut server) = UnixStream::pair().unwrap(); + client + .set_read_timeout(Some(Duration::from_secs(5))) + .unwrap(); + let pending = Mutex::new(Update::default()); + let (signal, received) = async_channel::bounded(1); + thread::scope(|threads| { + threads.spawn(|| read_updates(client, &pending, signal, session)); + let mut send_snapshot = |snapshot| { + protocol::write_message(&mut server, &ServerMessage::Snapshot(snapshot)) + .unwrap(); + received.recv_blocking().unwrap(); + std::mem::take(&mut *pending.lock().unwrap()) + }; + let frame = Snapshot { + lineage: vec![remote.identity], + revision: 1, + tabs: vec![protocol::TabInfo { + id: 1, + remote: Some("work".into()), + title: "work".into(), + manual_title: None, + panes: Vec::new(), + active_pane: 0, + stacks: Vec::new(), + }], + active_tab: 1, + panes: Vec::new(), + }; + assert_eq!(send_snapshot(frame.clone()).snapshot.unwrap().revision, 1); + + let skipped = send_snapshot(Snapshot { + revision: 2, + active_tab: 42, + ..frame.clone() + }); + assert!(skipped.snapshot.is_none()); + assert!(skipped.error.unwrap().contains("invalid active tab")); + assert!(!skipped.disconnected); + + let resumed = send_snapshot(Snapshot { + revision: 3, + ..frame + }); + assert_eq!(resumed.snapshot.unwrap().revision, 3); + assert!(!resumed.disconnected); + + server.shutdown(Shutdown::Write).unwrap(); + received.recv_blocking().unwrap(); + assert!(pending.lock().unwrap().disconnected); + }); + } + } + + #[test] + fn remote_session_can_be_remembered_after_transport_loss_but_not_after_exit() { + let empty = ServerMessage::Snapshot(Snapshot { + revision: 2, + lineage: Vec::new(), + tabs: Vec::new(), + active_tab: 0, + panes: Vec::new(), + }); + for (last_message, resumable) in [ + (ServerMessage::Pong, true), + (empty, false), + (ServerMessage::Closing, false), + ] { + let remote = RemoteSession { + identity: SessionIdentity { + server: [1; 16], + session: 1, + }, + live: AtomicBool::new(true), + }; + let mut bytes = Vec::new(); + protocol::write_message(&mut bytes, &last_message).unwrap(); + let (signal, _updates) = async_channel::bounded(1); + read_updates( + bytes.as_slice(), + &Mutex::new(Update::default()), + signal, + Some(&remote), + ); + assert_eq!(remote.live.load(Ordering::Acquire), resumable); + } + } + #[test] fn binary_bridge_flushes_without_newlines() { struct Output { diff --git a/src/commands.rs b/src/commands.rs index c4fe330..a7a3f8b 100644 --- a/src/commands.rs +++ b/src/commands.rs @@ -32,6 +32,7 @@ pub enum CommandAction { FocusTab(u64), FocusPane(u64), Scroll(ScrollKind), + DetachRemote, Detach, } @@ -101,7 +102,7 @@ fn shortcut(mac: &'static str, linux: &'static str) -> Option<&'static str> { } /// The complete command list. UI state affects availability, never discovery. -pub fn root_items(snapshot: Option<&Snapshot>) -> Vec { +pub fn root_items(snapshot: Option<&Snapshot>, remote_window: bool) -> Vec { use CommandAction::*; let pane = snapshot.is_some_and(|s| !s.panes.is_empty()); let tabs = snapshot.is_some_and(|s| !s.tabs.is_empty()); @@ -278,6 +279,19 @@ pub fn root_items(snapshot: Option<&Snapshot>) -> Vec { Scroll(ScrollKind::Bottom), ) .available(pane), + PaletteItem::action( + "detach-remote", + "Detach remote session", + "disconnect ssh close tab keep shells running reattach", + None, + DetachRemote, + ) + .available( + remote_window + || snapshot + .and_then(Snapshot::active_tab) + .is_some_and(|tab| tab.remote.is_some()), + ), PaletteItem::action( "detach", "Detach window", @@ -382,10 +396,11 @@ mod tests { #[test] fn empty_workspace_keeps_commands_discoverable_without_unsafe_actions() { - let items = root_items(None); + let items = root_items(None, false); let find = |id: &str| items.iter().find(|item| item.id == id).unwrap(); assert!(find("new-tab").enabled); assert!(find("detach").enabled); + assert!(!find("detach-remote").enabled); assert!(!find("close-pane").enabled); assert!(!find("switch-tab").enabled); assert!(find("reset-pane-name").shortcut.is_none()); diff --git a/src/launcher.rs b/src/launcher.rs index 1254f0f..bf02b39 100644 --- a/src/launcher.rs +++ b/src/launcher.rs @@ -170,9 +170,10 @@ fn control_stream_version( loop { let message: ServerMessage = protocol::read_message(&mut stream)?; match message { - ServerMessage::Pong | ServerMessage::Closing | ServerMessage::Sessions(_) => { - return Ok(message); - } + ServerMessage::Pong + | ServerMessage::Closing + | ServerMessage::Sessions(_) + | ServerMessage::DetachedRemote(_) => return Ok(message), ServerMessage::Error(error) => bail!("{error}"), _ => {} } @@ -246,6 +247,9 @@ pub fn open_window( command.arg(id.to_string()); } } + // Hostless reattachment opens the GUI in the invoking process so its + // SSH options, daemon identity checks, and connection errors are retained. + protocol::SessionTarget::Remembered(_) => bail!("reattach through the invoking client"), } if let Some(host) = remote { command.arg("--remote").arg(host); diff --git a/src/launcher/zygote.rs b/src/launcher/zygote.rs index e3b4fc0..3ea0cf0 100644 --- a/src/launcher/zygote.rs +++ b/src/launcher/zygote.rs @@ -257,8 +257,14 @@ pub fn run_zygote(socket: &Path) -> Result<()> { } drop(stream); drop(listener); - let result = set_child_reaping(false) - .and_then(|()| crate::run_gui(server_socket, remote, session)); + let result = set_child_reaping(false).and_then(|()| { + crate::run_gui( + server_socket, + remote, + session, + protocol::SshOptions::from_env(), + ) + }); let code = if let Err(error) = result { log::error!("GUI startup failed: {error:#}"); 1 diff --git a/src/main.rs b/src/main.rs index 7273552..5a84a50 100644 --- a/src/main.rs +++ b/src/main.rs @@ -17,7 +17,7 @@ mod session; mod terminal; mod transition; -use anyhow::{Result, bail}; +use anyhow::{Context as _, Result, bail}; use gpui::{prelude::*, *}; use protocol::{SessionId, SessionTarget}; use std::path::PathBuf; @@ -66,14 +66,11 @@ fn main() -> Result<()> { )) } "--remote" => { - remote = Some( - args.next_if(|arg| !arg.starts_with('-')) - .ok_or_else(|| anyhow::anyhow!("--remote needs an SSH destination"))?, - ) + remote = Some(args.next_if(|arg| !arg.starts_with('-'))); } "--help" | "-h" => { println!( - "psyTerm — server-owned terminals with a GPUI front end\n\n psyterm Open a new session in a new window\n psyterm --attach [ID] Join an existing session (prefer the latest detached session)\n psyterm --remote user@host Open an SSH session (an adjacent tab when run inside psyTerm)\n psyterm --list List local sessions, tabs and panes\n psyterm --shutdown Stop the local server and its shell sessions\n psyterm --socket PATH Use a separate local server\n psyterm --gui Run the GUI in the current process\n psyterm --server Run the server in the foreground\n psyterm --bridge Binary stdin/stdout transport used by SSH\n\nClosing a window detaches; tabs and shells keep running.\nSSH requires key/agent authentication and psyterm in the remote PATH.\nPSYTERM_REMOTE_BIN overrides the remote executable path.\n" + "psyTerm — server-owned terminals with a GPUI front end\n\n psyterm Open a new session in a new window\n psyterm --attach [ID] Join an existing session (prefer the latest detached session)\n psyterm --remote user@host Open an SSH session (an adjacent tab when run inside psyTerm)\n psyterm --remote --attach Reopen the last detached remote session\n psyterm --remote HOST --attach [ID] Join an existing session on HOST\n psyterm --list List local sessions, tabs and panes\n psyterm --shutdown Stop the local server and its shell sessions\n psyterm --socket PATH Use a separate local server\n psyterm --gui Run the GUI in the current process\n psyterm --server Run the server in the foreground\n psyterm --bridge Binary stdin/stdout transport used by SSH\n\nClosing a window detaches; tabs and shells keep running.\nSSH requires key/agent authentication and psyterm in the remote PATH.\nPSYTERM_REMOTE_BIN overrides the remote executable path.\n" ); return Ok(()); } @@ -83,6 +80,12 @@ fn main() -> Result<()> { if attach.is_some() && !matches!(role, "gui" | "launch" | "bridge") { bail!("--attach applies to a window or an SSH bridge"); } + if remote.is_some() && !matches!(role, "launch" | "gui") { + bail!("--remote applies to a GUI window or tab"); + } + if remote == Some(None) && attach.is_none() { + bail!("--remote needs an SSH destination, or --attach to reopen a detached remote session"); + } #[cfg(target_os = "macos")] if matches!(role, "launch" | "gui") && unsafe { libc::getppid() } == 1 @@ -92,7 +95,48 @@ fn main() -> Result<()> { // Finder launches the bundled process from the filesystem root. std::env::set_current_dir(home)?; } - let session = if let Some(id) = attach { + let origin = if role == "launch" && remote.is_some() { + session::PaneContext::from_env()? + } else { + None + }; + if let (Some(explicit), Some(origin)) = (&socket, &origin) + && explicit.canonicalize()? != origin.socket.canonicalize()? + { + bail!("--socket points outside the invoking psyTerm pane"); + } + let socket = socket + .or_else(|| origin.as_ref().map(|pane| pane.socket.clone())) + .map(Ok) + .unwrap_or_else(launcher::default_socket)?; + let mut ssh = protocol::SshOptions::from_env(); + let remembered = match remote { + Some(None) => { + launcher::require_server(&socket) + .context("no remembered remote session here; specify --remote HOST --attach")?; + let response = launcher::control( + &socket, + protocol::ClientMessage::LastDetachedRemote { + origin: origin.as_ref().map(|pane| pane.session), + }, + )?; + let protocol::ServerMessage::DetachedRemote(target) = response else { + bail!("expected a detached remote session"); + }; + Some(target) + } + _ => None, + }; + let remote = remote + .flatten() + .or_else(|| remembered.as_ref().map(|t| t.destination.clone())); + let session = if let Some(target) = remembered { + ssh.executable = ssh.executable.or(target.executable); + match attach.flatten() { + None => SessionTarget::Remembered(target.identity), + Some(id) => SessionTarget::Attach(Some(id)), + } + } else if let Some(id) = attach { SessionTarget::Attach(id) } else { SessionTarget::New { @@ -105,29 +149,20 @@ fn main() -> Result<()> { }, } }; - if role == "launch" - && let Some(destination) = &remote - && let Some(origin) = session::PaneContext::from_env()? - { - if let Some(explicit) = &socket - && explicit.canonicalize()? != origin.socket.canonicalize()? - { - bail!("--socket points outside the invoking psyTerm pane"); - } + if let (Some(destination), Some(origin)) = (&remote, origin) { launcher::control( - &origin.socket, + &socket, protocol::ClientMessage::OpenRemoteTab { session: origin.session, pane: origin.pane, destination: destination.clone(), target: session, - ssh: protocol::SshOptions::from_env(), + ssh, }, )?; return Ok(()); } - let socket = socket.map(Ok).unwrap_or_else(launcher::default_socket)?; match role { #[cfg(target_os = "macos")] "server" => server::run(&socket, |remote, session| { @@ -157,7 +192,7 @@ fn main() -> Result<()> { } else { launcher::ensure_server(&socket)?; } - run_gui(socket, remote, session) + run_gui(socket, remote, session, ssh) } "bridge" => client::bridge(&socket, attach.is_some()), "shutdown" => { @@ -210,9 +245,23 @@ pub(crate) fn run_gui( socket: PathBuf, remote: Option, session: SessionTarget, + ssh: protocol::SshOptions, ) -> Result<()> { - let (client, updates) = client::Client::connect(&socket, remote.as_deref(), session)?; + let (client, updates) = client::Client::connect(&socket, remote.as_deref(), session, ssh)?; Application::new().run(move |cx: &mut App| { + // Each GUI process owns one window. Remember a direct SSH session + // on every graceful close, including the native close button and Quit. + if client.remote().is_some() { + let direct = client.clone(); + cx.on_app_quit(move |_| { + // Finish the local launcher request before AppKit exits. + if let Err(error) = direct.remember_remote_detach() { + log::warn!("Could not remember detached SSH session: {error:#}"); + } + std::future::ready(()) + }) + .detach(); + } #[cfg(target_os = "macos")] { cx.on_action(|_: &Quit, cx| cx.quit()); diff --git a/src/protocol.rs b/src/protocol.rs index 677620e..24a7a06 100644 --- a/src/protocol.rs +++ b/src/protocol.rs @@ -24,8 +24,13 @@ pub struct SessionIdentity { #[derive(Debug, Clone, Serialize, Deserialize)] pub enum SessionTarget { - New { cwd: Option }, + New { + cwd: Option, + }, Attach(Option), + /// Local launcher request. The transport attaches by numeric ID on the v6 + /// wire and verifies the daemon identity in the first snapshot. + Remembered(SessionIdentity), } /// SSH settings inherited from the shell that requested a remote tab. @@ -35,6 +40,14 @@ pub struct SshOptions { pub agent_socket: Option, } +/// Reconnect using the original remote binary and verify the daemon that owned the shell. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct DetachedRemote { + pub destination: String, + pub identity: SessionIdentity, + pub executable: Option, +} + #[derive(Debug, Clone, Serialize, Deserialize)] pub struct SessionInfo { pub id: SessionId, @@ -84,8 +97,10 @@ pub enum ClientMessage { FocusPane { pane: PaneId, }, - ClosePane { - pane: PaneId, + /// Close a pane or an entire local tab. Pane and tab IDs are allocated + /// from the same sequence. Older v6 daemons only recognize pane IDs here. + Close { + id: u64, }, OpenWindow { target: Option, @@ -137,9 +152,16 @@ pub enum ClientMessage { target: SessionTarget, ssh: SshOptions, }, - ClosePendingTab { + /// Detach the SSH session displayed by this tab. Older v6 servers accept + /// this same wire command only while the connection is pending. + DetachRemote { tab: TabId, }, + /// Local launcher requests used to reopen a detached SSH connection. + LastDetachedRemote { + origin: Option, + }, + RememberDetachedRemote(DetachedRemote), } #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] @@ -205,6 +227,7 @@ pub enum ServerMessage { Closing, Connected { session: SessionId }, Sessions(Vec), + DetachedRemote(DetachedRemote), } #[derive(Debug, Clone, Serialize, Deserialize)] diff --git a/src/server.rs b/src/server.rs index 2cba074..59eea61 100644 --- a/src/server.rs +++ b/src/server.rs @@ -236,6 +236,7 @@ fn run_with_shell( shell, clients: HashMap::new(), sessions: BTreeMap::new(), + last_detached_remote: None, next_session: 1, sender, last_frame: Instant::now() - FRAME_INTERVAL, @@ -290,6 +291,7 @@ struct Server { socket: PathBuf, shell: Option, sessions: BTreeMap, + last_detached_remote: Option, next_session: SessionId, clients: HashMap, sender: mpsc::SyncSender, @@ -301,6 +303,7 @@ struct SessionState { identity: SessionIdentity, socket: PathBuf, remotes: HashMap, + last_detached_remote: Option, id: SessionId, last_used: Instant, shell: Option, @@ -523,6 +526,9 @@ impl Server { ensure!(client.session.is_none(), "client already has a session"); let session_id = match target { SessionTarget::Attach(id) => self.attach_target(id)?, + SessionTarget::Remembered(_) => { + anyhow::bail!("expected a resolved session target") + } SessionTarget::New { cwd } => { let id = self.next_session; self.next_session += 1; @@ -599,6 +605,39 @@ impl Server { open_window(target, session)?; self.clients[&id].output.reliable(ServerMessage::Pong); } + ClientMessage::DetachRemote { tab } => { + let state = self + .sessions + .get_mut(&client.session.context("join a session first")?) + .context("session has ended")?; + state.last_used = Instant::now(); + if let Some(target) = state.detach_remote(tab)? { + state.last_detached_remote = Some(target.clone()); + self.last_detached_remote = Some(target); + } + } + ClientMessage::RememberDetachedRemote(target) => { + crate::client::validate_destination(&target.destination)?; + self.last_detached_remote = Some(target); + client.output.reliable(ServerMessage::Pong); + } + ClientMessage::LastDetachedRemote { origin } => { + let workspace = origin + .map(|origin| { + self.sessions + .get(&origin.session) + .filter(|state| state.identity == origin) + .context("originating psyTerm session has ended") + }) + .transpose()?; + let target = workspace + .and_then(|state| state.last_detached_remote.as_ref()) + .or(self.last_detached_remote.as_ref()) + .context("no remembered remote session here; specify --remote HOST --attach")?; + client + .output + .reliable(ServerMessage::DetachedRemote(target.clone())); + } ClientMessage::Detach => self.remove_client(id), message => { let session = self @@ -625,6 +664,7 @@ impl SessionState { identity, socket, remotes: HashMap::new(), + last_detached_remote: None, last_used: Instant::now(), shell, panes: HashMap::new(), @@ -827,11 +867,19 @@ impl SessionState { ClientMessage::FocusPane { pane } => { self.focus_pane(pane)?; } - ClientMessage::ClosePendingTab { tab } => { - self.cancel_pending_tab(tab)?; - } - ClientMessage::ClosePane { pane } => { - ensure!(self.remove_pane(pane), "unknown pane"); + ClientMessage::Close { id } => { + if !self.remove_pane(id) { + let index = self + .tabs + .iter() + .position(|tab| tab.id == id) + .context("unknown pane or tab")?; + ensure!( + self.tabs[index].remote.is_none(), + "detach the SSH session to close its tabs" + ); + self.remove_local_tab(index); + } } ClientMessage::RenamePane { pane, name } => { self.pane_mut(pane)?.manual_title = name.and_then(clean_title); @@ -854,6 +902,9 @@ impl SessionState { | ClientMessage::ListSessions | ClientMessage::OpenWindow { .. } | ClientMessage::OpenRemoteTab { .. } + | ClientMessage::DetachRemote { .. } + | ClientMessage::LastDetachedRemote { .. } + | ClientMessage::RememberDetachedRemote(_) | ClientMessage::Detach => anyhow::bail!("expected a session command"), } Ok(()) @@ -1013,25 +1064,34 @@ impl SessionState { } flatten_panes(tab); if tab.stacks.is_empty() { - let removed_tab = self.tabs.remove(tab_index); - if self.active_tab == removed_tab.id { - self.active_tab = self - .tabs - .get(tab_index.min(self.tabs.len().saturating_sub(1))) - .map_or(0, |tab| tab.id); - } + self.remove_local_tab(tab_index); } } self.dirty = true; // No terminal lock is held here. On Event::Exit the I/O thread has // drained output and will finish, so joining Session cleanup is safe. drop(removed); - if self.active_tab != 0 { - let _ = self.focus_tab(self.active_tab); - } true } + /// Remove every PTY in the tab, including collapsed panes, in one actor turn. + fn remove_local_tab(&mut self, index: usize) { + let tab = self.tabs.remove(index); + for pane in tab.panes { + self.panes.remove(&pane); + } + if self.active_tab == tab.id { + self.active_tab = self + .tabs + .get(index.min(self.tabs.len().saturating_sub(1))) + .map_or(0, |tab| tab.id); + if self.active_tab != 0 { + let _ = self.focus_tab(self.active_tab); + } + } + self.dirty = true; + } + fn refresh_directories(&mut self) { for pane in self.panes.values_mut() { if let Some(directory) = pane.session.working_directory() { @@ -1417,7 +1477,7 @@ mod tests { fn send(stream: &mut UnixStream, message: ClientMessage) { protocol::write_message(stream, &message).unwrap(); } - fn contains(snapshot: &Snapshot, text: &str) -> bool { + pub(super) fn contains(snapshot: &Snapshot, text: &str) -> bool { snapshot.panes.iter().any(|pane| { pane.cells .iter() @@ -1427,6 +1487,29 @@ mod tests { }) } + #[test] + fn direct_remote_detach_can_be_looked_up_without_a_window() { + let server = TestServer::start(); + let control = |message| crate::launcher::control(&server.socket, message); + let lookup = || control(ClientMessage::LastDetachedRemote { origin: None }); + assert!(lookup().unwrap_err().to_string().contains("--remote HOST")); + for (destination, session) in [("first-host", 41), ("second-host", 19)] { + let target = DetachedRemote { + destination: destination.into(), + identity: SessionIdentity { + server: [3; 16], + session, + }, + executable: Some("/opt/bin/psyterm".into()), + }; + control(ClientMessage::RememberDetachedRemote(target.clone())).unwrap(); + assert!(matches!( + lookup().unwrap(), + ServerMessage::DetachedRemote(found) if found == target + )); + } + } + #[test] fn new_sessions_isolate_live_shells_and_attach_selects_only_existing_work() { let server = TestServer::start(); @@ -1502,12 +1585,7 @@ mod tests { ServerMessage::Error(message) if message.contains("no such session")) ); - send( - &mut mirror, - ClientMessage::ClosePane { - pane: b.panes[0].id, - }, - ); + send(&mut mirror, ClientMessage::Close { id: b.panes[0].id }); list_after_commands(&mut mirror); assert_eq!( list(&mut control).iter().map(|s| s.id).collect::>(), @@ -2103,7 +2181,7 @@ mod tests { assert_eq!(active_tab(&collapsed_exit).panes, [middle, bottom]); assert_eq!(collapsed_exit.panes[0].id, middle); // Explicit close uses the same adjacent fallback as natural exit. - send(&mut client, ClientMessage::ClosePane { pane: middle }); + send(&mut client, ClientMessage::Close { id: middle }); let closed = snapshot(&mut client, |s| active_tab(s).panes.len() == 1); assert_eq!(closed.panes[0].id, bottom); send( @@ -2123,6 +2201,69 @@ mod tests { assert!(empty.panes.is_empty()); } + #[test] + fn closing_a_local_tab_removes_all_its_panes_and_preserves_adjacent_tabs() { + let server = TestServer::start(); + let mut client = server.client(); + send( + &mut client, + ClientMessage::Connect(SessionTarget::New { cwd: None }), + ); + let initial = snapshot(&mut client, |s| s.panes.len() == 1); + let first = initial.active_tab; + let pane = initial.panes[0].id; + send(&mut client, ClientMessage::Split { pane, cwd: None }); + send( + &mut client, + ClientMessage::NewStackPane { + pane: Some(pane), + direction: VerticalDirection::Down, + cwd: None, + }, + ); + send(&mut client, ClientMessage::NewTab { cwd: None }); + send(&mut client, ClientMessage::NewTab { cwd: None }); + let three = list_after_commands(&mut client); + let removed = &three.tabs[0].panes; + assert_eq!(removed.len(), 3); + let middle = three.tabs[1].id; + let right = three.active_tab; + + // Closing an inactive tab leaves the current tab and its shell focused. + send(&mut client, ClientMessage::Close { id: first }); + let two = list_after_commands(&mut client); + assert_eq!(two.tabs, three.tabs[1..]); + assert_eq!(two.active_tab, right); + for &id in removed { + send( + &mut client, + ClientMessage::Input { + pane: id, + bytes: vec![], + }, + ); + } + send(&mut client, ClientMessage::Ping); + let mut missing = 0; + loop { + match protocol::read_message(&mut client).unwrap() { + ServerMessage::Error(error) if error.contains("unknown pane") => missing += 1, + ServerMessage::Pong => break, + _ => {} + } + } + assert_eq!(missing, removed.len()); + + send(&mut client, ClientMessage::Close { id: right }); + let one = list_after_commands(&mut client); + assert_eq!(one.active_tab, middle); + assert_eq!(one.panes[0].id, three.tabs[1].active_pane); + send(&mut client, ClientMessage::Close { id: middle }); + let empty = list_after_commands(&mut client); + assert!(empty.tabs.is_empty()); + assert_eq!(empty.active_tab, 0); + } + #[test] fn natural_shell_exit_removes_panes_and_empty_tabs_without_stealing_focus() { let server = TestServer::start(); diff --git a/src/server/remote.rs b/src/server/remote.rs index 1376b30..2e376d4 100644 --- a/src/server/remote.rs +++ b/src/server/remote.rs @@ -366,23 +366,33 @@ impl SessionState { ); } - pub(super) fn cancel_pending_tab(&mut self, tab: TabId) -> Result<()> { - if self + pub(super) fn detach_remote(&mut self, tab: TabId) -> Result> { + let (&group, remote) = self .remotes - .get(&tab) - .is_some_and(|remote| remote.latest.is_none()) + .iter() + .find(|(_, remote)| remote.owns_tab(tab)) + .context("tab is not attached to an SSH session")?; + // A nested SSH tab is owned by the upstream workspace. Detach it + // there so the enclosing SSH session and its other tabs stay open. + if let Some(frame) = &remote.latest + && let Some(id) = original(&remote.tabs, tab) + && frame.tabs.iter().any(|t| t.id == id && t.remote.is_some()) { - self.remove_remote(tab); - return Ok(()); + remote.send(ClientMessage::DetachRemote { tab: id })?; + return Ok(None); } - if let Some((remote, id)) = self - .remotes - .values() - .find_map(|remote| original(&remote.tabs, tab).map(|id| (remote, id))) - { - return remote.send(ClientMessage::ClosePendingTab { tab: id }); - } - anyhow::bail!("SSH tab is no longer connecting") + let target = remote.connection.as_ref().and_then(|client| { + let identity = client + .remote_identity() + .or_else(|| remote.latest.as_ref()?.lineage.first().copied())?; + Some(DetachedRemote { + destination: remote.destination.clone(), + identity, + executable: client.remote_executable().map(str::to_owned), + }) + }); + self.remove_remote(group); + Ok(target) } fn remove_remote(&mut self, group: u64) { @@ -467,7 +477,7 @@ impl SessionState { | Copy { pane } | Scroll { pane, .. } | Split { pane, .. } - | ClosePane { pane } + | Close { id: pane } | RenamePane { pane, .. } => self.remote_pane(*pane).map(|(remote, original)| { *pane = original; remote @@ -620,11 +630,103 @@ mod tests { } } + #[test] + fn detaching_a_mirror_keeps_its_tabs_and_live_shell_for_reattach() { + use super::super::tests::contains; + let upstream = super::super::tests::TestServer::start(); + let (client, updates) = Transport::connect( + &upstream.socket, + None, + SessionTarget::New { cwd: None }, + SshOptions::default(), + ) + .unwrap(); + let receive = receive_updates(updates); + client.send(ClientMessage::NewTab { cwd: None }).unwrap(); + let before = next_frame(&receive, |frame| frame.tabs.len() == 2); + let pane = before.active_tab().unwrap().active_pane; + client + .send(ClientMessage::Input { + pane, + bytes: b"psyterm_check=alive; printf 'SET_%s\\n' DONE\n".to_vec(), + }) + .unwrap(); + next_frame(&receive, |frame| contains(frame, "SET_DONE")); + + let mut local = session(1); + local.new_tab(None).unwrap(); + let origin = local.active_tab; + let group = reserve(&mut local, 0); + local.remotes.get_mut(&group).unwrap().connection = Some(client); + apply(&mut local, group, (*before).clone()).unwrap(); + assert!(local.detach_remote(origin).is_err()); + local.focus_tab(origin).unwrap(); + let clicked = local.tabs[1].id; + assert_ne!(clicked, group); + let target = local.detach_remote(clicked).unwrap().unwrap(); + assert_eq!(target.destination, "user@work"); + assert_eq!(target.identity, before.lineage[0]); + assert_eq!(local.tabs.len(), 1); + assert_eq!(local.active_tab, origin); + + let (resumed, updates) = Transport::connect( + &upstream.socket, + None, + SessionTarget::Remembered(target.identity), + SshOptions::default(), + ) + .unwrap(); + let receive = receive_updates(updates); + let restored = next_frame(&receive, |_| true); + assert_eq!(restored.tabs.len(), 2); + assert_eq!(restored.active_tab, before.active_tab); + resumed + .send(ClientMessage::Input { + pane, + bytes: b"printf 'REATTACHED_%s\\n' \"$psyterm_check\"\n".to_vec(), + }) + .unwrap(); + next_frame(&receive, |frame| contains(frame, "REATTACHED_alive")); + + // A replacement daemon can allocate the same session and pane + // numbers. Refuse its input channel even if the numeric attach succeeds. + let replacement = super::super::tests::TestServer::start(); + let (_other, updates) = Transport::connect( + &replacement.socket, + None, + SessionTarget::New { cwd: None }, + SshOptions::default(), + ) + .unwrap(); + let other = next_frame(&receive_updates(updates), |_| true).lineage[0]; + assert_eq!(other.session, target.identity.session); + assert_ne!(other.server, target.identity.server); + let error = Transport::connect( + &replacement.socket, + None, + SessionTarget::Remembered(target.identity), + SshOptions::default(), + ) + .err() + .expect("refuse a recycled session ID"); + assert!( + error + .to_string() + .contains("remembered remote session has ended"), + "{error:#}" + ); + } + #[test] fn stacked_remote_focus_publishes_matching_grids_while_requests_are_in_flight() { let upstream = super::super::tests::TestServer::start(); - let (client, updates) = - Transport::connect(&upstream.socket, None, SessionTarget::New { cwd: None }).unwrap(); + let (client, updates) = Transport::connect( + &upstream.socket, + None, + SessionTarget::New { cwd: None }, + SshOptions::default(), + ) + .unwrap(); let receive = receive_updates(updates); for _ in 0..3 { client @@ -690,6 +792,59 @@ mod tests { assert_eq!(frame.panes[0].id, top); } + #[test] + fn discarded_ssh_frame_keeps_the_mounted_workspace_and_accepts_the_next_frame() { + let mut upstream = session(2); + upstream.new_tab(None).unwrap(); + let mut local = session(1); + local.new_tab(None).unwrap(); + let origin = local.active_tab; + let group = reserve(&mut local, 0); + apply(&mut local, group, upstream.snapshot()).unwrap(); + let id = local.id; + let mut server = Server { + identity: local.identity.server, + socket: local.socket.clone(), + shell: None, + sender: local.sender.clone(), + sessions: BTreeMap::from([(id, local)]), + clients: HashMap::new(), + next_session: id + 1, + last_detached_remote: None, + last_frame: Instant::now(), + last_cwd_refresh: Instant::now(), + }; + server.remote_event( + id, + group, + RemoteEvent::Updated(Update { + error: Some("Discarded workspace update: invalid terminal grid".into()), + ..Update::default() + }), + ); + assert_eq!(server.sessions[&id].active_tab, group); + upstream.new_tab(None).unwrap(); + server.remote_event( + id, + group, + RemoteEvent::Updated(Update { + snapshot: Some(Arc::new(upstream.snapshot())), + ..Update::default() + }), + ); + assert_eq!(server.sessions[&id].remotes[&group].tabs.len(), 2); + server.remote_event( + id, + group, + RemoteEvent::Updated(Update { + disconnected: true, + ..Update::default() + }), + ); + assert_eq!(server.sessions[&id].active_tab, origin); + assert!(!server.sessions[&id].remotes.contains_key(&group)); + } + #[test] fn remote_ids_remain_stable_and_do_not_collide_with_local_tabs_or_other_mirrors() { let mut local = session(1); @@ -702,6 +857,13 @@ mod tests { let group = reserve(&mut local, 0); assert_eq!(local.active_tab, group); assert!(local.snapshot().panes.is_empty()); + let output = Arc::new(Outbox::default()); + assert!( + local + .command(ClientMessage::Close { id: group }, &output) + .is_err() + ); + assert!(local.remotes.contains_key(&group)); remote.new_tab(None).unwrap(); remote.new_tab(None).unwrap(); // The peers allocated exactly the same tab/pane IDs. @@ -720,6 +882,12 @@ mod tests { assert_eq!(local.snapshot().panes[0].id, remote_pane); assert_ne!(remote_pane, right.active_pane); let first_remote = local.tabs[1].id; + assert!( + local + .command(ClientMessage::Close { id: first_remote }, &output) + .is_err() + ); + assert!(local.remotes.contains_key(&group)); local.focus_tab(left.id).unwrap(); let second = reserve(&mut local, 0); apply(&mut local, second, remote.snapshot()).unwrap(); @@ -753,8 +921,13 @@ mod tests { #[test] fn copies_from_different_views_are_serialized_and_disconnect_completes_waiters() { let upstream = super::super::tests::TestServer::start(); - let (client, updates) = - Transport::connect(&upstream.socket, None, SessionTarget::New { cwd: None }).unwrap(); + let (client, updates) = Transport::connect( + &upstream.socket, + None, + SessionTarget::New { cwd: None }, + SshOptions::default(), + ) + .unwrap(); let receive = receive_updates(updates); let mut local = session(1); local.new_tab(None).unwrap(); @@ -817,7 +990,7 @@ mod tests { .to_string() .contains("inside itself") ); - local.cancel_pending_tab(group).unwrap(); + assert_eq!(local.detach_remote(group).unwrap(), None); assert!(cancelled.load(Ordering::Acquire)); assert_eq!(local.active_tab, anchor); assert_eq!(local.tabs.len(), 1); diff --git a/src/terminal.rs b/src/terminal.rs index d08f7cc..c624e22 100644 --- a/src/terminal.rs +++ b/src/terminal.rs @@ -137,7 +137,7 @@ impl Workspace { cx.notify(); }); } - let items = commands::root_items(self.snapshot.as_deref()); + let items = commands::root_items(self.snapshot.as_deref(), self.client.remote().is_some()); let owner = cx.weak_entity(); self.palette = Some(cx.new(|cx| { CommandPalette::new( @@ -204,6 +204,28 @@ impl Workspace { .detach(); } + fn close_tab(&mut self, id: u64, window: &mut Window, cx: &mut Context) { + let Some(tab) = self + .snapshot + .as_ref() + .and_then(|s| s.tabs.iter().find(|tab| tab.id == id)) + else { + return; + }; + let message = if tab.remote.is_some() { + ClientMessage::DetachRemote { tab: id } + } else if self.client.remote().is_some() { + window.remove_window(); + return; + } else { + ClientMessage::Close { id } + }; + if let Err(error) = self.client.send(message) { + self.error = Some(error.to_string()); + cx.notify(); + } + } + fn execute(&mut self, action: CommandAction, window: &mut Window, cx: &mut Context) { use CommandAction::*; let pane = self.focused_pane(); @@ -253,13 +275,11 @@ impl Workspace { Direction::Down }, }), - ClosePane => pane_id - .map(|pane| ClientMessage::ClosePane { pane }) - .or_else(|| { - let tab = self.snapshot.as_deref()?.active_tab()?; - tab.is_connecting() - .then_some(ClientMessage::ClosePendingTab { tab: tab.id }) - }), + ClosePane => pane_id.map(|id| ClientMessage::Close { id }).or_else(|| { + let tab = self.snapshot.as_deref()?.active_tab()?; + tab.is_connecting() + .then_some(ClientMessage::DetachRemote { tab: tab.id }) + }), ResetPaneName => pane_id.map(|pane| ClientMessage::RenamePane { pane, name: None }), ResetTabName => self .snapshot @@ -311,6 +331,17 @@ impl Workspace { } None } + DetachRemote => { + let tab = self.snapshot.as_deref().and_then(Snapshot::active_tab); + if let Some(tab) = tab.filter(|tab| tab.remote.is_some()) { + Some(ClientMessage::DetachRemote { tab: tab.id }) + } else { + if self.client.remote().is_some() { + window.remove_window(); + } + None + } + } Detach => { window.remove_window(); None @@ -455,7 +486,10 @@ impl Workspace { view.snapshot = Some(snapshot); if let Some(palette) = &view.palette { if metadata_changed { - let items = commands::root_items(view.snapshot.as_deref()); + let items = commands::root_items( + view.snapshot.as_deref(), + view.client.remote().is_some(), + ); palette .update(cx, |palette, cx| palette.set_items(items, cx)); } @@ -543,12 +577,16 @@ impl Render for Workspace { .unwrap_or_default(); let client = self.client.clone(); let new_client = self.client.clone(); + let owner = cx.weak_entity(); let header = chrome::header( tabs, cfg!(target_os = "macos") && !window.is_fullscreen(), move |tab, _, _| { let _ = client.send(ClientMessage::FocusTab { tab }); }, + move |tab, window, cx| { + let _ = owner.update(cx, |view, cx| view.close_tab(tab, window, cx)); + }, move |_, _| { let _ = new_client.send(ClientMessage::NewTab { cwd: None }); },