Add server-owned stacked panes with vertical navigation

This commit is contained in:
2026-11-17 02:08:02 -08:00
parent 4655f8149b
commit ec97ef00b0
10 changed files with 1129 additions and 136 deletions
+650 -40
View File
@@ -86,6 +86,24 @@ fn clean_title(title: String) -> Option<String> {
let title = title.trim();
(!title.is_empty()).then(|| title.to_owned())
}
fn single_pane_stack(pane: PaneId) -> StackInfo {
StackInfo {
panes: vec![StackPaneInfo {
id: pane,
title: "Shell".into(),
}],
active_pane: pane,
}
}
fn flatten_panes(tab: &mut TabInfo) {
tab.panes = tab
.stacks
.iter()
.flat_map(|stack| stack.panes.iter().map(|pane| pane.id))
.collect();
}
struct Client {
authenticated: bool,
attached: bool,
@@ -563,44 +581,63 @@ impl Server {
self.dirty = true;
}
ClientMessage::Split { pane, cwd } => {
let tab = self
.tabs
.iter()
.position(|tab| tab.panes.contains(&pane))
.context("unknown pane")?;
let occupied: usize = self.tabs[tab]
.panes
.iter()
.filter_map(|id| self.panes.get(id))
.map(|pane| {
let size = pane.session.size();
size.num_cols as usize * size.num_lines as usize
})
.sum();
ensure!(
occupied + 80 * 24 <= MAX_GRID_CELLS,
"tab grid exceeds {MAX_GRID_CELLS} cells"
);
let (tab_index, stack_index, _) = self.pane_position(pane)?;
self.ensure_new_pane_fits(tab_index)?;
let pane = self.new_pane(cwd)?;
self.tabs[tab].panes.push(pane);
self.tabs[tab].active_pane = pane;
self.active_tab = self.tabs[tab].id;
let tab = &mut self.tabs[tab_index];
tab.stacks.insert(stack_index + 1, single_pane_stack(pane));
flatten_panes(tab);
tab.active_pane = pane;
self.active_tab = tab.id;
self.dirty = true;
}
ClientMessage::NewStackPane {
pane,
direction,
cwd,
} => {
let pane = pane
.or_else(|| {
self.tabs
.iter()
.find(|tab| tab.id == self.active_tab)
.map(|tab| tab.active_pane)
})
.context("no active pane")?;
let (tab_index, stack_index, pane_index) = self.pane_position(pane)?;
self.ensure_new_pane_fits(tab_index)?;
let pane = self.new_pane(cwd)?;
let tab = &mut self.tabs[tab_index];
let stack = &mut tab.stacks[stack_index];
let insert_at = pane_index + usize::from(direction == VerticalDirection::Down);
stack.panes.insert(
insert_at,
StackPaneInfo {
id: pane,
title: "Shell".into(),
},
);
stack.active_pane = pane;
tab.active_pane = pane;
flatten_panes(tab);
self.active_tab = tab.id;
self.dirty = true;
}
ClientMessage::FocusStackPane { pane, direction } => {
self.focus_stack_pane(pane, direction)?;
}
ClientMessage::FocusDirection { direction } => {
self.focus_direction(direction)?;
}
ClientMessage::CycleTab { forward } => self.cycle_tab(forward),
ClientMessage::CyclePane { forward } => self.cycle_pane(forward)?,
ClientMessage::FocusTab { tab } => {
ensure!(self.tabs.iter().any(|entry| entry.id == tab), "unknown tab");
self.active_tab = tab;
self.dirty = true;
}
ClientMessage::FocusPane { pane } => {
let tab = self
.tabs
.iter_mut()
.find(|tab| tab.panes.contains(&pane))
.context("unknown pane")?;
tab.active_pane = pane;
self.active_tab = tab.id;
self.dirty = true;
self.focus_pane(pane)?;
}
ClientMessage::ClosePane { pane } => {
ensure!(self.remove_pane(pane), "unknown pane");
@@ -615,23 +652,147 @@ impl Server {
Ok(())
}
fn pane_position(&self, pane: PaneId) -> Result<(usize, usize, usize)> {
for (tab_index, tab) in self.tabs.iter().enumerate() {
for (stack_index, stack) in tab.stacks.iter().enumerate() {
if let Some(pane_index) = stack.panes.iter().position(|entry| entry.id == pane) {
return Ok((tab_index, stack_index, pane_index));
}
}
}
anyhow::bail!("unknown pane")
}
fn ensure_new_pane_fits(&self, tab_index: usize) -> Result<()> {
let occupied: usize = self.tabs[tab_index]
.panes
.iter()
.filter_map(|id| self.panes.get(id))
.map(|pane| {
let size = pane.session.size();
size.num_cols as usize * size.num_lines as usize
})
.sum();
ensure!(
occupied + 80 * 24 <= MAX_GRID_CELLS,
"tab grid exceeds {MAX_GRID_CELLS} cells"
);
Ok(())
}
fn focus_pane(&mut self, pane: PaneId) -> Result<()> {
let (tab_index, stack_index, _) = self.pane_position(pane)?;
let tab = &mut self.tabs[tab_index];
tab.stacks[stack_index].active_pane = pane;
tab.active_pane = pane;
self.active_tab = tab.id;
self.dirty = true;
Ok(())
}
fn focus_stack_pane(&mut self, pane: PaneId, direction: VerticalDirection) -> Result<()> {
let (tab_index, stack_index, pane_index) = self.pane_position(pane)?;
let stack = &self.tabs[tab_index].stacks[stack_index];
let next = match direction {
VerticalDirection::Up => pane_index.checked_sub(1),
VerticalDirection::Down => {
(pane_index + 1 < stack.panes.len()).then_some(pane_index + 1)
}
};
if let Some(index) = next {
self.focus_pane(stack.panes[index].id)?;
}
Ok(())
}
fn cycle_tab(&mut self, forward: bool) {
let Some(index) = self.tabs.iter().position(|tab| tab.id == self.active_tab) else {
return;
};
let count = self.tabs.len();
let next = if forward {
(index + 1) % count
} else {
(index + count - 1) % count
};
self.active_tab = self.tabs[next].id;
self.dirty = true;
}
fn cycle_pane(&mut self, forward: bool) -> Result<()> {
let Some(tab) = self.tabs.iter().find(|tab| tab.id == self.active_tab) else {
return Ok(());
};
let index = tab
.stacks
.iter()
.position(|stack| stack.active_pane == tab.active_pane)
.context("focused pane is not expanded")?;
let count = tab.stacks.len();
let next = if forward {
(index + 1) % count
} else {
(index + count - 1) % count
};
self.focus_pane(tab.stacks[next].active_pane)
}
fn focus_direction(&mut self, direction: Direction) -> Result<()> {
let Some(tab_index) = self.tabs.iter().position(|tab| tab.id == self.active_tab) else {
return Ok(());
};
let pane = self.tabs[tab_index].active_pane;
match direction {
Direction::Up => self.focus_stack_pane(pane, VerticalDirection::Up),
Direction::Down => self.focus_stack_pane(pane, VerticalDirection::Down),
Direction::Left | Direction::Right => {
let (_, stack_index, _) = self.pane_position(pane)?;
let tab = &self.tabs[tab_index];
let next = if direction == Direction::Left {
stack_index.checked_sub(1)
} else {
(stack_index + 1 < tab.stacks.len()).then_some(stack_index + 1)
};
if let Some(index) = next {
self.focus_pane(tab.stacks[index].active_pane)?;
} else {
self.cycle_tab(direction == Direction::Right);
}
Ok(())
}
}
}
/// The same lifecycle path serves explicit close and a shell's natural exit.
fn remove_pane(&mut self, pane: PaneId) -> bool {
let Some(removed) = self.panes.remove(&pane) else {
return false;
};
if let Some(tab_index) = self.tabs.iter().position(|tab| tab.panes.contains(&pane)) {
if let Ok((tab_index, stack_index, pane_index)) = self.pane_position(pane) {
let tab = &mut self.tabs[tab_index];
let pane_index = tab.panes.iter().position(|id| *id == pane).unwrap();
tab.panes.remove(pane_index);
if tab.active_pane == pane {
tab.active_pane = tab
let stack = &mut tab.stacks[stack_index];
stack.panes.remove(pane_index);
if stack.active_pane == pane {
stack.active_pane = stack
.panes
.get(pane_index.min(tab.panes.len().saturating_sub(1)))
.copied()
.unwrap_or(0);
.get(pane_index.min(stack.panes.len().saturating_sub(1)))
.map_or(0, |entry| entry.id);
}
if tab.panes.is_empty() {
let replacement = stack.active_pane;
if stack.panes.is_empty() {
tab.stacks.remove(stack_index);
}
if tab.active_pane == pane {
tab.active_pane = if replacement != 0 {
replacement
} else {
tab.stacks
.get(stack_index.min(tab.stacks.len().saturating_sub(1)))
.map_or(0, |stack| stack.active_pane)
};
}
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
@@ -722,6 +883,7 @@ impl Server {
title: "Shell".into(),
panes: vec![pane],
active_pane: pane,
stacks: vec![single_pane_stack(pane)],
});
self.active_tab = id;
Ok(())
@@ -736,7 +898,17 @@ impl Server {
return;
};
match event {
Event::Wakeup => pane.session.acknowledge_wakeup(),
Event::Wakeup => {
// Hidden PTYs still parse output and must rearm their wakeups,
// but their grids are absent from the current client snapshot.
pane.session.acknowledge_wakeup();
self.dirty |= self
.tabs
.iter()
.find(|tab| tab.id == self.active_tab)
.is_some_and(|tab| tab.stacks.iter().any(|stack| stack.active_pane == id));
return;
}
Event::Title(title) => pane.program_title = clean_title(title),
Event::ResetTitle => pane.program_title = None,
Event::PtyWrite(text) => pane.session.write(text.into_bytes()),
@@ -770,12 +942,24 @@ impl Server {
if let Some(pane) = self.panes.get(&tab.active_pane) {
tab.title = pane.title();
}
for stack in &mut tab.stacks {
for entry in &mut stack.panes {
if let Some(pane) = self.panes.get(&entry.id) {
entry.title = pane.title();
}
}
}
}
let visible = self
.tabs
.iter()
.find(|tab| tab.id == self.active_tab)
.map(|tab| tab.panes.clone())
.map(|tab| {
tab.stacks
.iter()
.map(|stack| stack.active_pane)
.collect::<Vec<_>>()
})
.unwrap_or_default();
let panes = visible
.into_iter()
@@ -1166,6 +1350,432 @@ mod tests {
);
}
fn active_tab(snapshot: &Snapshot) -> &TabInfo {
snapshot
.tabs
.iter()
.find(|tab| tab.id == snapshot.active_tab)
.unwrap()
}
fn list_after_commands(client: &mut UnixStream) -> Snapshot {
// A round trip separates older queued snapshots from this inspection.
send(client, ClientMessage::Ping);
loop {
match protocol::read_message::<ServerMessage>(client).unwrap() {
ServerMessage::Pong => break,
ServerMessage::Error(error) => panic!("server error: {error}"),
_ => {}
}
}
send(client, ClientMessage::List);
snapshot(client, |_| true)
}
#[test]
fn collapsed_output_rearms_wakeups_without_publishing_unchanged_grids() {
let (sender, receiver) = mpsc::sync_channel(1024);
let mut actor = Server {
shell: Some(Shell::new("/bin/sh".into(), Vec::new())),
panes: HashMap::new(),
tabs: Vec::new(),
active_tab: 0,
next_id: 1,
clients: HashMap::new(),
sender,
revision: 0,
dirty: false,
last_frame: Instant::now(),
last_cwd_refresh: Instant::now(),
};
actor.new_tab(None).unwrap();
let hidden = actor.tabs[0].active_pane;
let visible = actor.new_pane(None).unwrap();
let tab = &mut actor.tabs[0];
tab.stacks[0].panes.push(StackPaneInfo {
id: visible,
title: "Visible".into(),
});
tab.stacks[0].active_pane = visible;
tab.active_pane = visible;
flatten_panes(tab);
// Drive actual PTY/parser events directly so absence of a publish is
// tested through its dirty flag, without timing-dependent socket gaps.
let output = |actor: &mut Server, suffix: &str, expect_dirty: bool| {
actor.panes[&hidden]
.session
.write(format!("printf 'HIDDEN_%s\\n' '{suffix}'\n").into_bytes());
let needle = format!("HIDDEN_{suffix}");
let deadline = Instant::now() + Duration::from_secs(5);
loop {
let event = receiver
.recv_timeout(deadline.saturating_duration_since(Instant::now()))
.unwrap();
if let Action::Terminal(id, event) = event {
let target_wakeup = id == hidden && matches!(event, Event::Wakeup);
actor.dirty = false;
actor.terminal_event(id, event);
if target_wakeup {
assert_eq!(actor.dirty, expect_dirty);
let term = actor.panes[&hidden].session.term.lock();
let text = term
.renderable_content()
.display_iter
.map(|cell| cell.cell.c)
.collect::<String>();
if text.contains(&needle) {
break;
}
}
}
}
};
output(&mut actor, "FIRST", false);
// A second burst verifies the first suppressed wakeup was acknowledged.
output(&mut actor, "SECOND", false);
let hidden_snapshot = actor.snapshot();
assert_eq!(hidden_snapshot.panes.len(), 1);
assert_eq!(hidden_snapshot.panes[0].id, visible);
actor.focus_pane(hidden).unwrap();
assert!(actor.dirty);
assert!(contains(&actor.snapshot(), "HIDDEN_SECOND"));
output(&mut actor, "VISIBLE", true);
}
#[test]
fn stacks_insert_in_both_directions_and_only_expand_one_grid() {
let server = TestServer::start();
let mut client = server.client();
send(&mut client, ClientMessage::Attach);
let initial = snapshot(&mut client, |s| s.panes.len() == 1);
let first = initial.panes[0].id;
input(
&mut client,
first,
"stty -echo; printf '\\033[2J\\033[HSTACK_STATE\\n'\n",
);
snapshot(&mut client, |s| contains(s, "STACK_STATE"));
send(
&mut client,
ClientMessage::NewStackPane {
pane: Some(first),
direction: VerticalDirection::Down,
cwd: None,
},
);
let second = snapshot(&mut client, |s| active_tab(s).panes.len() == 2);
let bottom = active_tab(&second).active_pane;
assert_eq!(active_tab(&second).panes, [first, bottom]);
assert_eq!(active_tab(&second).stacks.len(), 1);
assert_eq!(second.panes.len(), 1);
assert_eq!(second.panes[0].id, bottom);
send(
&mut client,
ClientMessage::RenamePane {
pane: first,
name: Some("Collapsed source".into()),
},
);
snapshot(&mut client, |s| {
active_tab(s).stacks[0].panes[0].title == "Collapsed source"
});
send(
&mut client,
ClientMessage::NewStackPane {
pane: Some(bottom),
direction: VerticalDirection::Up,
cwd: None,
},
);
let third = snapshot(&mut client, |s| active_tab(s).panes.len() == 3);
let middle = active_tab(&third).active_pane;
assert_eq!(active_tab(&third).panes, [first, middle, bottom]);
assert_eq!(third.panes.len(), 1);
send(
&mut client,
ClientMessage::FocusDirection {
direction: Direction::Up,
},
);
let top = snapshot(&mut client, |s| active_tab(s).active_pane == first);
assert!(contains(&top, "STACK_STATE"));
send(
&mut client,
ClientMessage::FocusDirection {
direction: Direction::Up,
},
);
assert_eq!(
active_tab(&list_after_commands(&mut client)).active_pane,
first
);
send(
&mut client,
ClientMessage::FocusStackPane {
pane: first,
direction: VerticalDirection::Down,
},
);
snapshot(&mut client, |s| active_tab(s).active_pane == middle);
send(&mut client, ClientMessage::FocusPane { pane: bottom });
snapshot(&mut client, |s| active_tab(s).active_pane == bottom);
send(
&mut client,
ClientMessage::FocusDirection {
direction: Direction::Down,
},
);
assert_eq!(
active_tab(&list_after_commands(&mut client)).active_pane,
bottom
);
}
#[test]
fn relative_commands_preserve_bursts_without_intermediate_snapshots() {
let server = TestServer::start();
// A control client does not attach, so the only snapshots are the
// explicit List responses after each complete command burst.
let mut client = server.client();
let inspect = |client: &mut UnixStream| {
send(client, ClientMessage::List);
snapshot(client, |_| true)
};
for _ in 0..3 {
send(&mut client, ClientMessage::NewTab { cwd: None });
}
let initial = inspect(&mut client);
let first_tab = initial.tabs[0].id;
let last_tab = initial.tabs[2].id;
let first_pane = initial.tabs[0].active_pane;
send(&mut client, ClientMessage::FocusTab { tab: first_tab });
send(&mut client, ClientMessage::CycleTab { forward: true });
send(&mut client, ClientMessage::CycleTab { forward: true });
assert_eq!(inspect(&mut client).active_tab, last_tab);
send(&mut client, ClientMessage::CycleTab { forward: false });
send(&mut client, ClientMessage::CycleTab { forward: false });
assert_eq!(inspect(&mut client).active_tab, first_tab);
send(&mut client, ClientMessage::CycleTab { forward: false });
assert_eq!(inspect(&mut client).active_tab, last_tab);
send(&mut client, ClientMessage::FocusTab { tab: first_tab });
for _ in 0..2 {
send(
&mut client,
ClientMessage::NewStackPane {
pane: None,
direction: VerticalDirection::Down,
cwd: None,
},
);
}
let down = inspect(&mut client);
let order = &active_tab(&down).panes;
assert_eq!(order.len(), 3);
assert_eq!(order[0], first_pane);
// Pane IDs grow with creation order: repeated Down appends in that
// order, rather than repeatedly inserting after the stale first pane.
assert!(order[1] < order[2]);
let last_down = order[2];
assert_eq!(active_tab(&down).active_pane, last_down);
for _ in 0..2 {
send(
&mut client,
ClientMessage::NewStackPane {
pane: None,
direction: VerticalDirection::Up,
cwd: None,
},
);
}
let up = inspect(&mut client);
let order = &active_tab(&up).panes;
assert_eq!(order.len(), 5);
assert_eq!(order[4], last_down);
assert!(order[2] > order[3]);
let expanded = order[2];
assert_eq!(active_tab(&up).active_pane, expanded);
send(
&mut client,
ClientMessage::Split {
pane: expanded,
cwd: None,
},
);
let middle = active_tab(&inspect(&mut client)).active_pane;
send(
&mut client,
ClientMessage::Split {
pane: middle,
cwd: None,
},
);
let right = active_tab(&inspect(&mut client)).active_pane;
send(&mut client, ClientMessage::FocusPane { pane: expanded });
send(&mut client, ClientMessage::CyclePane { forward: true });
send(&mut client, ClientMessage::CyclePane { forward: true });
assert_eq!(active_tab(&inspect(&mut client)).active_pane, right);
send(&mut client, ClientMessage::CyclePane { forward: true });
assert_eq!(active_tab(&inspect(&mut client)).active_pane, expanded);
send(&mut client, ClientMessage::CyclePane { forward: false });
send(&mut client, ClientMessage::CyclePane { forward: false });
assert_eq!(active_tab(&inspect(&mut client)).active_pane, middle);
}
#[test]
fn horizontal_navigation_moves_between_columns_and_then_tabs() {
let server = TestServer::start();
let mut client = server.client();
send(&mut client, ClientMessage::Attach);
let initial = snapshot(&mut client, |s| s.panes.len() == 1);
let first = initial.panes[0].id;
let first_tab = initial.active_tab;
send(
&mut client,
ClientMessage::NewStackPane {
pane: Some(first),
direction: VerticalDirection::Down,
cwd: None,
},
);
let stacked = snapshot(&mut client, |s| active_tab(s).panes.len() == 2);
let expanded = active_tab(&stacked).active_pane;
send(
&mut client,
ClientMessage::Split {
pane: first,
cwd: None,
},
);
let split = snapshot(&mut client, |s| s.panes.len() == 2);
let right = active_tab(&split).active_pane;
assert_eq!(active_tab(&split).panes, [first, expanded, right]);
assert_eq!(active_tab(&split).stacks.len(), 2);
assert_eq!(
split.panes.iter().map(|pane| pane.id).collect::<Vec<_>>(),
[expanded, right]
);
send(
&mut client,
ClientMessage::FocusDirection {
direction: Direction::Left,
},
);
snapshot(&mut client, |s| active_tab(s).active_pane == expanded);
send(
&mut client,
ClientMessage::FocusDirection {
direction: Direction::Up,
},
);
snapshot(&mut client, |s| active_tab(s).active_pane == first);
send(
&mut client,
ClientMessage::FocusDirection {
direction: Direction::Right,
},
);
snapshot(&mut client, |s| active_tab(s).active_pane == right);
send(&mut client, ClientMessage::NewTab { cwd: None });
let next_tab = snapshot(&mut client, |s| s.tabs.len() == 2);
send(
&mut client,
ClientMessage::FocusDirection {
direction: Direction::Left,
},
);
let restored = snapshot(&mut client, |s| s.active_tab == first_tab);
assert_eq!(active_tab(&restored).active_pane, right);
send(
&mut client,
ClientMessage::FocusDirection {
direction: Direction::Right,
},
);
snapshot(&mut client, |s| s.active_tab == next_tab.active_tab);
send(
&mut client,
ClientMessage::FocusDirection {
direction: Direction::Right,
},
);
snapshot(&mut client, |s| s.active_tab == first_tab);
}
#[test]
fn stack_state_and_collapsed_shells_survive_clients_and_exit_cleanly() {
let server = TestServer::start();
let mut first_client = server.client();
send(&mut first_client, ClientMessage::Attach);
let initial = snapshot(&mut first_client, |s| s.panes.len() == 1);
let top = initial.panes[0].id;
send(
&mut first_client,
ClientMessage::NewStackPane {
pane: Some(top),
direction: VerticalDirection::Down,
cwd: None,
},
);
let stacked = snapshot(&mut first_client, |s| active_tab(s).panes.len() == 2);
let middle = active_tab(&stacked).active_pane;
send(
&mut first_client,
ClientMessage::NewStackPane {
pane: Some(middle),
direction: VerticalDirection::Down,
cwd: None,
},
);
let three = snapshot(&mut first_client, |s| active_tab(s).panes.len() == 3);
let bottom = active_tab(&three).active_pane;
let mut other_client = server.client();
send(&mut other_client, ClientMessage::Attach);
let mirrored = snapshot(&mut other_client, |s| active_tab(s).panes.len() == 3);
assert_eq!(active_tab(&mirrored).panes, [top, middle, bottom]);
send(&mut other_client, ClientMessage::FocusPane { pane: middle });
snapshot(&mut other_client, |s| active_tab(s).active_pane == middle);
snapshot(&mut first_client, |s| active_tab(s).active_pane == middle);
send(&mut first_client, ClientMessage::Detach);
send(&mut other_client, ClientMessage::Detach);
drop(first_client);
drop(other_client);
let mut client = server.client();
send(&mut client, ClientMessage::Attach);
let reattached = snapshot(&mut client, |s| active_tab(s).panes.len() == 3);
assert_eq!(reattached.active_tab, initial.active_tab);
assert_eq!(active_tab(&reattached).stacks[0].active_pane, middle);
assert_eq!(reattached.panes[0].id, middle);
// A collapsed shell's exit leaves the focused/expanded pane alone.
input(&mut client, top, "exit\n");
let collapsed_exit = snapshot(&mut client, |s| active_tab(s).panes.len() == 2);
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 });
let closed = snapshot(&mut client, |s| active_tab(s).panes.len() == 1);
assert_eq!(closed.panes[0].id, bottom);
send(
&mut client,
ClientMessage::Split {
pane: bottom,
cwd: None,
},
);
let split = snapshot(&mut client, |s| s.panes.len() == 2);
let other = active_tab(&split).active_pane;
input(&mut client, bottom, "exit\n");
let removed_column = snapshot(&mut client, |s| active_tab(s).stacks.len() == 1);
assert_eq!(removed_column.panes[0].id, other);
input(&mut client, other, "exit\n");
let empty = snapshot(&mut client, |s| s.tabs.is_empty());
assert!(empty.panes.is_empty());
}
#[test]
fn natural_shell_exit_removes_panes_and_empty_tabs_without_stealing_focus() {
let server = TestServer::start();