refactor(maestro): make the TUI dispatch a reducer over effects
ci / rust (pull_request) Successful in 1m57s
ci / rust (push) Successful in 1m54s

dispatch was `async fn -> ()` with reqwest calls and task spawns inlined,
so it could not report intent and the spawn, kill and attach arms had no
test. It now returns Vec<Effect> and App::run performs them.

Two bugs the old shape produced, both fixed and covered:

- The toast overlay could not be dismissed. handle_overlay_input returned
  Pass for Toast(_) and nothing cleared it, so "spawn failed: ..." stayed
  until another overlay replaced it. It now clears and still returns Pass,
  so the keystroke does its normal job instead of being eaten.
- Closing a tab leaked its emulator. Only submit_kill released one, so a
  closed tab's WebSocket task and vt100 parser outlived it forever.
  close_tab now reports the session it dropped — and holds onto it when
  another tab still shows the same one.

AppState::overlay is private behind show_overlay/dismiss_overlay/toast.
Four sites poked the field directly; that is why the toast bug existed.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit was merged in pull request #42.
This commit is contained in:
Miguel Palhas
2026-08-22 13:08:08 +01:00
co-authored by Claude Opus 5
parent 63898cef25
commit f01771568b
3 changed files with 332 additions and 103 deletions
+257 -98
View File
@@ -66,6 +66,18 @@ impl std::fmt::Debug for App {
}
}
/// Something a keystroke decided to do that reaches outside `AppState`.
///
/// `dispatch` returns these instead of performing them, so every arm is
/// assertable without a daemon on the other end.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Effect {
Attach(Uuid),
Spawn(CreateSessionRequest),
Kill(Uuid),
Forward { id: Uuid, bytes: Vec<u8> },
}
impl App {
pub fn new(cfg: TuiConfig, catalog: CatalogStore, daemon: DaemonClient) -> Self {
let chord_timeout = cfg.chord_timeout;
@@ -119,7 +131,9 @@ impl App {
};
// Overlay intercept first.
if self.handle_overlay_input(&key).await == OverlayDecision::Consumed {
let (decision, effects) = self.handle_overlay_input(&key);
self.perform(effects).await;
if decision == OverlayDecision::Consumed {
return Ok(false);
}
@@ -131,52 +145,87 @@ impl App {
if matches!(act, Action::Quit) {
return Ok(true);
}
self.dispatch(act).await;
let effects = self.dispatch(act);
self.perform(effects).await;
} else if self.state.mode == Mode::Insert && matches!(self.state.focus, Focus::Pane)
{
self.forward_to_session(&key).await;
if let Some(effect) = self.forward_to_session(&key) {
self.perform(vec![effect]).await;
}
}
Ok(false)
}
}
}
async fn handle_overlay_input(&mut self, key: &InputKey) -> OverlayDecision {
use crate::overlays::SpawnInputResult;
match self.state.overlay.clone() {
Some(OverlayKind::Spawn) => {
match self.spawn.on_input(key) {
SpawnInputResult::Consumed => {}
SpawnInputResult::Cancel => {
self.state.overlay = None;
}
SpawnInputResult::Submit => {
self.submit_spawn().await;
/// Carry out what `dispatch` decided. The only place in `App` that talks to
/// the daemon.
async fn perform(&mut self, effects: Vec<Effect>) {
for effect in effects {
match effect {
Effect::Attach(id) => self.attach(id),
Effect::Spawn(req) => self.submit_spawn(req).await,
Effect::Kill(id) => self.submit_kill(id).await,
Effect::Forward { id, bytes } => {
if let Some(handle) = self.emulators.get(id) {
let _ = handle.tx.send(SessionInput::Bytes(bytes)).await;
}
}
OverlayDecision::Consumed
}
Some(OverlayKind::KillConfirm(id)) => match key {
InputKey::Char { c: 'y', .. } => {
self.state.overlay = None;
self.submit_kill(id).await;
OverlayDecision::Consumed
}
InputKey::Char { c: 'n', .. } | InputKey::Esc => {
self.state.overlay = None;
OverlayDecision::Consumed
}
_ => OverlayDecision::Consumed,
},
Some(OverlayKind::Help) => {
self.state.overlay = None;
OverlayDecision::Consumed
}
Some(OverlayKind::Toast(_)) | None => OverlayDecision::Pass,
}
}
async fn dispatch(&mut self, act: Action) {
fn handle_overlay_input(&mut self, key: &InputKey) -> (OverlayDecision, Vec<Effect>) {
use crate::overlays::SpawnInputResult;
match self.state.overlay().cloned() {
Some(OverlayKind::Spawn) => {
let mut effects = Vec::new();
match self.spawn.on_input(key) {
SpawnInputResult::Consumed => {}
SpawnInputResult::Cancel => {
self.state.dismiss_overlay();
}
SpawnInputResult::Submit => {
effects.push(Effect::Spawn(CreateSessionRequest {
cwd: std::path::PathBuf::from(self.spawn.cwd.clone()),
command: self.spawn.command.clone(),
env: Default::default(),
metadata: Default::default(),
worktree: None,
}));
}
}
(OverlayDecision::Consumed, effects)
}
Some(OverlayKind::KillConfirm(id)) => match key {
InputKey::Char { c: 'y', .. } => {
self.state.dismiss_overlay();
(OverlayDecision::Consumed, vec![Effect::Kill(id)])
}
InputKey::Char { c: 'n', .. } | InputKey::Esc => {
self.state.dismiss_overlay();
(OverlayDecision::Consumed, Vec::new())
}
_ => (OverlayDecision::Consumed, Vec::new()),
},
Some(OverlayKind::Help) => {
self.state.dismiss_overlay();
(OverlayDecision::Consumed, Vec::new())
}
// A toast is informational: clear it, but let the keystroke go on
// and do its normal job rather than being swallowed.
Some(OverlayKind::Toast(_)) => {
self.state.dismiss_overlay();
(OverlayDecision::Pass, Vec::new())
}
None => (OverlayDecision::Pass, Vec::new()),
}
}
/// Fold a resolved action into `AppState` and report anything it wants done
/// outside it. Deliberately sync and side-effect-free.
fn dispatch(&mut self, act: Action) -> Vec<Effect> {
let mut effects = Vec::new();
match act {
Action::Noop | Action::Quit => {}
Action::EnterInsert => self.state.mode = Mode::Insert,
@@ -198,7 +247,11 @@ impl App {
self.state.focus = Focus::Sidebar;
}
Action::NewTab => self.state.new_tab(),
Action::CloseTab => self.state.close_tab(),
Action::CloseTab => {
if let Some(sid) = self.state.close_tab() {
self.release_session(sid);
}
}
Action::NextTab => self.state.next_tab(),
Action::PrevTab => self.state.prev_tab(),
Action::GotoTab(n) => self.state.goto_tab(n),
@@ -207,7 +260,7 @@ impl App {
self.help = HelpOverlay {
lines: render_help_lines(&self.cfg),
};
self.state.overlay = Some(OverlayKind::Help);
self.state.show_overlay(OverlayKind::Help);
}
Action::OpenSpawnModal => {
self.spawn = SpawnModal {
@@ -215,31 +268,42 @@ impl App {
command: String::new(),
focused_field: Default::default(),
};
self.state.overlay = Some(OverlayKind::Spawn);
self.state.show_overlay(OverlayKind::Spawn);
}
Action::AttachHighlighted | Action::ToggleAttachHighlighted => {
if let Some(sid) = self.pick_sidebar_target() {
if self.emulators.get(sid).is_none() {
match self.daemon.attach_url(sid) {
Ok(ws_url) => {
let handle = SessionTask::spawn(ws_url, 24, 80);
self.emulators.insert(sid, handle);
}
Err(e) => {
self.state.overlay =
Some(OverlayKind::Toast(format!("attach failed: {e}")));
}
}
}
effects.push(Effect::Attach(sid));
self.state.attach_to_focused(sid);
}
}
Action::KillHighlighted => {
if let Some(sid) = self.pick_sidebar_target() {
self.state.overlay = Some(OverlayKind::KillConfirm(sid));
self.state.show_overlay(OverlayKind::KillConfirm(sid));
}
}
}
effects
}
/// Open a stream for `sid` if one isn't already running.
fn attach(&mut self, sid: Uuid) {
if self.emulators.get(sid).is_some() {
return;
}
match self.daemon.attach_url(sid) {
Ok(ws_url) => {
let handle = SessionTask::spawn(ws_url, 24, 80);
self.emulators.insert(sid, handle);
}
Err(e) => self.state.toast(format!("attach failed: {e}")),
}
}
/// Tear down the emulator for `sid`, aborting its WebSocket task and
/// dropping its vt100 parser.
fn release_session(&mut self, sid: Uuid) {
self.emulators.remove(sid);
self.last_sent_size.remove(&sid);
}
/// Return the session under the sidebar highlight, falling back to the
@@ -252,13 +316,11 @@ impl App {
snap.sessions.first().map(|s| s.id)
}
async fn forward_to_session(&mut self, key: &InputKey) {
let Some(sid) = self.state.active_tab().pane else {
return;
};
let Some(handle) = self.emulators.get(sid) else {
return;
};
/// Encode a keystroke for the focused pane. `None` when there is nothing
/// attached to send it to.
fn forward_to_session(&mut self, key: &InputKey) -> Option<Effect> {
let sid = self.state.active_tab().pane?;
self.emulators.get(sid)?;
let bytes = match key {
InputKey::Char { c, ctrl, alt, .. } => {
let mut out = Vec::with_capacity(8);
@@ -282,37 +344,24 @@ impl App {
InputKey::Down => b"\x1b[B".to_vec(),
InputKey::Right => b"\x1b[C".to_vec(),
InputKey::Left => b"\x1b[D".to_vec(),
InputKey::Mouse { .. } => return,
InputKey::Mouse { .. } => return None,
};
let _ = handle.tx.send(SessionInput::Bytes(bytes)).await;
Some(Effect::Forward { id: sid, bytes })
}
async fn submit_spawn(&mut self) {
let cwd = std::path::PathBuf::from(self.spawn.cwd.clone());
let req = CreateSessionRequest {
cwd,
command: self.spawn.command.clone(),
env: Default::default(),
metadata: Default::default(),
worktree: None,
};
async fn submit_spawn(&mut self, req: CreateSessionRequest) {
match self.daemon.create_session(&req).await {
Ok(_) => self.state.overlay = None,
Err(e) => {
self.state.overlay = Some(OverlayKind::Toast(format!("spawn failed: {e}")));
Ok(_) => {
self.state.dismiss_overlay();
}
Err(e) => self.state.toast(format!("spawn failed: {e}")),
}
}
async fn submit_kill(&mut self, sid: Uuid) {
match self.daemon.kill_session(sid).await {
Ok(()) => {
self.emulators.remove(sid);
self.last_sent_size.remove(&sid);
}
Err(e) => {
self.state.overlay = Some(OverlayKind::Toast(format!("kill failed: {e}")));
}
Ok(()) => self.release_session(sid),
Err(e) => self.state.toast(format!("kill failed: {e}")),
}
}
@@ -432,42 +481,152 @@ mod tests {
)
}
#[tokio::test]
async fn enter_insert_then_leave() {
#[test]
fn enter_insert_then_leave() {
let mut app = make_app();
assert_eq!(app.state.mode, Mode::Normal);
app.dispatch(Action::EnterInsert).await;
app.dispatch(Action::EnterInsert);
assert_eq!(app.state.mode, Mode::Insert);
app.dispatch(Action::LeaveInsert).await;
app.dispatch(Action::LeaveInsert);
assert_eq!(app.state.mode, Mode::Normal);
}
#[tokio::test]
async fn new_tab_action_extends_tabs() {
#[test]
fn new_tab_action_extends_tabs() {
let mut app = make_app();
app.dispatch(Action::NewTab).await;
app.dispatch(Action::NewTab).await;
app.dispatch(Action::NewTab);
app.dispatch(Action::NewTab);
assert_eq!(app.state.tabs.len(), 3);
app.dispatch(Action::CloseTab).await;
app.dispatch(Action::CloseTab);
assert_eq!(app.state.tabs.len(), 2);
}
#[tokio::test]
async fn show_help_opens_overlay() {
#[test]
fn show_help_opens_overlay() {
let mut app = make_app();
app.dispatch(Action::ShowHelp).await;
assert!(matches!(app.state.overlay, Some(OverlayKind::Help)));
app.dispatch(Action::ShowHelp);
assert!(matches!(app.state.overlay(), Some(OverlayKind::Help)));
}
#[tokio::test]
async fn open_spawn_modal_sets_overlay() {
#[test]
fn open_spawn_modal_sets_overlay() {
let mut app = make_app();
app.dispatch(Action::OpenSpawnModal).await;
assert!(matches!(app.state.overlay, Some(OverlayKind::Spawn)));
app.dispatch(Action::OpenSpawnModal);
assert!(matches!(app.state.overlay(), Some(OverlayKind::Spawn)));
}
#[tokio::test]
async fn kill_highlighted_opens_confirm() {
/// Seed the catalog with one session and highlight it.
fn app_with_highlighted_session(sid: Uuid) -> App {
use chrono::Utc;
use maestro_protocol::{CatalogEvent, Session, SessionStatus};
let mut app = make_app();
app.catalog.apply_event(CatalogEvent::Snapshot {
sessions: vec![Session {
id: sid,
command: "bash".into(),
cwd: std::path::PathBuf::from("/"),
env: Default::default(),
metadata: Default::default(),
status: SessionStatus::Running,
created_at: Utc::now(),
foreground: None,
activity: Default::default(),
last_activity_at: Utc::now(),
current_cwd: None,
}],
});
app.dispatch(Action::SidebarNext);
app
}
#[test]
fn attach_highlighted_asks_for_an_attach() {
let sid = Uuid::from_u128(11);
let mut app = app_with_highlighted_session(sid);
assert_eq!(
app.dispatch(Action::AttachHighlighted),
vec![Effect::Attach(sid)]
);
assert_eq!(app.state.active_tab().pane, Some(sid));
}
#[test]
fn confirming_a_kill_asks_for_the_kill() {
let sid = Uuid::from_u128(12);
let mut app = app_with_highlighted_session(sid);
app.dispatch(Action::KillHighlighted);
let (decision, effects) = app.handle_overlay_input(&InputKey::Char {
c: 'y',
ctrl: false,
alt: false,
shift: false,
});
assert_eq!(decision, OverlayDecision::Consumed);
assert_eq!(effects, vec![Effect::Kill(sid)]);
assert!(app.state.overlay().is_none());
}
#[test]
fn declining_a_kill_asks_for_nothing() {
let sid = Uuid::from_u128(13);
let mut app = app_with_highlighted_session(sid);
app.dispatch(Action::KillHighlighted);
let (decision, effects) = app.handle_overlay_input(&InputKey::Esc);
assert_eq!(decision, OverlayDecision::Consumed);
assert!(effects.is_empty());
assert!(app.state.overlay().is_none());
}
#[test]
fn submitting_the_spawn_modal_carries_the_typed_fields() {
let mut app = make_app();
app.dispatch(Action::OpenSpawnModal);
app.spawn.cwd = "/srv/work".into();
app.spawn.command = "claude".into();
app.spawn.focused_field = crate::overlays::SpawnField::Submit;
let (_, effects) = app.handle_overlay_input(&InputKey::Enter);
match effects.as_slice() {
[Effect::Spawn(req)] => {
assert_eq!(req.cwd, std::path::PathBuf::from("/srv/work"));
assert_eq!(req.command, "claude");
}
other => panic!("expected one Spawn effect, got {other:?}"),
}
}
/// Regression: `Toast` returned `Pass` and nothing ever cleared it, so a
/// failure message stayed on screen until another overlay replaced it.
#[test]
fn a_toast_is_dismissed_by_the_next_key_without_eating_it() {
let mut app = make_app();
app.state.toast("spawn failed: nope");
let (decision, effects) = app.handle_overlay_input(&InputKey::Char {
c: 'j',
ctrl: false,
alt: false,
shift: false,
});
assert_eq!(
decision,
OverlayDecision::Pass,
"the keystroke should still reach the keymap"
);
assert!(effects.is_empty());
assert!(app.state.overlay().is_none(), "the toast must be gone");
}
#[test]
fn forwarding_is_a_no_op_without_an_attached_pane() {
let mut app = make_app();
assert!(app.forward_to_session(&InputKey::Enter).is_none());
}
#[test]
fn kill_highlighted_opens_confirm() {
use chrono::Utc;
use maestro_protocol::{CatalogEvent, Session, SessionStatus};
let mut app = make_app();
@@ -488,7 +647,7 @@ mod tests {
current_cwd: None,
}],
});
app.dispatch(Action::KillHighlighted).await;
assert!(matches!(app.state.overlay, Some(OverlayKind::KillConfirm(s)) if s == sid));
app.dispatch(Action::KillHighlighted);
assert!(matches!(app.state.overlay(), Some(OverlayKind::KillConfirm(s)) if *s == sid));
}
}
+1 -1
View File
@@ -137,7 +137,7 @@ pub fn draw(f: &mut Frame, inputs: RenderInputs<'_>) -> RegionMap {
// always see the current mode + key hints.
render_status_bar(f, status_area, inputs.state);
match &inputs.state.overlay {
match inputs.state.overlay() {
Some(OverlayKind::Spawn) => {
inputs.spawn.render(f, area);
map.modal = Some(area);
+74 -4
View File
@@ -39,7 +39,11 @@ pub struct AppState {
pub mode: Mode,
pub sidebar_visible: bool,
pub sidebar_highlight: Option<Uuid>,
pub overlay: Option<OverlayKind>,
/// Private: every transition goes through [`AppState::show_overlay`],
/// [`AppState::dismiss_overlay`] or [`AppState::toast`]. Poking the field
/// from four call sites is what left a toast on screen with no way to
/// clear it.
overlay: Option<OverlayKind>,
}
impl Default for AppState {
@@ -64,6 +68,24 @@ impl AppState {
}
}
pub fn overlay(&self) -> Option<&OverlayKind> {
self.overlay.as_ref()
}
pub fn show_overlay(&mut self, kind: OverlayKind) {
self.overlay = Some(kind);
}
/// Clear whatever overlay is up. Returns true if one was showing.
pub fn dismiss_overlay(&mut self) -> bool {
self.overlay.take().is_some()
}
/// Surface a transient message. Replaces any overlay currently up.
pub fn toast(&mut self, message: impl Into<String>) {
self.overlay = Some(OverlayKind::Toast(message.into()));
}
pub fn active_tab(&self) -> &Tab {
&self.tabs[self.active_tab_idx]
}
@@ -83,14 +105,21 @@ impl AppState {
/// Drop the active tab. No-op if it's the only one — there must always
/// be at least one tab.
pub fn close_tab(&mut self) {
///
/// Returns the session that tab was showing, if any, so the caller can
/// release its emulator. Without that the tab's WebSocket task and vt100
/// parser outlive the tab forever.
pub fn close_tab(&mut self) -> Option<Uuid> {
if self.tabs.len() <= 1 {
return;
return None;
}
self.tabs.remove(self.active_tab_idx);
let closed = self.tabs.remove(self.active_tab_idx);
if self.active_tab_idx >= self.tabs.len() {
self.active_tab_idx = self.tabs.len() - 1;
}
// Only release it if no other tab still shows the same session.
let still_shown = self.tabs.iter().any(|t| t.pane == closed.pane);
closed.pane.filter(|_| !still_shown)
}
pub fn next_tab(&mut self) {
@@ -277,4 +306,45 @@ mod tests {
// Doesn't force focus back; sidebar shown but focus stays where it was.
assert_eq!(state.focus, Focus::Pane);
}
/// The emulator leak: a closed tab's session must come back so the caller
/// can abort its WebSocket task.
#[test]
fn close_tab_reports_the_session_it_dropped() {
let mut state = AppState::new();
let sid = Uuid::from_u128(3);
state.new_tab();
state.active_tab_mut().pane = Some(sid);
assert_eq!(state.close_tab(), Some(sid));
}
/// ...but not while another tab still shows it.
#[test]
fn close_tab_keeps_a_session_another_tab_still_shows() {
let mut state = AppState::new();
let sid = Uuid::from_u128(4);
state.active_tab_mut().pane = Some(sid);
state.new_tab();
state.active_tab_mut().pane = Some(sid);
assert_eq!(state.close_tab(), None);
}
#[test]
fn close_tab_is_a_no_op_on_the_last_tab() {
let mut state = AppState::new();
state.active_tab_mut().pane = Some(Uuid::from_u128(5));
assert_eq!(state.close_tab(), None);
assert_eq!(state.tabs.len(), 1);
}
#[test]
fn dismiss_overlay_reports_whether_one_was_showing() {
let mut state = AppState::new();
assert!(!state.dismiss_overlay());
state.toast("boom");
assert!(state.dismiss_overlay());
assert!(state.overlay().is_none());
}
}