Close local tabs and detach or reattach live SSH sessions

Remember the remote daemon and session identity for hostless reattachment. Keep other tabs usable after a discarded snapshot and preserve the last live detach target when a remote shell exits. Reject remote flags for local daemon control commands.
This commit is contained in:
James Magahern
2026-11-17 16:15:28 -08:00
parent f2390ca9b4
commit 153838061e
12 changed files with 874 additions and 162 deletions
+19
View File
@@ -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` | Open a new local session in a new window |
| `psyterm --attach [ID]` | Open a window on an existing session | | `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 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 --remote user@host --attach [ID]` | Reattach to an existing session on the SSH host |
| `psyterm --gui` | Run the GUI in the current process | | `psyterm --gui` | Run the GUI in the current process |
| `psyterm --list` | Show local sessions, attached window counts, tabs, and panes | | `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 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. 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 SSH uses `BatchMode=yes`. Configure key or agent authentication and trust the
host key before connecting. The remote host needs a compatible `psyterm` host key before connecting. The remote host needs a compatible `psyterm`
executable on its noninteractive SSH `PATH`. To use a different path, set 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 | | 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. 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 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 the mouse wheel or touchpad. Closing the window detaches the GUI and keeps the
server sessions running. server sessions running.
+1 -1
View File
@@ -207,7 +207,7 @@ mod tests {
use crate::commands::{PaletteItemKind, root_items}; use crate::commands::{PaletteItemKind, root_items};
use std::mem::discriminant; 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) let (Some(hint), PaletteItemKind::Action(expected)) = (item.shortcut, &item.kind)
else { else {
continue; continue;
+41 -3
View File
@@ -39,15 +39,16 @@ pub struct ChromeTab {
} }
/// An app-owned titlebar. Callbacks issue server commands; no tab state lives here. /// 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( pub fn header(
tabs: Vec<ChromeTab>, tabs: Vec<ChromeTab>,
reserve_traffic_lights: bool, reserve_traffic_lights: bool,
on_tab: impl Fn(u64, &mut Window, &mut App) + 'static, 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_new: impl Fn(&mut Window, &mut App) + 'static,
on_close: impl Fn(&mut Window, &mut App) + 'static, on_close: impl Fn(&mut Window, &mut App) + 'static,
) -> Div { ) -> Div {
let on_tab = Rc::new(on_tab); let on_tab = Rc::new(on_tab);
let on_close_tab = Rc::new(on_close_tab);
let mut tab_strip = div() let mut tab_strip = div()
.flex() .flex()
.items_center() .items_center()
@@ -58,9 +59,11 @@ pub fn header(
.overflow_hidden(); .overflow_hidden();
for tab in tabs { for tab in tabs {
let on_tab = on_tab.clone(); let on_tab = on_tab.clone();
let on_close_tab = on_close_tab.clone();
let active = tab.active; let active = tab.active;
let id = tab.id; 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) (PANE_FOCUS, 0x102d28, 0x112720, 0x285749)
} else { } else {
(ACCENT, ACTIVE_BACKGROUND, HOVER_BACKGROUND, BORDER) (ACCENT, ACTIVE_BACKGROUND, HOVER_BACKGROUND, BORDER)
@@ -98,6 +101,7 @@ pub fn header(
tab_strip = tab_strip.child( tab_strip = tab_strip.child(
div() div()
.id(ElementId::Name(format!("tab-{id}").into())) .id(ElementId::Name(format!("tab-{id}").into()))
.group("tab")
.flex() .flex()
.items_center() .items_center()
.gap(px(7.)) .gap(px(7.))
@@ -106,6 +110,7 @@ pub fn header(
.flex_shrink() .flex_shrink()
.min_w_0() .min_w_0()
.max_w(px(200.)) .max_w(px(200.))
.overflow_hidden()
.px(px(10.)) .px(px(10.))
.border_1() .border_1()
.border_color(rgb(if active { .border_color(rgb(if active {
@@ -134,7 +139,23 @@ pub fn header(
.h(px(if active { 22. } else { 12. })) .h(px(if active { 22. } else { 12. }))
.bg(rgb(accent)), .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<Self>) -> 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. /// Keep SSH aliases as entered, omitting user, URI port and IPv6 brackets.
fn remote_hostname(destination: &str) -> &str { fn remote_hostname(destination: &str) -> &str {
let uri = destination.strip_prefix("ssh://"); let uri = destination.strip_prefix("ssh://");
@@ -264,6 +301,7 @@ mod tests {
], ],
cfg!(target_os = "macos"), cfg!(target_os = "macos"),
|_, _, _| {}, |_, _, _| {},
|_, _, _| {},
|_, _| {}, |_, _| {},
|_, _| {}, |_, _| {},
); );
+280 -74
View File
@@ -1,6 +1,8 @@
//! Display-only client transport. No terminal parser, PTY, or shell lives here. //! Display-only client transport. No terminal parser, PTY, or shell lives here.
use crate::protocol::{self, ClientMessage, ServerMessage, SessionTarget, Snapshot, SshOptions}; use crate::protocol::{
use anyhow::{Context, Result, bail}; self, ClientMessage, ServerMessage, SessionIdentity, SessionTarget, Snapshot, SshOptions,
};
use anyhow::{Context, Result, bail, ensure};
use std::{ use std::{
collections::{HashSet, VecDeque}, collections::{HashSet, VecDeque},
io::{self, Read, Write}, io::{self, Read, Write},
@@ -42,10 +44,18 @@ impl Updates {
} }
#[derive(Clone)] #[derive(Clone)]
pub struct Client(Arc<Connection>); pub struct Client {
connection: Arc<Connection>,
remote_session: Option<Arc<RemoteSession>>,
}
struct RemoteSession {
identity: SessionIdentity,
live: AtomicBool,
}
struct Connection { struct Connection {
launcher_socket: PathBuf, launcher_socket: PathBuf,
remote: Option<String>, remote: Option<String>,
remote_executable: Option<String>,
commands: mpsc::Sender<ClientMessage>, commands: mpsc::Sender<ClientMessage>,
socket: Option<UnixStream>, socket: Option<UnixStream>,
ssh: Mutex<Option<Child>>, ssh: Mutex<Option<Child>>,
@@ -90,14 +100,9 @@ impl Client {
launcher_socket: &Path, launcher_socket: &Path,
remote: Option<&str>, remote: Option<&str>,
session: SessionTarget, session: SessionTarget,
options: SshOptions,
) -> Result<(Self, Updates)> { ) -> Result<(Self, Updates)> {
Self::connect_with( Self::connect_with(launcher_socket, remote, session, options, None)
launcher_socket,
remote,
session,
SshOptions::from_env(),
None,
)
} }
pub fn connect_remote( pub fn connect_remote(
@@ -123,6 +128,13 @@ impl Client {
options: SshOptions, options: SshOptions,
cancelled: Option<Arc<AtomicBool>>, cancelled: Option<Arc<AtomicBool>>,
) -> Result<(Self, Updates)> { ) -> 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<dyn Write + Send>, _, _) = let (mut reader, mut writer, socket, mut ssh): (_, Box<dyn Write + Send>, _, _) =
if let Some(remote) = remote { if let Some(remote) = remote {
validate_destination(remote)?; validate_destination(remote)?;
@@ -175,13 +187,14 @@ impl Client {
let (commands, receive) = mpsc::channel(); let (commands, receive) = mpsc::channel();
let (signal, notifications) = async_channel::bounded(1); let (signal, notifications) = async_channel::bounded(1);
let pending = Arc::new(Mutex::new(Update::default())); 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(), launcher_socket: launcher_socket.to_owned(),
remote: remote.map(str::to_owned), remote: remote.map(str::to_owned),
remote_executable: options.executable,
commands, commands,
socket, socket,
ssh: Mutex::new(ssh), ssh: Mutex::new(ssh),
})); });
let diagnostic = stderr.map(ssh_diagnostics).transpose()?; let diagnostic = stderr.map(ssh_diagnostics).transpose()?;
reader.set_read_timeout(Some(Duration::from_millis(150)))?; reader.set_read_timeout(Some(Duration::from_millis(150)))?;
let mut greeting = GreetingReader { let mut greeting = GreetingReader {
@@ -189,15 +202,34 @@ impl Client {
deadline: Instant::now() + Duration::from_secs(if remote.is_some() { 30 } else { 5 }), deadline: Instant::now() + Duration::from_secs(if remote.is_some() { 30 } else { 5 }),
cancelled: cancelled.as_deref(), cancelled: cancelled.as_deref(),
}; };
if let Err(error) = greet(&mut greeting, &mut writer, session) { let first_frame = match greet(
drop(connection); &mut greeting,
if let Some(detail) = diagnostic &mut writer,
.and_then(|rx| rx.recv_timeout(Duration::from_millis(150)).ok()) session,
.filter(|s| !s.is_empty()) remote.is_some(),
{ expected,
bail!("{error:#}: {detail}"); ) {
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)?; reader.set_read_timeout(None)?;
let errors = pending.clone(); let errors = pending.clone();
@@ -215,57 +247,15 @@ impl Client {
} }
})?; })?;
let incoming = pending.clone(); let incoming = pending.clone();
let reader_session = remote_session.clone();
thread::Builder::new() thread::Builder::new()
.name("psyterm-client-reader".into()) .name("psyterm-client-reader".into())
.spawn(move || { .spawn(move || read_updates(reader, &incoming, signal, reader_session.as_deref()))?;
let mut reader = reader;
loop {
let message = protocol::read_message::<ServerMessage>(&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(());
}
})?;
Ok(( Ok((
connection, Self {
connection,
remote_session,
},
Updates { Updates {
signal: notifications, signal: notifications,
pending, pending,
@@ -274,13 +264,42 @@ impl Client {
} }
pub fn remote(&self) -> Option<&str> { pub fn remote(&self) -> Option<&str> {
self.0.remote.as_deref() self.connection.remote.as_deref()
}
pub fn remote_identity(&self) -> Option<SessionIdentity> {
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. /// Launch through the local daemon even when this terminal connects over SSH.
pub fn open_window(&self, remote: Option<String>, cwd: Option<String>) -> Result<()> { pub fn open_window(&self, remote: Option<String>, cwd: Option<String>) -> Result<()> {
crate::launcher::control( crate::launcher::control(
&self.0.launcher_socket, &self.connection.launcher_socket,
ClientMessage::OpenWindow { ClientMessage::OpenWindow {
target: remote, target: remote,
session: SessionTarget::New { cwd }, session: SessionTarget::New { cwd },
@@ -290,7 +309,7 @@ impl Client {
} }
pub fn send(&self, message: ClientMessage) -> Result<()> { pub fn send(&self, message: ClientMessage) -> Result<()> {
self.0 self.connection
.commands .commands
.send(message) .send(message)
.context("server transport is closed") .context("server transport is closed")
@@ -306,6 +325,66 @@ impl Client {
} }
} }
fn read_updates(
mut reader: impl Read,
pending: &Mutex<Update>,
signal: async_channel::Sender<()>,
remote_session: Option<&RemoteSession>,
) {
loop {
let message = protocol::read_message::<ServerMessage>(&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 /// 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. /// startup failures in the invoking window as well as in the daemon log.
fn ssh_diagnostics(mut stderr: ChildStderr) -> io::Result<mpsc::Receiver<String>> { fn ssh_diagnostics(mut stderr: ChildStderr) -> io::Result<mpsc::Receiver<String>> {
@@ -383,7 +462,9 @@ fn greet(
reader: &mut GreetingReader<'_>, reader: &mut GreetingReader<'_>,
writer: &mut impl Write, writer: &mut impl Write,
session: SessionTarget, session: SessionTarget,
) -> Result<()> { from_ssh: bool,
expected: Option<SessionIdentity>,
) -> Result<Option<Snapshot>> {
reader.check()?; reader.check()?;
protocol::write_message( protocol::write_message(
writer, writer,
@@ -398,11 +479,37 @@ fn greet(
} }
reader.check()?; reader.check()?;
protocol::write_message(writer, &ClientMessage::Connect(session))?; protocol::write_message(writer, &ClientMessage::Connect(session))?;
match protocol::read_message::<ServerMessage>(reader)? { let session = match protocol::read_message::<ServerMessage>(reader)? {
ServerMessage::Connected { .. } => Ok(()), ServerMessage::Connected { session } => session,
ServerMessage::Error(error) => bail!("{error}"), ServerMessage::Error(error) => bail!("{error}"),
_ => bail!("server did not acknowledge the session"), _ => 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::<ServerMessage>(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 { 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)] #[cfg(test)]
mod tests { mod tests {
use super::*; 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] #[test]
fn binary_bridge_flushes_without_newlines() { fn binary_bridge_flushes_without_newlines() {
struct Output { struct Output {
+17 -2
View File
@@ -32,6 +32,7 @@ pub enum CommandAction {
FocusTab(u64), FocusTab(u64),
FocusPane(u64), FocusPane(u64),
Scroll(ScrollKind), Scroll(ScrollKind),
DetachRemote,
Detach, 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. /// The complete command list. UI state affects availability, never discovery.
pub fn root_items(snapshot: Option<&Snapshot>) -> Vec<PaletteItem> { pub fn root_items(snapshot: Option<&Snapshot>, remote_window: bool) -> Vec<PaletteItem> {
use CommandAction::*; use CommandAction::*;
let pane = snapshot.is_some_and(|s| !s.panes.is_empty()); let pane = snapshot.is_some_and(|s| !s.panes.is_empty());
let tabs = snapshot.is_some_and(|s| !s.tabs.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<PaletteItem> {
Scroll(ScrollKind::Bottom), Scroll(ScrollKind::Bottom),
) )
.available(pane), .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( PaletteItem::action(
"detach", "detach",
"Detach window", "Detach window",
@@ -382,10 +396,11 @@ mod tests {
#[test] #[test]
fn empty_workspace_keeps_commands_discoverable_without_unsafe_actions() { 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(); let find = |id: &str| items.iter().find(|item| item.id == id).unwrap();
assert!(find("new-tab").enabled); assert!(find("new-tab").enabled);
assert!(find("detach").enabled); assert!(find("detach").enabled);
assert!(!find("detach-remote").enabled);
assert!(!find("close-pane").enabled); assert!(!find("close-pane").enabled);
assert!(!find("switch-tab").enabled); assert!(!find("switch-tab").enabled);
assert!(find("reset-pane-name").shortcut.is_none()); assert!(find("reset-pane-name").shortcut.is_none());
+7 -3
View File
@@ -170,9 +170,10 @@ fn control_stream_version(
loop { loop {
let message: ServerMessage = protocol::read_message(&mut stream)?; let message: ServerMessage = protocol::read_message(&mut stream)?;
match message { match message {
ServerMessage::Pong | ServerMessage::Closing | ServerMessage::Sessions(_) => { ServerMessage::Pong
return Ok(message); | ServerMessage::Closing
} | ServerMessage::Sessions(_)
| ServerMessage::DetachedRemote(_) => return Ok(message),
ServerMessage::Error(error) => bail!("{error}"), ServerMessage::Error(error) => bail!("{error}"),
_ => {} _ => {}
} }
@@ -246,6 +247,9 @@ pub fn open_window(
command.arg(id.to_string()); 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 { if let Some(host) = remote {
command.arg("--remote").arg(host); command.arg("--remote").arg(host);
+8 -2
View File
@@ -257,8 +257,14 @@ pub fn run_zygote(socket: &Path) -> Result<()> {
} }
drop(stream); drop(stream);
drop(listener); drop(listener);
let result = set_child_reaping(false) let result = set_child_reaping(false).and_then(|()| {
.and_then(|()| crate::run_gui(server_socket, remote, session)); crate::run_gui(
server_socket,
remote,
session,
protocol::SshOptions::from_env(),
)
});
let code = if let Err(error) = result { let code = if let Err(error) = result {
log::error!("GUI startup failed: {error:#}"); log::error!("GUI startup failed: {error:#}");
1 1
+70 -21
View File
@@ -17,7 +17,7 @@ mod session;
mod terminal; mod terminal;
mod transition; mod transition;
use anyhow::{Result, bail}; use anyhow::{Context as _, Result, bail};
use gpui::{prelude::*, *}; use gpui::{prelude::*, *};
use protocol::{SessionId, SessionTarget}; use protocol::{SessionId, SessionTarget};
use std::path::PathBuf; use std::path::PathBuf;
@@ -66,14 +66,11 @@ fn main() -> Result<()> {
)) ))
} }
"--remote" => { "--remote" => {
remote = Some( remote = Some(args.next_if(|arg| !arg.starts_with('-')));
args.next_if(|arg| !arg.starts_with('-'))
.ok_or_else(|| anyhow::anyhow!("--remote needs an SSH destination"))?,
)
} }
"--help" | "-h" => { "--help" | "-h" => {
println!( 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(()); return Ok(());
} }
@@ -83,6 +80,12 @@ fn main() -> Result<()> {
if attach.is_some() && !matches!(role, "gui" | "launch" | "bridge") { if attach.is_some() && !matches!(role, "gui" | "launch" | "bridge") {
bail!("--attach applies to a window or an SSH 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")] #[cfg(target_os = "macos")]
if matches!(role, "launch" | "gui") if matches!(role, "launch" | "gui")
&& unsafe { libc::getppid() } == 1 && unsafe { libc::getppid() } == 1
@@ -92,7 +95,48 @@ fn main() -> Result<()> {
// Finder launches the bundled process from the filesystem root. // Finder launches the bundled process from the filesystem root.
std::env::set_current_dir(home)?; 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) SessionTarget::Attach(id)
} else { } else {
SessionTarget::New { SessionTarget::New {
@@ -105,29 +149,20 @@ fn main() -> Result<()> {
}, },
} }
}; };
if role == "launch" if let (Some(destination), Some(origin)) = (&remote, origin) {
&& 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");
}
launcher::control( launcher::control(
&origin.socket, &socket,
protocol::ClientMessage::OpenRemoteTab { protocol::ClientMessage::OpenRemoteTab {
session: origin.session, session: origin.session,
pane: origin.pane, pane: origin.pane,
destination: destination.clone(), destination: destination.clone(),
target: session, target: session,
ssh: protocol::SshOptions::from_env(), ssh,
}, },
)?; )?;
return Ok(()); return Ok(());
} }
let socket = socket.map(Ok).unwrap_or_else(launcher::default_socket)?;
match role { match role {
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
"server" => server::run(&socket, |remote, session| { "server" => server::run(&socket, |remote, session| {
@@ -157,7 +192,7 @@ fn main() -> Result<()> {
} else { } else {
launcher::ensure_server(&socket)?; launcher::ensure_server(&socket)?;
} }
run_gui(socket, remote, session) run_gui(socket, remote, session, ssh)
} }
"bridge" => client::bridge(&socket, attach.is_some()), "bridge" => client::bridge(&socket, attach.is_some()),
"shutdown" => { "shutdown" => {
@@ -210,9 +245,23 @@ pub(crate) fn run_gui(
socket: PathBuf, socket: PathBuf,
remote: Option<String>, remote: Option<String>,
session: SessionTarget, session: SessionTarget,
ssh: protocol::SshOptions,
) -> Result<()> { ) -> 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| { 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")] #[cfg(target_os = "macos")]
{ {
cx.on_action(|_: &Quit, cx| cx.quit()); cx.on_action(|_: &Quit, cx| cx.quit());
+27 -4
View File
@@ -24,8 +24,13 @@ pub struct SessionIdentity {
#[derive(Debug, Clone, Serialize, Deserialize)] #[derive(Debug, Clone, Serialize, Deserialize)]
pub enum SessionTarget { pub enum SessionTarget {
New { cwd: Option<String> }, New {
cwd: Option<String>,
},
Attach(Option<SessionId>), Attach(Option<SessionId>),
/// 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. /// SSH settings inherited from the shell that requested a remote tab.
@@ -35,6 +40,14 @@ pub struct SshOptions {
pub agent_socket: Option<std::path::PathBuf>, pub agent_socket: Option<std::path::PathBuf>,
} }
/// 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<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)] #[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SessionInfo { pub struct SessionInfo {
pub id: SessionId, pub id: SessionId,
@@ -84,8 +97,10 @@ pub enum ClientMessage {
FocusPane { FocusPane {
pane: PaneId, pane: PaneId,
}, },
ClosePane { /// Close a pane or an entire local tab. Pane and tab IDs are allocated
pane: PaneId, /// from the same sequence. Older v6 daemons only recognize pane IDs here.
Close {
id: u64,
}, },
OpenWindow { OpenWindow {
target: Option<String>, target: Option<String>,
@@ -137,9 +152,16 @@ pub enum ClientMessage {
target: SessionTarget, target: SessionTarget,
ssh: SshOptions, 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, tab: TabId,
}, },
/// Local launcher requests used to reopen a detached SSH connection.
LastDetachedRemote {
origin: Option<SessionIdentity>,
},
RememberDetachedRemote(DetachedRemote),
} }
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
@@ -205,6 +227,7 @@ pub enum ServerMessage {
Closing, Closing,
Connected { session: SessionId }, Connected { session: SessionId },
Sessions(Vec<SessionInfo>), Sessions(Vec<SessionInfo>),
DetachedRemote(DetachedRemote),
} }
#[derive(Debug, Clone, Serialize, Deserialize)] #[derive(Debug, Clone, Serialize, Deserialize)]
+164 -23
View File
@@ -236,6 +236,7 @@ fn run_with_shell(
shell, shell,
clients: HashMap::new(), clients: HashMap::new(),
sessions: BTreeMap::new(), sessions: BTreeMap::new(),
last_detached_remote: None,
next_session: 1, next_session: 1,
sender, sender,
last_frame: Instant::now() - FRAME_INTERVAL, last_frame: Instant::now() - FRAME_INTERVAL,
@@ -290,6 +291,7 @@ struct Server {
socket: PathBuf, socket: PathBuf,
shell: Option<Shell>, shell: Option<Shell>,
sessions: BTreeMap<SessionId, SessionState>, sessions: BTreeMap<SessionId, SessionState>,
last_detached_remote: Option<DetachedRemote>,
next_session: SessionId, next_session: SessionId,
clients: HashMap<u64, Client>, clients: HashMap<u64, Client>,
sender: mpsc::SyncSender<Action>, sender: mpsc::SyncSender<Action>,
@@ -301,6 +303,7 @@ struct SessionState {
identity: SessionIdentity, identity: SessionIdentity,
socket: PathBuf, socket: PathBuf,
remotes: HashMap<u64, remote::RemoteSession>, remotes: HashMap<u64, remote::RemoteSession>,
last_detached_remote: Option<DetachedRemote>,
id: SessionId, id: SessionId,
last_used: Instant, last_used: Instant,
shell: Option<Shell>, shell: Option<Shell>,
@@ -523,6 +526,9 @@ impl Server {
ensure!(client.session.is_none(), "client already has a session"); ensure!(client.session.is_none(), "client already has a session");
let session_id = match target { let session_id = match target {
SessionTarget::Attach(id) => self.attach_target(id)?, SessionTarget::Attach(id) => self.attach_target(id)?,
SessionTarget::Remembered(_) => {
anyhow::bail!("expected a resolved session target")
}
SessionTarget::New { cwd } => { SessionTarget::New { cwd } => {
let id = self.next_session; let id = self.next_session;
self.next_session += 1; self.next_session += 1;
@@ -599,6 +605,39 @@ impl Server {
open_window(target, session)?; open_window(target, session)?;
self.clients[&id].output.reliable(ServerMessage::Pong); 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), ClientMessage::Detach => self.remove_client(id),
message => { message => {
let session = self let session = self
@@ -625,6 +664,7 @@ impl SessionState {
identity, identity,
socket, socket,
remotes: HashMap::new(), remotes: HashMap::new(),
last_detached_remote: None,
last_used: Instant::now(), last_used: Instant::now(),
shell, shell,
panes: HashMap::new(), panes: HashMap::new(),
@@ -827,11 +867,19 @@ impl SessionState {
ClientMessage::FocusPane { pane } => { ClientMessage::FocusPane { pane } => {
self.focus_pane(pane)?; self.focus_pane(pane)?;
} }
ClientMessage::ClosePendingTab { tab } => { ClientMessage::Close { id } => {
self.cancel_pending_tab(tab)?; if !self.remove_pane(id) {
} let index = self
ClientMessage::ClosePane { pane } => { .tabs
ensure!(self.remove_pane(pane), "unknown pane"); .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 } => { ClientMessage::RenamePane { pane, name } => {
self.pane_mut(pane)?.manual_title = name.and_then(clean_title); self.pane_mut(pane)?.manual_title = name.and_then(clean_title);
@@ -854,6 +902,9 @@ impl SessionState {
| ClientMessage::ListSessions | ClientMessage::ListSessions
| ClientMessage::OpenWindow { .. } | ClientMessage::OpenWindow { .. }
| ClientMessage::OpenRemoteTab { .. } | ClientMessage::OpenRemoteTab { .. }
| ClientMessage::DetachRemote { .. }
| ClientMessage::LastDetachedRemote { .. }
| ClientMessage::RememberDetachedRemote(_)
| ClientMessage::Detach => anyhow::bail!("expected a session command"), | ClientMessage::Detach => anyhow::bail!("expected a session command"),
} }
Ok(()) Ok(())
@@ -1013,25 +1064,34 @@ impl SessionState {
} }
flatten_panes(tab); flatten_panes(tab);
if tab.stacks.is_empty() { if tab.stacks.is_empty() {
let removed_tab = self.tabs.remove(tab_index); self.remove_local_tab(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.dirty = true; self.dirty = true;
// No terminal lock is held here. On Event::Exit the I/O thread has // 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. // drained output and will finish, so joining Session cleanup is safe.
drop(removed); drop(removed);
if self.active_tab != 0 {
let _ = self.focus_tab(self.active_tab);
}
true 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) { fn refresh_directories(&mut self) {
for pane in self.panes.values_mut() { for pane in self.panes.values_mut() {
if let Some(directory) = pane.session.working_directory() { if let Some(directory) = pane.session.working_directory() {
@@ -1417,7 +1477,7 @@ mod tests {
fn send(stream: &mut UnixStream, message: ClientMessage) { fn send(stream: &mut UnixStream, message: ClientMessage) {
protocol::write_message(stream, &message).unwrap(); 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| { snapshot.panes.iter().any(|pane| {
pane.cells pane.cells
.iter() .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] #[test]
fn new_sessions_isolate_live_shells_and_attach_selects_only_existing_work() { fn new_sessions_isolate_live_shells_and_attach_selects_only_existing_work() {
let server = TestServer::start(); let server = TestServer::start();
@@ -1502,12 +1585,7 @@ mod tests {
ServerMessage::Error(message) if message.contains("no such session")) ServerMessage::Error(message) if message.contains("no such session"))
); );
send( send(&mut mirror, ClientMessage::Close { id: b.panes[0].id });
&mut mirror,
ClientMessage::ClosePane {
pane: b.panes[0].id,
},
);
list_after_commands(&mut mirror); list_after_commands(&mut mirror);
assert_eq!( assert_eq!(
list(&mut control).iter().map(|s| s.id).collect::<Vec<_>>(), list(&mut control).iter().map(|s| s.id).collect::<Vec<_>>(),
@@ -2103,7 +2181,7 @@ mod tests {
assert_eq!(active_tab(&collapsed_exit).panes, [middle, bottom]); assert_eq!(active_tab(&collapsed_exit).panes, [middle, bottom]);
assert_eq!(collapsed_exit.panes[0].id, middle); assert_eq!(collapsed_exit.panes[0].id, middle);
// Explicit close uses the same adjacent fallback as natural exit. // 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); let closed = snapshot(&mut client, |s| active_tab(s).panes.len() == 1);
assert_eq!(closed.panes[0].id, bottom); assert_eq!(closed.panes[0].id, bottom);
send( send(
@@ -2123,6 +2201,69 @@ mod tests {
assert!(empty.panes.is_empty()); 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] #[test]
fn natural_shell_exit_removes_panes_and_empty_tabs_without_stealing_focus() { fn natural_shell_exit_removes_panes_and_empty_tabs_without_stealing_focus() {
let server = TestServer::start(); let server = TestServer::start();
+193 -20
View File
@@ -366,23 +366,33 @@ impl SessionState {
); );
} }
pub(super) fn cancel_pending_tab(&mut self, tab: TabId) -> Result<()> { pub(super) fn detach_remote(&mut self, tab: TabId) -> Result<Option<DetachedRemote>> {
if self let (&group, remote) = self
.remotes .remotes
.get(&tab) .iter()
.is_some_and(|remote| remote.latest.is_none()) .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); remote.send(ClientMessage::DetachRemote { tab: id })?;
return Ok(()); return Ok(None);
} }
if let Some((remote, id)) = self let target = remote.connection.as_ref().and_then(|client| {
.remotes let identity = client
.values() .remote_identity()
.find_map(|remote| original(&remote.tabs, tab).map(|id| (remote, id))) .or_else(|| remote.latest.as_ref()?.lineage.first().copied())?;
{ Some(DetachedRemote {
return remote.send(ClientMessage::ClosePendingTab { tab: id }); destination: remote.destination.clone(),
} identity,
anyhow::bail!("SSH tab is no longer connecting") executable: client.remote_executable().map(str::to_owned),
})
});
self.remove_remote(group);
Ok(target)
} }
fn remove_remote(&mut self, group: u64) { fn remove_remote(&mut self, group: u64) {
@@ -467,7 +477,7 @@ impl SessionState {
| Copy { pane } | Copy { pane }
| Scroll { pane, .. } | Scroll { pane, .. }
| Split { pane, .. } | Split { pane, .. }
| ClosePane { pane } | Close { id: pane }
| RenamePane { pane, .. } => self.remote_pane(*pane).map(|(remote, original)| { | RenamePane { pane, .. } => self.remote_pane(*pane).map(|(remote, original)| {
*pane = original; *pane = original;
remote 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] #[test]
fn stacked_remote_focus_publishes_matching_grids_while_requests_are_in_flight() { fn stacked_remote_focus_publishes_matching_grids_while_requests_are_in_flight() {
let upstream = super::super::tests::TestServer::start(); let upstream = super::super::tests::TestServer::start();
let (client, updates) = let (client, updates) = Transport::connect(
Transport::connect(&upstream.socket, None, SessionTarget::New { cwd: None }).unwrap(); &upstream.socket,
None,
SessionTarget::New { cwd: None },
SshOptions::default(),
)
.unwrap();
let receive = receive_updates(updates); let receive = receive_updates(updates);
for _ in 0..3 { for _ in 0..3 {
client client
@@ -690,6 +792,59 @@ mod tests {
assert_eq!(frame.panes[0].id, top); 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] #[test]
fn remote_ids_remain_stable_and_do_not_collide_with_local_tabs_or_other_mirrors() { fn remote_ids_remain_stable_and_do_not_collide_with_local_tabs_or_other_mirrors() {
let mut local = session(1); let mut local = session(1);
@@ -702,6 +857,13 @@ mod tests {
let group = reserve(&mut local, 0); let group = reserve(&mut local, 0);
assert_eq!(local.active_tab, group); assert_eq!(local.active_tab, group);
assert!(local.snapshot().panes.is_empty()); 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();
remote.new_tab(None).unwrap(); remote.new_tab(None).unwrap();
// The peers allocated exactly the same tab/pane IDs. // 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_eq!(local.snapshot().panes[0].id, remote_pane);
assert_ne!(remote_pane, right.active_pane); assert_ne!(remote_pane, right.active_pane);
let first_remote = local.tabs[1].id; 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(); local.focus_tab(left.id).unwrap();
let second = reserve(&mut local, 0); let second = reserve(&mut local, 0);
apply(&mut local, second, remote.snapshot()).unwrap(); apply(&mut local, second, remote.snapshot()).unwrap();
@@ -753,8 +921,13 @@ mod tests {
#[test] #[test]
fn copies_from_different_views_are_serialized_and_disconnect_completes_waiters() { fn copies_from_different_views_are_serialized_and_disconnect_completes_waiters() {
let upstream = super::super::tests::TestServer::start(); let upstream = super::super::tests::TestServer::start();
let (client, updates) = let (client, updates) = Transport::connect(
Transport::connect(&upstream.socket, None, SessionTarget::New { cwd: None }).unwrap(); &upstream.socket,
None,
SessionTarget::New { cwd: None },
SshOptions::default(),
)
.unwrap();
let receive = receive_updates(updates); let receive = receive_updates(updates);
let mut local = session(1); let mut local = session(1);
local.new_tab(None).unwrap(); local.new_tab(None).unwrap();
@@ -817,7 +990,7 @@ mod tests {
.to_string() .to_string()
.contains("inside itself") .contains("inside itself")
); );
local.cancel_pending_tab(group).unwrap(); assert_eq!(local.detach_remote(group).unwrap(), None);
assert!(cancelled.load(Ordering::Acquire)); assert!(cancelled.load(Ordering::Acquire));
assert_eq!(local.active_tab, anchor); assert_eq!(local.active_tab, anchor);
assert_eq!(local.tabs.len(), 1); assert_eq!(local.tabs.len(), 1);
+47 -9
View File
@@ -137,7 +137,7 @@ impl Workspace {
cx.notify(); 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(); let owner = cx.weak_entity();
self.palette = Some(cx.new(|cx| { self.palette = Some(cx.new(|cx| {
CommandPalette::new( CommandPalette::new(
@@ -204,6 +204,28 @@ impl Workspace {
.detach(); .detach();
} }
fn close_tab(&mut self, id: u64, window: &mut Window, cx: &mut Context<Self>) {
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<Self>) { fn execute(&mut self, action: CommandAction, window: &mut Window, cx: &mut Context<Self>) {
use CommandAction::*; use CommandAction::*;
let pane = self.focused_pane(); let pane = self.focused_pane();
@@ -253,13 +275,11 @@ impl Workspace {
Direction::Down Direction::Down
}, },
}), }),
ClosePane => pane_id ClosePane => pane_id.map(|id| ClientMessage::Close { id }).or_else(|| {
.map(|pane| ClientMessage::ClosePane { pane }) let tab = self.snapshot.as_deref()?.active_tab()?;
.or_else(|| { tab.is_connecting()
let tab = self.snapshot.as_deref()?.active_tab()?; .then_some(ClientMessage::DetachRemote { tab: tab.id })
tab.is_connecting() }),
.then_some(ClientMessage::ClosePendingTab { tab: tab.id })
}),
ResetPaneName => pane_id.map(|pane| ClientMessage::RenamePane { pane, name: None }), ResetPaneName => pane_id.map(|pane| ClientMessage::RenamePane { pane, name: None }),
ResetTabName => self ResetTabName => self
.snapshot .snapshot
@@ -311,6 +331,17 @@ impl Workspace {
} }
None 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 => { Detach => {
window.remove_window(); window.remove_window();
None None
@@ -455,7 +486,10 @@ impl Workspace {
view.snapshot = Some(snapshot); view.snapshot = Some(snapshot);
if let Some(palette) = &view.palette { if let Some(palette) = &view.palette {
if metadata_changed { 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 palette
.update(cx, |palette, cx| palette.set_items(items, cx)); .update(cx, |palette, cx| palette.set_items(items, cx));
} }
@@ -543,12 +577,16 @@ impl Render for Workspace {
.unwrap_or_default(); .unwrap_or_default();
let client = self.client.clone(); let client = self.client.clone();
let new_client = self.client.clone(); let new_client = self.client.clone();
let owner = cx.weak_entity();
let header = chrome::header( let header = chrome::header(
tabs, tabs,
cfg!(target_os = "macos") && !window.is_fullscreen(), cfg!(target_os = "macos") && !window.is_fullscreen(),
move |tab, _, _| { move |tab, _, _| {
let _ = client.send(ClientMessage::FocusTab { tab }); let _ = client.send(ClientMessage::FocusTab { tab });
}, },
move |tab, window, cx| {
let _ = owner.update(cx, |view, cx| view.close_tab(tab, window, cx));
},
move |_, _| { move |_, _| {
let _ = new_client.send(ClientMessage::NewTab { cwd: None }); let _ = new_client.send(ClientMessage::NewTab { cwd: None });
}, },