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
+193 -20
View File
@@ -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<Option<DetachedRemote>> {
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);