use std::time::Instant; use bytes::Bytes; use super::App; struct PendingAgentResumeCandidate { pane_id: crate::layout::PaneId, terminal_id: crate::terminal::TerminalId, cwd: std::path::PathBuf, plan: crate::agent_resume::AgentResumePlan, rows: u16, cols: u16, } impl App { pub(crate) fn has_pending_agent_resumes(&self) -> bool { self.state .terminals .values() .any(|terminal| terminal.pending_agent_resume_plan.is_some()) } pub(crate) fn sync_pending_agent_resume_deadline(&mut self, now: Instant) { if !self.has_pending_agent_resumes() { self.pending_agent_resume_deadline = None; return; } if self.pending_agent_resume_candidates().is_empty() { self.pending_agent_resume_deadline = None; return; } self.pending_agent_resume_deadline .get_or_insert(now + super::PENDING_AGENT_RESUME_THEME_WAIT); } pub(crate) fn pending_agent_resume_due(&self, now: Instant) -> bool { self.pending_agent_resume_deadline .is_some_and(|deadline| now >= deadline) } pub(crate) fn start_pending_agent_resumes(&mut self, allow_empty_theme: bool) -> bool { let pending = self.pending_agent_resume_candidates(); let mut changed = false; for PendingAgentResumeCandidate { pane_id, terminal_id, cwd, plan, rows, cols, } in pending { if self.terminal_runtimes.get(&terminal_id).is_some() { continue; } changed |= self.start_pending_agent_resume( pane_id, terminal_id, cwd, plan, rows, cols, allow_empty_theme, ); } if changed { self.schedule_session_save(); } if !self.has_pending_agent_resumes() || self.pending_agent_resume_candidates().is_empty() { self.pending_agent_resume_deadline = None; } changed } fn pending_agent_resume_candidates(&self) -> Vec { let Some(ws_idx) = self.state.active else { return Vec::new(); }; let Some(ws) = self.state.workspaces.get(ws_idx) else { return Vec::new(); }; let Some(tab) = ws.tabs.get(ws.active_tab) else { return Vec::new(); }; let mut pending = Vec::new(); for pane_id in tab.layout.pane_ids() { let Some(pane) = tab.panes.get(&pane_id) else { continue; }; if self .terminal_runtimes .get(&pane.attached_terminal_id) .is_some() { continue; } let Some(info) = self .state .view .pane_infos .iter() .find(|info| info.id == pane_id) else { continue; }; let Some(terminal) = self.state.terminals.get(&pane.attached_terminal_id) else { continue; }; let Some(plan) = terminal.pending_agent_resume_plan.clone() else { continue; }; pending.push(PendingAgentResumeCandidate { pane_id, terminal_id: pane.attached_terminal_id.clone(), cwd: terminal.cwd.clone(), plan, rows: info.inner_rect.height, cols: info.inner_rect.width, }); } pending } pub(crate) fn start_pending_agent_resume_for_terminal( &mut self, terminal_id: &crate::terminal::TerminalId, rows: u16, cols: u16, allow_empty_theme: bool, ) -> bool { if self.terminal_runtimes.get(terminal_id).is_some() { return false; } let Some((pane_id, cwd, plan)) = self.state.workspaces.iter().find_map(|ws| { ws.tabs.iter().find_map(|tab| { tab.layout.pane_ids().into_iter().find_map(|pane_id| { let pane = tab.panes.get(&pane_id)?; if &pane.attached_terminal_id != terminal_id { return None; } let terminal = self.state.terminals.get(terminal_id)?; Some(( pane_id, terminal.cwd.clone(), terminal.pending_agent_resume_plan.clone()?, )) }) }) }) else { return false; }; let changed = self.start_pending_agent_resume( pane_id, terminal_id.clone(), cwd, plan, rows, cols, allow_empty_theme, ); if changed { self.schedule_session_save(); } if !self.has_pending_agent_resumes() { self.pending_agent_resume_deadline = None; } changed } fn start_pending_agent_resume( &mut self, pane_id: crate::layout::PaneId, terminal_id: crate::terminal::TerminalId, cwd: std::path::PathBuf, plan: crate::agent_resume::AgentResumePlan, rows: u16, cols: u16, allow_empty_theme: bool, ) -> bool { let host_terminal_theme = self.state.host_terminal_theme; if host_terminal_theme.is_empty() && !allow_empty_theme { return false; } let Some(resume_command) = shell_command_from_argv(&plan.argv) else { tracing::warn!( pane = pane_id.raw(), terminal = %terminal_id, agent = %plan.agent, "failed to start deferred agent resume with empty argv" ); return false; }; let runtime = match crate::terminal::TerminalRuntime::spawn( pane_id, rows, cols, cwd, self.state.pane_scrollback_limit_bytes, host_terminal_theme, crate::pane::PaneShellConfig::new(&self.state.default_shell, self.state.shell_mode), self.event_tx.clone(), self.render_notify.clone(), self.render_dirty.clone(), ) { Ok(runtime) => runtime, Err(err) => { tracing::warn!( pane = pane_id.raw(), terminal = %terminal_id, agent = %plan.agent, err = %err, "failed to start shell for deferred agent resume" ); if let Some(terminal) = self.state.terminals.get_mut(&terminal_id) { terminal.clear_agent_runtime_identity_after_respawn(); } return false; } }; let mut input = resume_command; input.push('\r'); if let Err(err) = runtime.try_send_bytes(Bytes::from(input)) { tracing::warn!( pane = pane_id.raw(), terminal = %terminal_id, agent = %plan.agent, err = %err, "failed to send deferred agent resume command to shell" ); runtime.shutdown(); return false; } self.terminal_runtimes.insert(terminal_id.clone(), runtime); if let Some(terminal) = self.state.terminals.get_mut(&terminal_id) { terminal.pending_agent_resume_plan = None; terminal.respawn_shell_on_exit = false; } true } } fn shell_command_from_argv(argv: &[String]) -> Option { let mut parts = argv.iter(); let first = shell_quote(parts.next()?); let mut command = first; for part in parts { command.push(' '); command.push_str(&shell_quote(part)); } Some(command) } fn shell_quote(value: &str) -> String { if value.is_empty() { return "''".to_string(); } if value.bytes().all(|byte| { byte.is_ascii_alphanumeric() || matches!( byte, b'_' | b'-' | b'.' | b'/' | b':' | b'@' | b'%' | b'+' | b'=' ) }) { return value.to_string(); } format!("'{}'", value.replace('\'', "'\\''")) } #[cfg(test)] mod tests { use super::*; fn test_app() -> App { let (_api_tx, api_rx) = tokio::sync::mpsc::unbounded_channel(); App::new( &crate::config::Config::default(), true, None, api_rx, crate::api::EventHub::default(), ) } #[tokio::test] async fn pending_agent_resume_waits_for_host_theme_before_launch() { let mut app = test_app(); let workspace = crate::workspace::Workspace::test_new("restored"); let pane_id = workspace.tabs[0].root_pane; let terminal_id = workspace.terminal_id(pane_id).cloned().unwrap(); let pane_infos = workspace.tabs[0] .layout .panes(ratatui::layout::Rect::new(0, 0, 100, 30)); app.state.workspaces = vec![workspace]; app.state.active = Some(0); app.state.ensure_test_terminals(); app.state.view.pane_infos = pane_infos; let terminal = app .state .terminals .get_mut(&terminal_id) .expect("test terminal should exist"); terminal.pending_agent_resume_plan = Some(crate::agent_resume::AgentResumePlan { agent: "codex".into(), argv: vec![ "/bin/sh".into(), "-c".into(), "printf '%s' 'restored agent: shell quoted | marker'; sleep 5".into(), ], dedupe_key: "herdr:codex\0codex\0Id\0codex-session".into(), }); assert!(!app.start_pending_agent_resumes(false)); assert!(app.terminal_runtimes.get(&terminal_id).is_none()); app.state.host_terminal_theme = crate::terminal_theme::TerminalTheme { foreground: Some(crate::terminal_theme::RgbColor { r: 220, g: 220, b: 220, }), background: Some(crate::terminal_theme::RgbColor { r: 20, g: 20, b: 20, }), }; assert!(app.start_pending_agent_resumes(false)); assert!(app.terminal_runtimes.get(&terminal_id).is_some()); let terminal = app .state .terminals .get(&terminal_id) .expect("terminal should survive launch"); assert!(terminal.pending_agent_resume_plan.is_none()); assert!(!terminal.respawn_shell_on_exit); let runtime = app .terminal_runtimes .get(&terminal_id) .expect("pending resume should leave a shell runtime"); let marker = "restored agent: shell quoted | marker"; for _ in 0..20 { if runtime .snapshot_history() .is_some_and(|text| text.contains(marker)) { break; } tokio::time::sleep(std::time::Duration::from_millis(25)).await; } assert!( runtime .snapshot_history() .expect("runtime should expose terminal history") .contains(marker), "deferred restore should inject the resume argv into the restored shell" ); for (_, runtime) in app.terminal_runtimes.drain() { runtime.shutdown(); } } #[tokio::test] async fn pending_agent_resume_can_launch_after_theme_wait_expires() { let mut app = test_app(); let workspace = crate::workspace::Workspace::test_new("restored"); let pane_id = workspace.tabs[0].root_pane; let terminal_id = workspace.terminal_id(pane_id).cloned().unwrap(); app.state.view.pane_infos = workspace.tabs[0] .layout .panes(ratatui::layout::Rect::new(0, 0, 100, 30)); app.state.workspaces = vec![workspace]; app.state.active = Some(0); app.state.ensure_test_terminals(); app.state .terminals .get_mut(&terminal_id) .expect("test terminal should exist") .pending_agent_resume_plan = Some(crate::agent_resume::AgentResumePlan { agent: "codex".into(), argv: vec!["/bin/sh".into(), "-c".into(), "sleep 5".into()], dedupe_key: "herdr:codex\0codex\0Id\0codex-session".into(), }); app.sync_pending_agent_resume_deadline(std::time::Instant::now()); assert!(!app.start_pending_agent_resumes(false)); assert!(app.start_pending_agent_resumes(true)); assert!(app.terminal_runtimes.get(&terminal_id).is_some()); for (_, runtime) in app.terminal_runtimes.drain() { runtime.shutdown(); } } #[tokio::test] async fn pending_agent_resume_skips_hidden_panes_without_visible_geometry() { let mut app = test_app(); let active_workspace = crate::workspace::Workspace::test_new("active"); let active_pane = active_workspace.tabs[0].root_pane; let active_terminal = active_workspace.terminal_id(active_pane).cloned().unwrap(); let hidden_workspace = crate::workspace::Workspace::test_new("hidden"); let hidden_pane = hidden_workspace.tabs[0].root_pane; let hidden_terminal = hidden_workspace.terminal_id(hidden_pane).cloned().unwrap(); app.state.view.pane_infos = active_workspace.tabs[0] .layout .panes(ratatui::layout::Rect::new(0, 0, 100, 30)); app.state.workspaces = vec![active_workspace, hidden_workspace]; app.state.active = Some(0); app.state.ensure_test_terminals(); app.state.host_terminal_theme = crate::terminal_theme::TerminalTheme { foreground: Some(crate::terminal_theme::RgbColor { r: 220, g: 220, b: 220, }), background: Some(crate::terminal_theme::RgbColor { r: 20, g: 20, b: 20, }), }; for terminal_id in [&active_terminal, &hidden_terminal] { app.state .terminals .get_mut(terminal_id) .expect("test terminal should exist") .pending_agent_resume_plan = Some(crate::agent_resume::AgentResumePlan { agent: "codex".into(), argv: vec!["/bin/sh".into(), "-c".into(), "sleep 5".into()], dedupe_key: format!("herdr:codex\0codex\0Id\0{terminal_id}"), }); } app.pending_agent_resume_deadline = Some(std::time::Instant::now() - std::time::Duration::from_millis(1)); assert!(app.start_pending_agent_resumes(false)); assert!(app.terminal_runtimes.get(&active_terminal).is_some()); assert!(app.terminal_runtimes.get(&hidden_terminal).is_none()); assert!( app.pending_agent_resume_deadline.is_none(), "hidden-only pending resumes should not keep an expired wakeup deadline active" ); assert!( app.state .terminals .get(&hidden_terminal) .expect("hidden terminal should still exist") .pending_agent_resume_plan .is_some(), "hidden restored panes should wait until their tab has computed geometry" ); for (_, runtime) in app.terminal_runtimes.drain() { runtime.shutdown(); } } #[tokio::test] async fn pending_agent_resume_ignores_stale_geometry_from_previous_active_view() { let mut app = test_app(); let previous_workspace = crate::workspace::Workspace::test_new("previous"); let previous_pane = previous_workspace.tabs[0].root_pane; let previous_terminal = previous_workspace .terminal_id(previous_pane) .cloned() .unwrap(); let current_workspace = crate::workspace::Workspace::test_new("current"); app.state.view.pane_infos = previous_workspace.tabs[0] .layout .panes(ratatui::layout::Rect::new(0, 0, 100, 30)); app.state.workspaces = vec![previous_workspace, current_workspace]; app.state.active = Some(1); app.state.ensure_test_terminals(); app.state.host_terminal_theme = crate::terminal_theme::TerminalTheme { foreground: Some(crate::terminal_theme::RgbColor { r: 220, g: 220, b: 220, }), background: Some(crate::terminal_theme::RgbColor { r: 20, g: 20, b: 20, }), }; app.state .terminals .get_mut(&previous_terminal) .expect("test terminal should exist") .pending_agent_resume_plan = Some(crate::agent_resume::AgentResumePlan { agent: "codex".into(), argv: vec!["/bin/sh".into(), "-c".into(), "sleep 5".into()], dedupe_key: "herdr:codex\0codex\0Id\0codex-session".into(), }); app.sync_pending_agent_resume_deadline(std::time::Instant::now()); assert!(app.pending_agent_resume_deadline.is_none()); assert!(!app.start_pending_agent_resumes(false)); assert!(app.terminal_runtimes.get(&previous_terminal).is_none()); assert!( app.state .terminals .get(&previous_terminal) .expect("previous terminal should still exist") .pending_agent_resume_plan .is_some(), "a pane hidden by navigation should wait for a fresh visible geometry snapshot" ); } #[tokio::test] async fn pending_agent_resume_launches_with_inner_rect_size() { let mut app = test_app(); let mut workspace = crate::workspace::Workspace::test_new("split"); let pane_id = workspace.test_split(ratatui::layout::Direction::Horizontal); let terminal_id = workspace.terminal_id(pane_id).cloned().unwrap(); app.state.view.pane_infos = vec![crate::layout::PaneInfo { id: pane_id, rect: ratatui::layout::Rect::new(0, 0, 100, 30), inner_rect: ratatui::layout::Rect::new(1, 1, 98, 28), scrollbar_rect: None, is_focused: true, }]; app.state.workspaces = vec![workspace]; app.state.active = Some(0); app.state.ensure_test_terminals(); app.state.host_terminal_theme = crate::terminal_theme::TerminalTheme { foreground: Some(crate::terminal_theme::RgbColor { r: 220, g: 220, b: 220, }), background: Some(crate::terminal_theme::RgbColor { r: 20, g: 20, b: 20, }), }; app.state .terminals .get_mut(&terminal_id) .expect("test terminal should exist") .pending_agent_resume_plan = Some(crate::agent_resume::AgentResumePlan { agent: "codex".into(), argv: vec!["/bin/sh".into(), "-c".into(), "sleep 5".into()], dedupe_key: "herdr:codex\0codex\0Id\0codex-session".into(), }); assert!(app.start_pending_agent_resumes(false)); assert_eq!( app.terminal_runtimes .get(&terminal_id) .expect("pending resume should launch") .current_size(), (28, 98) ); for (_, runtime) in app.terminal_runtimes.drain() { runtime.shutdown(); } } #[test] fn shell_command_from_argv_quotes_resume_arguments() { let argv = vec![ "claude".to_string(), "--resume".to_string(), "session with ' quote".to_string(), ]; assert_eq!( shell_command_from_argv(&argv).as_deref(), Some("claude --resume 'session with '\\'' quote'") ); assert_eq!(shell_command_from_argv(&[]), None); } }