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:
+1
-1
@@ -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;
|
||||
|
||||
+41
-3
@@ -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<ChromeTab>,
|
||||
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<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.
|
||||
fn remote_hostname(destination: &str) -> &str {
|
||||
let uri = destination.strip_prefix("ssh://");
|
||||
@@ -264,6 +301,7 @@ mod tests {
|
||||
],
|
||||
cfg!(target_os = "macos"),
|
||||
|_, _, _| {},
|
||||
|_, _, _| {},
|
||||
|_, _| {},
|
||||
|_, _| {},
|
||||
);
|
||||
|
||||
+280
-74
@@ -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<Connection>);
|
||||
pub struct Client {
|
||||
connection: Arc<Connection>,
|
||||
remote_session: Option<Arc<RemoteSession>>,
|
||||
}
|
||||
struct RemoteSession {
|
||||
identity: SessionIdentity,
|
||||
live: AtomicBool,
|
||||
}
|
||||
struct Connection {
|
||||
launcher_socket: PathBuf,
|
||||
remote: Option<String>,
|
||||
remote_executable: Option<String>,
|
||||
commands: mpsc::Sender<ClientMessage>,
|
||||
socket: Option<UnixStream>,
|
||||
ssh: Mutex<Option<Child>>,
|
||||
@@ -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<Arc<AtomicBool>>,
|
||||
) -> 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>, _, _) =
|
||||
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::<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(());
|
||||
}
|
||||
})?;
|
||||
.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<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.
|
||||
pub fn open_window(&self, remote: Option<String>, cwd: Option<String>) -> 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<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
|
||||
/// startup failures in the invoking window as well as in the daemon log.
|
||||
fn ssh_diagnostics(mut stderr: ChildStderr) -> io::Result<mpsc::Receiver<String>> {
|
||||
@@ -383,7 +462,9 @@ fn greet(
|
||||
reader: &mut GreetingReader<'_>,
|
||||
writer: &mut impl Write,
|
||||
session: SessionTarget,
|
||||
) -> Result<()> {
|
||||
from_ssh: bool,
|
||||
expected: Option<SessionIdentity>,
|
||||
) -> Result<Option<Snapshot>> {
|
||||
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::<ServerMessage>(reader)? {
|
||||
ServerMessage::Connected { .. } => Ok(()),
|
||||
let session = match protocol::read_message::<ServerMessage>(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::<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 {
|
||||
@@ -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 {
|
||||
|
||||
+17
-2
@@ -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<PaletteItem> {
|
||||
pub fn root_items(snapshot: Option<&Snapshot>, remote_window: bool) -> Vec<PaletteItem> {
|
||||
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<PaletteItem> {
|
||||
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());
|
||||
|
||||
+7
-3
@@ -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);
|
||||
|
||||
@@ -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
|
||||
|
||||
+70
-21
@@ -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<String>,
|
||||
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());
|
||||
|
||||
+27
-4
@@ -24,8 +24,13 @@ pub struct SessionIdentity {
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub enum SessionTarget {
|
||||
New { cwd: Option<String> },
|
||||
New {
|
||||
cwd: Option<String>,
|
||||
},
|
||||
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.
|
||||
@@ -35,6 +40,14 @@ pub struct SshOptions {
|
||||
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)]
|
||||
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<String>,
|
||||
@@ -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<SessionIdentity>,
|
||||
},
|
||||
RememberDetachedRemote(DetachedRemote),
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
||||
@@ -205,6 +227,7 @@ pub enum ServerMessage {
|
||||
Closing,
|
||||
Connected { session: SessionId },
|
||||
Sessions(Vec<SessionInfo>),
|
||||
DetachedRemote(DetachedRemote),
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
|
||||
+164
-23
@@ -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<Shell>,
|
||||
sessions: BTreeMap<SessionId, SessionState>,
|
||||
last_detached_remote: Option<DetachedRemote>,
|
||||
next_session: SessionId,
|
||||
clients: HashMap<u64, Client>,
|
||||
sender: mpsc::SyncSender<Action>,
|
||||
@@ -301,6 +303,7 @@ struct SessionState {
|
||||
identity: SessionIdentity,
|
||||
socket: PathBuf,
|
||||
remotes: HashMap<u64, remote::RemoteSession>,
|
||||
last_detached_remote: Option<DetachedRemote>,
|
||||
id: SessionId,
|
||||
last_used: Instant,
|
||||
shell: Option<Shell>,
|
||||
@@ -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::<Vec<_>>(),
|
||||
@@ -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();
|
||||
|
||||
+193
-20
@@ -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);
|
||||
|
||||
+47
-9
@@ -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<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>) {
|
||||
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 });
|
||||
},
|
||||
|
||||
Reference in New Issue
Block a user