From f71db5bcd3816a1edb15ed373572524518965e67 Mon Sep 17 00:00:00 2001 From: galact <94279960+galact-byte@users.noreply.github.com> Date: Sat, 26 Sep 2026 23:42:50 +0800 Subject: [PATCH 1/2] feat: collect per-pane command output and map local snapshots --- nebula_app/src/gpui_shell/config.rs | 2 + nebula_app/src/gpui_shell/terminal/view.rs | 16 +- .../gpui_shell/terminal/view/completion.rs | 4 +- .../src/gpui_shell/terminal/view/pointer.rs | 5 +- .../gpui_shell/terminal/view/recent_output.rs | 134 +++++ .../terminal/view/recent_output_tests.rs | 472 ++++++++++++++++++ .../src/gpui_shell/terminal/view/runtime.rs | 5 + .../src/gpui_shell/terminal/view/startup.rs | 6 + .../workspace/session_persistence.rs | 170 ++++++- .../session_persistence/local_snapshot.rs | 302 +++++++++++ .../gpui_shell/workspace/session_recovery.rs | 60 ++- nebula_settings/src/lib.rs | 21 + nebula_settings/src/reset.rs | 1 + 13 files changed, 1179 insertions(+), 19 deletions(-) create mode 100644 nebula_app/src/gpui_shell/terminal/view/recent_output.rs create mode 100644 nebula_app/src/gpui_shell/terminal/view/recent_output_tests.rs create mode 100644 nebula_app/src/gpui_shell/workspace/session_persistence/local_snapshot.rs diff --git a/nebula_app/src/gpui_shell/config.rs b/nebula_app/src/gpui_shell/config.rs index 0ad33363b..3fa4e69bf 100644 --- a/nebula_app/src/gpui_shell/config.rs +++ b/nebula_app/src/gpui_shell/config.rs @@ -76,6 +76,7 @@ pub struct Settings { pub cursor_blink: Option, /// 选区完成即复制(旧壳 `copy_on_select` 设置)。 pub copy_on_select: bool, + pub(crate) command_output_enabled: bool, pub scrollback_lines: usize, pub scroll_speed: f32, /// Pointer handlers and split rendering only read these cached preferences. @@ -280,6 +281,7 @@ impl Settings { }), cursor_blink: runtime.cursor_blink, copy_on_select: runtime.copy_on_select, + command_output_enabled: runtime.command_output_enabled(), scrollback_lines: runtime.scrollback_lines, scroll_speed: runtime.scroll_speed, focus_follows_mouse: runtime diff --git a/nebula_app/src/gpui_shell/terminal/view.rs b/nebula_app/src/gpui_shell/terminal/view.rs index a3a488db8..23d03f9c8 100644 --- a/nebula_app/src/gpui_shell/terminal/view.rs +++ b/nebula_app/src/gpui_shell/terminal/view.rs @@ -16,6 +16,9 @@ mod notifications; mod output_tests; mod path_drop; mod pointer; +mod recent_output; +#[cfg(test)] +mod recent_output_tests; mod runtime; mod startup; mod startup_command; @@ -305,6 +308,10 @@ pub struct TerminalView { /// `NEBULA|` 标题报 `running_program`,装了 OSC133 集成的 bash/zsh/nu 只 /// 发这一对语义标记——两条路都要能点亮侧栏的「运行中」。 command_running: bool, + recent_output: crate::recent_output::RecentOutput, + recent_output_restore_closed: bool, + recent_output_enabled: bool, + restored_viewport_offset: Option, /// 进程树给出的反证:`command_running` 为真、但 shell 树下只剩交互式 /// shell 与 console plumbing 时置位,转圈据此熄灭(issue #42)。判据与 /// 节流都在 `runtime::reconcile_shell_activity`,裁定理由见那里。 @@ -531,6 +538,7 @@ impl TerminalView { } match event { TermEvent::Wakeup => { + self.follow_restored_viewport(); self.flush_pending_runtime_submit(cx); self.flush_pending_shell_command(cx); if self.output_visible { @@ -739,11 +747,14 @@ impl TerminalView { if !preserves_prompt { term.nebula_end_prompt(); } - term.scroll_display(Scroll::Bottom); + if self.restored_viewport_offset.is_none() { + term.scroll_display(Scroll::Bottom); + } term.selection = None; } session.notifier.notify(bytes); } + self.follow_restored_viewport(); self.sync_native_prompt(); self.restart_cursor_blink(cx); cx.notify(); @@ -879,6 +890,7 @@ impl TerminalView { let font_size = px(settings.font_size_px); let palette = Arc::new(settings.palette.clone()); let copy_on_select = settings.copy_on_select; + let command_output_enabled = settings.command_output_enabled; let default_cursor_style = settings.term_config().default_cursor_style; let cursor_style_changed = self.default_cursor_style != default_cursor_style; self.ghost_enabled = settings.ghost; @@ -928,6 +940,7 @@ impl TerminalView { term.reset_cursor_style_override(); } } + self.set_recent_output_enabled(command_output_enabled); self.restart_cursor_blink(cx); cx.notify(); } @@ -1189,6 +1202,7 @@ impl TerminalView { }; if let Some(scroll) = scroll { if let Some(session) = &self.session { + self.restored_viewport_offset = None; session.term.lock().scroll_display(scroll); } cx.notify(); diff --git a/nebula_app/src/gpui_shell/terminal/view/completion.rs b/nebula_app/src/gpui_shell/terminal/view/completion.rs index 20e5fedc3..a80fbc605 100644 --- a/nebula_app/src/gpui_shell/terminal/view/completion.rs +++ b/nebula_app/src/gpui_shell/terminal/view/completion.rs @@ -6,7 +6,7 @@ use nebula_terminal::term::TermMode; impl TerminalView { /// Enter 提交:从 grid 读回显真值(screen truth)记入共享历史,然后清 - /// 行镜像。读法与旧壳 `nebula_commit_line` 的 Windows 契约一致:无法证明 + /// 行镜像。所有平台共享提示符/OSC 边界确认:无法证明 /// 是提示符的 REPL 行或中线编辑读不到就宁缺毋滥——键击重构的 /// line_buf 在光标移动/Tab 补全后就是拼接垃圾,不能进历史。Agent 已在 /// 前台时保留最初 shell 提示符,内部交互的 Enter 不得覆盖退出证据。 @@ -27,7 +27,6 @@ impl TerminalView { return; } self.suggest.pending_command_prompt = None; - #[cfg(windows)] if let Some(session) = &self.session { let term = session.term.lock(); if !term.mode().intersects(TermMode::ALT_SCREEN | TermMode::VI) { @@ -56,6 +55,7 @@ impl TerminalView { && !self.suggest.screen_line.trim().is_empty(); suggest::commit_line(&mut self.suggest); if confirmed_submission { + self.begin_recent_output(); self.mark_submitted_command(native_submission); cx.notify(); } diff --git a/nebula_app/src/gpui_shell/terminal/view/pointer.rs b/nebula_app/src/gpui_shell/terminal/view/pointer.rs index a5f6221d6..a78916269 100644 --- a/nebula_app/src/gpui_shell/terminal/view/pointer.rs +++ b/nebula_app/src/gpui_shell/terminal/view/pointer.rs @@ -99,11 +99,12 @@ impl TerminalView { } /// 把回滚位置落到 `target`(滚动条拖拽的落点提交)。 - pub(super) fn scroll_to_offset(&self, target: usize, current: usize) { + pub(super) fn scroll_to_offset(&mut self, target: usize, current: usize) { if target == current { return; } if let Some(session) = &self.session { + self.restored_viewport_offset = None; session.term.lock().scroll_display(Scroll::Delta(target as i32 - current as i32)); } } @@ -724,6 +725,7 @@ impl TerminalView { return true; } if let Some(session) = &self.session { + self.restored_viewport_offset = None; session.term.lock().scroll_display(Scroll::Delta(lines)); } // 滚动换了视口到绝对行的映射,选区末端必须按滚动后的网格重算—— @@ -913,6 +915,7 @@ impl TerminalView { } session.notifier.notify(bytes); } else { + self.restored_viewport_offset = None; session.term.lock().scroll_display(Scroll::Delta(lines)); } cx.notify(); diff --git a/nebula_app/src/gpui_shell/terminal/view/recent_output.rs b/nebula_app/src/gpui_shell/terminal/view/recent_output.rs new file mode 100644 index 000000000..67d3b6281 --- /dev/null +++ b/nebula_app/src/gpui_shell/terminal/view/recent_output.rs @@ -0,0 +1,134 @@ +//! 命令恢复只消费已确认的 shell 提交,不从运行徽章推断提交。 + +use super::TerminalView; +use nebula_terminal::term::TermMode; + +impl TerminalView { + pub(crate) fn restore_output_batch( + path: std::path::PathBuf, + targets: Vec<(String, gpui::WeakEntity)>, + cx: &mut gpui::App, + ) { + if targets.is_empty() { + return; + } + let read = cx + .background_executor() + .spawn(async move { crate::recent_output::storage::Archive::read_from(&path) }); + cx.spawn(async move |cx| { + let mut archive = match read.await { + Ok(archive) => archive, + Err(error) => { + if error.kind() != std::io::ErrorKind::NotFound { + log::warn!("Could not restore command output: {error}"); + } + return; + }, + }; + for (id, target) in targets { + let Some(records) = archive.take_records(&id) else { continue }; + let _ = target.update(cx, |view, cx| { + if view.exited.is_some() { + return; + } + if let Err(error) = view.restore_recent_output(records, cx) { + log::warn!("Invalid saved command output: {error}"); + } + }); + } + }) + .detach(); + } + + pub(crate) fn set_recent_output_enabled(&mut self, enabled: bool) { + self.recent_output_enabled = enabled; + if !enabled { + self.clear_recent_output(); + } + } + + pub(crate) fn clear_recent_output(&mut self) { + self.recent_output = crate::recent_output::RecentOutput::default(); + self.recent_output_restore_closed = true; + } + + pub(crate) fn restore_recent_output( + &mut self, + records: Vec, + cx: &mut gpui::Context, + ) -> Result { + if !self.recent_output_enabled || self.recent_output_restore_closed { + return Ok(false); + } + let Some(session) = &self.session else { return Ok(false) }; + let recent = crate::recent_output::RecentOutput::try_from_records(records)?; + let mut term = session.term.lock(); + if term.mode().contains(TermMode::ALT_SCREEN) { + return Ok(false); + } + recent.restore(term.grid_mut())?; + // 恢复内容位于主屏之前;只移动视口,不改 ConPTY 的绝对光标坐标。 + // 新输出逐步占用主屏下方空行,输入不能提前隐藏恢复内容。 + let grid = term.grid(); + use nebula_terminal::grid::Dimensions; + let room = grid.screen_lines().saturating_sub(grid.cursor.point.line.0 as usize + 1); + let offset = room.min(grid.history_size()); + term.scroll_display(nebula_terminal::grid::Scroll::Bottom); + term.scroll_display(nebula_terminal::grid::Scroll::Delta(offset as i32)); + self.restored_viewport_offset = (offset > 0).then_some(offset); + self.recent_output = recent; + self.recent_output_restore_closed = true; + drop(term); + cx.notify(); + Ok(true) + } + + pub(super) fn follow_restored_viewport(&mut self) { + use nebula_terminal::grid::{Dimensions, Scroll}; + let Some(_) = self.restored_viewport_offset else { return }; + let Some(session) = &self.session else { return }; + let mut term = session.term.lock(); + if term.mode().intersects(TermMode::ALT_SCREEN | TermMode::VI) { + self.restored_viewport_offset = None; + return; + } + let grid = term.grid(); + let room = grid.screen_lines().saturating_sub(grid.cursor.point.line.0 as usize + 1); + // 恢复跟随期间用空白容量容纳历史;宽度重排可能增加历史行数, + // 不能沿用恢复时的旧 offset,否则会截掉长命令的开头。 + let current = grid.display_offset(); + let offset = room.min(grid.history_size()); + if current != offset { + term.scroll_display(Scroll::Delta(offset as i32 - current as i32)); + } + self.restored_viewport_offset = (offset > 0).then_some(offset); + } + + pub(super) fn begin_recent_output(&mut self) { + if !self.recent_output_enabled { + return; + } + let Some(session) = &self.session else { return }; + let term = session.term.lock(); + if !term.mode().intersects(TermMode::ALT_SCREEN | TermMode::VI) { + self.recent_output_restore_closed = true; + self.recent_output.finish(term.grid()); + self.recent_output.begin(term.grid()); + } + } + + pub(super) fn finish_recent_output(&mut self) { + let Some(session) = &self.session else { return }; + let term = session.term.lock(); + self.recent_output.finish(term.primary_grid()); + } + + pub(crate) fn recent_output_snapshot(&self) -> Vec { + if !self.recent_output_enabled { + return Vec::new(); + } + let Some(session) = &self.session else { return Vec::new() }; + let term = session.term.lock(); + self.recent_output.snapshot(term.primary_grid()) + } +} diff --git a/nebula_app/src/gpui_shell/terminal/view/recent_output_tests.rs b/nebula_app/src/gpui_shell/terminal/view/recent_output_tests.rs new file mode 100644 index 000000000..096cab93e --- /dev/null +++ b/nebula_app/src/gpui_shell/terminal/view/recent_output_tests.rs @@ -0,0 +1,472 @@ +use super::*; +use gpui::TestAppContext; +use startup_tests::{feed, open}; + +fn prompt(view: &mut TerminalView, input: &str) { + view.suggest.suggest_env = crate::display::SuggestEnv::Local; + feed(view, format!("\x1b]133;A\x07C:\\work>\x1b]133;B\x07\x1b]1337;SetUserVar=pebrel_cmd_prompt=MQ==\x07{input}").as_bytes()); +} + +fn restored_text(view: &TerminalView) -> String { + let recent = + crate::recent_output::RecentOutput::try_from_records(view.recent_output_snapshot()) + .unwrap(); + let (session, _) = session::test_session(); + let mut term = session.term.lock(); + recent.restore(term.grid_mut()).unwrap(); + use nebula_terminal::grid::Dimensions; + term.bounds_to_string( + TermPoint::new(Line(-(term.grid().history_size() as i32)), Column(0)), + TermPoint::new(Line(-1), Column(term.columns() - 1)), + ) +} + +#[gpui::test] +fn confirmed_shell_submission_captures_output_but_not_later_idle_input(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + prompt(view, "echo saved"); + view.commit_line(cx); + view.write_input(b"\r".to_vec(), cx); + feed(view, b"\r\nsaved result\r\n"); + prompt(view, ""); + view.finish_foreground_command(Some(0), cx); + feed(view, b"not-submitted"); + let text = restored_text(view); + assert!(text.contains("echo saved"), "{text:?}"); + assert!(text.contains("saved result")); + assert!(!text.contains("not-submitted")); + assert_eq!(view.recent_output_snapshot().len(), 1); + }); +} + +#[gpui::test] +fn empty_enter_and_foreground_password_do_not_create_records(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + prompt(view, ""); + view.commit_line(cx); + assert!(view.recent_output_snapshot().is_empty()); + feed(view, b"tool"); + view.commit_line(cx); + view.write_input(b"\r".to_vec(), cx); + feed(view, b"\r\nPassword: "); + view.suggest.line_buf = "invisible-secret".into(); + view.commit_line(cx); + assert_eq!(view.recent_output_snapshot().len(), 1); + assert!(!restored_text(view).contains("invisible-secret")); + }); +} + +#[gpui::test] +fn alternate_screen_keeps_main_output_and_never_saves_tui_input(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + prompt(view, "tool"); + view.commit_line(cx); + view.write_input(b"\r".to_vec(), cx); + feed(view, b"\r\nmain output\x1b[?1049hTUI private input"); + let text = restored_text(view); + assert!(text.contains("main output"), "{text:?}"); + assert!(!text.contains("TUI private input"), "{text:?}"); + feed(view, b"\x1b[?1049l\r\n"); + prompt(view, ""); + view.finish_foreground_command(Some(0), cx); + assert!(restored_text(view).contains("main output")); + }); +} + +#[gpui::test] +fn cold_restore_inserts_once_without_executing_or_replacing_prompt(cx: &mut TestAppContext) { + let (source, window, _) = open(cx); + let records = source.update(window, |view, cx| { + prompt(view, "echo old-marker"); + view.commit_line(cx); + view.write_input(b"\r".to_vec(), cx); + feed(view, b"\r\nold-result\r\n"); + prompt(view, ""); + view.finish_foreground_command(Some(0), cx); + view.recent_output_snapshot() + }); + let (target, target_window, _) = open(cx); + target.update(target_window, |view, cx| { + prompt(view, ""); + let before = view.session.as_ref().unwrap().term.lock().grid().cursor.point; + assert!(view.restore_recent_output(records.clone(), cx).unwrap()); + assert!(!view.restore_recent_output(records, cx).unwrap()); + assert!(!view.command_running); + assert!(view.active_run.is_none()); + assert_eq!(view.recent_output_snapshot().len(), 1); + let term = view.session.as_ref().unwrap().term.lock(); + use nebula_terminal::grid::Dimensions; + assert_eq!(term.grid().cursor.point, before); + let text = term.bounds_to_string( + TermPoint::new(Line(-(term.grid().history_size() as i32)), Column(0)), + TermPoint::new(Line(-1), Column(term.columns() - 1)), + ); + assert_eq!(text.matches("echo old-marker").count(), 1, "{text:?}"); + assert_eq!(text.matches("old-result").count(), 1, "{text:?}"); + let origin = term.viewport_origin_for(term.screen_lines()); + let visible = term.bounds_to_string( + TermPoint::new(origin, Column(0)), + TermPoint::new(origin + term.screen_lines() - 1, Column(term.columns() - 1)), + ); + assert!(visible.contains("old-result"), "restored output must be visible: {visible:?}"); + assert!(visible.contains("C:\\work>"), "live prompt must remain visible: {visible:?}"); + }); +} + +#[gpui::test] +fn restored_output_follows_input_until_live_screen_fills(cx: &mut TestAppContext) { + let (source, window, _) = open(cx); + let records = source.update(window, |view, cx| { + prompt(view, "echo old-marker"); + view.commit_line(cx); + feed(view, b"\r\nold-result\r\n"); + prompt(view, ""); + view.finish_foreground_command(Some(0), cx); + view.recent_output_snapshot() + }); + let (target, window, _) = open(cx); + target.update(window, |view, cx| { + prompt(view, ""); + view.restore_recent_output(records, cx).unwrap(); + let offset = view.session.as_ref().unwrap().term.lock().grid().display_offset(); + assert!(offset > 0); + view.write_input(b"e".to_vec(), cx); + feed(view, b"e"); + view.process_event(TermEvent::Wakeup, cx); + assert_eq!(view.session.as_ref().unwrap().term.lock().grid().display_offset(), offset); + feed(view, b"\r\nnext-output\r\n"); + view.process_event(TermEvent::Wakeup, cx); + assert_eq!(view.session.as_ref().unwrap().term.lock().grid().display_offset(), offset); + feed(view, "\r\nnew-line".repeat(40).as_bytes()); + view.process_event(TermEvent::Wakeup, cx); + assert_eq!(view.session.as_ref().unwrap().term.lock().grid().display_offset(), 0); + }); +} + +#[gpui::test] +fn restored_long_command_stays_visible_when_startup_layout_narrows(cx: &mut TestAppContext) { + let (source, window, _) = open(cx); + let records = source.update(window, |view, cx| { + prompt(view, "echo long-command-marker-1234567890"); + view.commit_line(cx); + feed(view, b"\r\nold-result\r\n"); + prompt(view, ""); + view.finish_foreground_command(Some(0), cx); + view.recent_output_snapshot() + }); + let (target, window, _) = open(cx); + target.update(window, |view, cx| { + prompt(view, ""); + view.restore_recent_output(records, cx).unwrap(); + view.session + .as_ref() + .unwrap() + .term + .lock() + .resize(session::GridSize { columns: 24, screen_lines: 24 }); + view.process_event(TermEvent::Wakeup, cx); + let term = view.session.as_ref().unwrap().term.lock(); + use nebula_terminal::grid::Dimensions; + let origin = term.viewport_origin_for(term.screen_lines()); + let visible = term.bounds_to_string( + TermPoint::new(origin, Column(0)), + TermPoint::new(origin + term.screen_lines() - 1, Column(term.columns() - 1)), + ); + assert!(visible.contains("C:\\work>echo long-command-marker-1234567890"), "{visible:?}"); + assert!(visible.contains("old-result"), "{visible:?}"); + }); +} + +#[gpui::test] +fn manual_scroll_after_restore_keeps_normal_input_return_to_bottom(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + feed(view, "old-line\r\n".repeat(40).as_bytes()); + view.session.as_ref().unwrap().term.lock().scroll_display(Scroll::Delta(3)); + view.restored_viewport_offset = Some(3); + view.scroll_to_offset(5, 3); + view.process_event(TermEvent::Wakeup, cx); + assert_eq!(view.session.as_ref().unwrap().term.lock().grid().display_offset(), 5); + view.write_input(b"e".to_vec(), cx); + assert_eq!(view.session.as_ref().unwrap().term.lock().grid().display_offset(), 0); + assert_eq!(view.restored_viewport_offset, None); + }); +} + +#[gpui::test] +fn alternate_screen_ends_restore_follow_without_scrolling_the_application(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + feed(view, "old-line\r\n".repeat(40).as_bytes()); + view.session.as_ref().unwrap().term.lock().scroll_display(Scroll::Delta(3)); + view.restored_viewport_offset = Some(3); + feed(view, b"\x1b[?1049hfull-screen"); + view.process_event(TermEvent::Wakeup, cx); + assert_eq!(view.restored_viewport_offset, None); + assert_eq!(view.session.as_ref().unwrap().term.lock().grid().display_offset(), 0); + feed(view, b"\x1b[?1049l"); + view.write_input(b"e".to_vec(), cx); + assert_eq!(view.session.as_ref().unwrap().term.lock().grid().display_offset(), 0); + }); +} + +#[gpui::test] +fn late_restore_does_not_replace_commands_submitted_since_startup(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + prompt(view, "echo new-command"); + view.commit_line(cx); + assert!(!view.restore_recent_output(Vec::new(), cx).unwrap()); + assert!(restored_text(view).contains("echo new-command")); + }); +} + +#[gpui::test] +fn disabled_capture_does_not_collect_commands_or_accept_restore(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + view.set_recent_output_enabled(false); + prompt(view, "echo do-not-save"); + view.commit_line(cx); + feed(view, b"\r\nprivate output\r\n"); + view.finish_foreground_command(Some(0), cx); + assert!(view.recent_output_snapshot().is_empty()); + assert!(!view.restore_recent_output(Vec::new(), cx).unwrap()); + view.set_recent_output_enabled(true); + prompt(view, "echo allowed"); + view.commit_line(cx); + assert_eq!(view.recent_output_snapshot().len(), 1); + }); +} + +#[gpui::test] +fn disabling_capture_clears_memory_and_stops_active_output(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + prompt(view, "tool"); + view.commit_line(cx); + feed(view, b"\r\nbefore\r\n"); + assert_eq!(view.recent_output_snapshot().len(), 1); + view.set_recent_output_enabled(false); + view.set_recent_output_enabled(true); + feed(view, b"after-enable"); + view.finish_foreground_command(Some(0), cx); + assert!(view.recent_output_snapshot().is_empty()); + }); +} + +#[gpui::test] +fn loaded_settings_disable_existing_and_new_terminal_capture(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + for raw in ["save_command_output=0", "restore_session=0\nsave_command_output=1"] { + view.update(window, |view, cx| { + let settings = Settings::load_with_runtime( + nebula_settings::ThemeName::Nord, + nebula_settings::RuntimeSettings::from_raw( + &nebula_settings::RawSettings::from_text(raw), + ), + ); + cx.set_global(settings); + view.apply_settings(cx); + prompt(view, "echo private"); + view.commit_line(cx); + assert!(view.recent_output_snapshot().is_empty(), "{raw}"); + }); + window.update(|window, cx| { + let new_view = cx.new(|cx| { + TerminalView::new( + 43, + (80, 24), + TerminalLaunch::Local { + cwd: None, + shell: Some(nebula_terminal::tty::Shell::new( + "pebrel-test-missing-shell-executable".into(), + vec![], + )), + shell_name: None, + }, + window, + cx, + ) + }); + assert!(!new_view.read(cx).recent_output_enabled, "{raw}"); + }); + } +} + +#[gpui::test] +fn batch_restore_reads_exact_references_and_skips_changed_panes(cx: &mut TestAppContext) { + let (source, window, _) = open(cx); + let records = source.update(window, |view, cx| { + prompt(view, "echo batch-marker"); + view.commit_line(cx); + feed(view, b"\r\nbatch-result\r\n"); + view.finish_foreground_command(Some(0), cx); + view.recent_output_snapshot() + }); + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + crate::recent_output::storage::Archive::new(std::collections::BTreeMap::from([ + ("first".into(), records.clone()), + ("changed".into(), records.clone()), + ("disabled".into(), records), + ])) + .write_to(&path) + .unwrap(); + let (changed, changed_window, _) = open(cx); + changed.update(changed_window, |view, cx| { + prompt(view, "echo new-command"); + view.commit_line(cx); + }); + let (disabled, disabled_window, _) = open(cx); + disabled.update(disabled_window, |view, _| view.set_recent_output_enabled(false)); + let (missing, _, _) = open(cx); + let (first, first_window, _) = open(cx); + first_window.update(|_, cx| { + TerminalView::restore_output_batch( + path, + vec![ + ("first".into(), first.downgrade()), + ("changed".into(), changed.downgrade()), + ("disabled".into(), disabled.downgrade()), + ("missing".into(), missing.downgrade()), + ], + cx, + ); + }); + first_window.run_until_parked(); + first.update(first_window, |view, _| { + assert!(restored_text(view).contains("batch-marker")); + assert!(!view.command_running); + }); + changed.update(first_window, |view, _| { + assert!(restored_text(view).contains("new-command")); + assert!(!restored_text(view).contains("batch-marker")); + }); + disabled.update(first_window, |view, _| assert!(view.recent_output_snapshot().is_empty())); + missing.update(first_window, |view, _| assert!(view.recent_output_snapshot().is_empty())); +} + +// Unlike startup_tests::feed, this drives the production OSC prompt lifecycle +// as well as VT parsing, without depending on the host OS or a native CMD marker. +fn shell_output(view: &mut TerminalView, bytes: &[u8], cx: &mut Context) { + let (_session, _input, mut events, proxy) = session::test_session_with_events(); + nebula_terminal::event_loop::StreamProcessor::default().feed( + &mut view.session.as_ref().unwrap().term.lock(), + &proxy, + bytes, + ); + while let Ok(event) = events.try_recv() { + view.process_event(event, cx); + } +} + +#[gpui::test] +fn local_unix_prompts_capture_commands_with_and_without_osc(cx: &mut TestAppContext) { + for (prefix, prompt) in [("", "dev@host:~/work$ "), ("\x1b]133;A\x07", "host% ")] { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + view.suggest.suggest_env = crate::display::SuggestEnv::Local; + shell_output(view, format!("{prefix}{prompt}printf saved").as_bytes(), cx); + view.suggest.line_buf = "printf saved".into(); + view.commit_line(cx); + assert_eq!(view.recent_output_snapshot().len(), 1); + view.write_input(b"\r".to_vec(), cx); + shell_output(view, b"\r\n\x1b]133;C\x07saved result\r\n\x1b]133;D;0\x07", cx); + shell_output(view, format!("{prefix}{prompt}not-submitted").as_bytes(), cx); + let text = restored_text(view); + assert!(text.contains("printf saved"), "{text:?}"); + assert!(text.contains("saved result"), "{text:?}"); + assert!(!text.contains("not-submitted"), "{text:?}"); + assert!(!view.command_running); + assert!(!view.native_prompt_seen); + }); + } +} + +#[gpui::test] +fn semantic_shell_prompt_uses_echo_not_stale_mirror_and_starts_next_record( + cx: &mut TestAppContext, +) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + view.suggest.suggest_env = crate::display::SuggestEnv::Local; + for command in ["printf first", "printf second"] { + shell_output( + view, + format!("\x1b]133;A\x07custom :: \x1b]133;B\x07{command}").as_bytes(), + cx, + ); + view.suggest.line_buf = "stale-private-mirror".into(); + view.suggest.screen_line = "stale-screen".into(); + view.commit_line(cx); + assert_eq!(view.suggest.last_committed, command); + view.write_input(b"\r".to_vec(), cx); + shell_output(view, b"\r\n\x1b]133;C\x07result\r\n\x1b]133;D;0\x07", cx); + } + assert_eq!(view.recent_output_snapshot().len(), 2); + let text = restored_text(view); + assert!(text.find("printf first").unwrap() < text.find("printf second").unwrap()); + assert!(!text.contains("stale-private-mirror")); + assert!(!text.contains("stale-screen")); + }); +} + +#[gpui::test] +fn unconfirmed_unix_input_never_starts_output_capture(cx: &mut TestAppContext) { + for (screen, mirror) in [ + ("dev@host:~/work$ ", ""), + ("dev@host:~/work$ ", " "), + ("\x1b]133;A\x07custom :: \x1b]133;B\x07", "stale-private-mirror"), + ("Password: ", "invisible-secret"), + ("dev@host:~/work$ printf actual", "printf stale"), + ("\x1b]133;A\x07custom :: \x1b]133;B\x07\x1b]133;C\x07\r\nPassword: ", "invisible-secret"), + ("\x1b[?1049hdev@host:~/work$ tui-input", "tui-input"), + ] { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + view.suggest.suggest_env = crate::display::SuggestEnv::Local; + shell_output(view, screen.as_bytes(), cx); + view.suggest.line_buf = mirror.into(); + view.suggest.screen_line = "stale-screen".into(); + view.suggest.pending_command_prompt = Some("stale-prompt".into()); + view.commit_line(cx); + assert!(view.recent_output_snapshot().is_empty(), "{screen:?}"); + assert!(!view.recent_output_restore_closed, "{screen:?}"); + }); + } +} + +#[gpui::test] +fn agent_internal_enter_does_not_create_a_second_shell_record(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + view.suggest.suggest_env = crate::display::SuggestEnv::Local; + shell_output(view, b"\x1b]133;A\x07dev@host:~$ \x1b]133;B\x07pi", cx); + view.commit_line(cx); + view.write_input(b"\r".to_vec(), cx); + shell_output(view, b"\r\n\x1b]133;C\x07", cx); + feed(view, "❯ tool input".as_bytes()); + view.suggest.line_buf = "tool input".into(); + view.commit_line(cx); + assert_eq!(view.recent_output_snapshot().len(), 1); + assert_eq!(view.suggest.last_committed, "pi"); + }); +} + +#[gpui::test] +fn runtime_submission_records_echo_only_after_barrier(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + prompt(view, ""); + view.runtime_prompt("echo runtime".into(), true, cx).unwrap(); + assert!(view.recent_output_snapshot().is_empty()); + feed(view, b"echo runtime"); + view.flush_pending_runtime_submit(cx); + assert_eq!(view.recent_output_snapshot().len(), 1); + assert!(restored_text(view).contains("echo runtime")); + }); +} diff --git a/nebula_app/src/gpui_shell/terminal/view/runtime.rs b/nebula_app/src/gpui_shell/terminal/view/runtime.rs index 194022534..43799a43a 100644 --- a/nebula_app/src/gpui_shell/terminal/view/runtime.rs +++ b/nebula_app/src/gpui_shell/terminal/view/runtime.rs @@ -162,6 +162,7 @@ impl TerminalView { exit_code: Option, cx: &mut Context, ) { + self.finish_recent_output(); let choose_codex_session = self.codex_restore_target_missing(exit_code); self.notify_command_done(exit_code, cx); self.last_command_failed = exit_code.is_some_and(|code| code != 0); @@ -1075,6 +1076,10 @@ impl TerminalView { return; } let pending = self.pending_runtime_submit.take().expect("checked above"); + // 运行徽章在 echo 前已置位;只有启动前捕获的 shell 提示符允许记录。 + if self.suggest.pending_command_prompt.is_some() && self.runtime_agent().is_none() { + self.begin_recent_output(); + } self.write_input(pending.submit_bytes, cx); } } diff --git a/nebula_app/src/gpui_shell/terminal/view/startup.rs b/nebula_app/src/gpui_shell/terminal/view/startup.rs index 58167db2d..6fa155e8f 100644 --- a/nebula_app/src/gpui_shell/terminal/view/startup.rs +++ b/nebula_app/src/gpui_shell/terminal/view/startup.rs @@ -264,6 +264,12 @@ impl TerminalView { branch: String::new(), running_program: None, command_running: false, + recent_output: crate::recent_output::RecentOutput::default(), + recent_output_restore_closed: false, + restored_viewport_offset: None, + recent_output_enabled: cx + .try_global::() + .is_none_or(|settings| settings.command_output_enabled), command_running_disproved: false, command_started: None, last_process_probe: None, diff --git a/nebula_app/src/gpui_shell/workspace/session_persistence.rs b/nebula_app/src/gpui_shell/workspace/session_persistence.rs index 9159a25ac..a0cbe326e 100644 --- a/nebula_app/src/gpui_shell/workspace/session_persistence.rs +++ b/nebula_app/src/gpui_shell/workspace/session_persistence.rs @@ -1,3 +1,6 @@ +mod local_snapshot; +pub(super) use local_snapshot::{LocalSnapshot, prepare_windows}; + use crate::session::Session; pub(super) use crate::session::combine_sessions; @@ -9,7 +12,15 @@ pub(super) enum SaveReason { Quit, } +pub(super) struct PendingSave { + pub(super) session: Session, + generation: u64, + quitting: bool, +} + pub(super) struct SessionPersistence { + generation: u64, + write_pending: bool, latest: Option, saved: Option, quitting: bool, @@ -19,6 +30,8 @@ pub(super) struct SessionPersistence { impl Default for SessionPersistence { fn default() -> Self { Self { + generation: 0, + write_pending: false, latest: None, saved: None, quitting: false, @@ -35,7 +48,33 @@ impl SessionPersistence { .into_update_windows() } + pub(super) fn disable_output_references(&mut self) { + self.generation += 1; + if self.latest.is_none() { + self.latest = self.saved.clone(); + } + if let Some(session) = &mut self.latest { + for tab in &mut session.tabs { + tab.output_refs.clear(); + } + } + // The old saved snapshot no longer describes the durable target. Keep + // latest for a retry even when the checkpoint has no live windows. + self.saved = None; + self.write_pending = true; + } + + pub(super) fn clear_output_references(&mut self) { + self.generation += 1; + for session in self.latest.iter_mut().chain(self.saved.iter_mut()) { + for tab in &mut session.tabs { + tab.output_refs.clear(); + } + } + } + pub(super) fn cancel_quit(&mut self) { + self.generation += 1; self.quitting = false; } @@ -53,16 +92,27 @@ impl SessionPersistence { reason: SaveReason, write: impl FnOnce(&Session) -> std::io::Result<()>, ) -> std::io::Result<()> { + let Some(pending) = self.prepare(current, reason) else { return Ok(()) }; + write(&pending.session)?; + self.complete(pending); + Ok(()) + } + + pub(super) fn prepare( + &mut self, + current: Option, + reason: SaveReason, + ) -> Option { // An administrator window must not overwrite the ordinary workspace or // cause its privileged shell command to be restored in a later session. if self.isolated { - return Ok(()); + return None; } let retry_checkpoint = reason == SaveReason::Checkpoint && current.as_ref().is_none_or(|session| session.tabs.is_empty()); let candidate = if self.quitting { if reason != SaveReason::Quit { - return Ok(()); + return None; } self.latest.clone() } else { @@ -81,26 +131,38 @@ impl SessionPersistence { .or_else(|| self.latest.clone()), } }; - let Some(mut session) = candidate else { return Ok(()) }; + let mut session = candidate?; if !retry_checkpoint { session.clean_exit = matches!(reason, SaveReason::WindowClose | SaveReason::Quit); } + self.generation += 1; self.latest = Some(session.clone()); - if self.saved.as_ref() == Some(&session) { + if !self.write_pending && self.saved.as_ref() == Some(&session) { self.quitting |= reason == SaveReason::Quit; - return Ok(()); + return None; } - // A failed final write is cancellable: windows stay live and subsequent - // checkpoints must still be able to save newly confirmed identities. - write(&session)?; - self.saved = Some(session); - self.quitting |= reason == SaveReason::Quit; - Ok(()) + self.write_pending = true; + Some(PendingSave { + session, + generation: self.generation, + quitting: reason == SaveReason::Quit, + }) + } + + // 只在后台写入成功后确认;失败不冻结退出,迟到的确认不覆盖新状态。 + pub(super) fn complete(&mut self, pending: PendingSave) -> bool { + if pending.generation != self.generation { + return false; + } + self.saved = Some(pending.session); + self.write_pending = false; + self.quitting |= pending.quitting; + true } } #[cfg(test)] -mod tests { +pub(super) mod tests { use super::*; #[test] @@ -120,7 +182,7 @@ mod tests { } use crate::session::{AgentSession, LayoutSession, TabSession}; - fn ordinary_window() -> SessionPersistence { + pub(in crate::gpui_shell::workspace) fn ordinary_window() -> SessionPersistence { // Hosted Windows runners can be elevated. These tests exercise ordinary // window persistence; privileged isolation has its own negative test. SessionPersistence { isolated: false, ..SessionPersistence::default() } @@ -216,6 +278,21 @@ mod tests { let _ = state.save_with(None, SaveReason::Quit, |_| panic!("no snapshot to write")); } + #[test] + fn disabling_output_does_not_acknowledge_unsaved_references_and_can_retry() { + let mut state = ordinary_window(); + let mut old = sample_session(); + old.tabs[0].output_refs = vec!["old".into()]; + state.save_with(Some(old), SaveReason::Checkpoint, |_| Ok(())).unwrap(); + state.disable_output_references(); + assert!(state.saved.is_none(), "disk state is unconfirmed until the checkpoint completes"); + let failed = state.prepare(None, SaveReason::Checkpoint).unwrap(); + assert!(failed.session.tabs[0].output_refs.is_empty()); + let retry = state.prepare(None, SaveReason::Checkpoint).unwrap(); + assert!(state.complete(retry)); + assert!(state.saved.as_ref().unwrap().tabs[0].output_refs.is_empty()); + } + #[test] fn failed_checkpoint_and_final_writes_are_retried() { let mut state = ordinary_window(); @@ -290,6 +367,73 @@ mod tests { assert!(state.saved.unwrap().tabs.is_empty()); } + #[test] + fn preparing_background_save_does_not_acknowledge_or_freeze_quit() { + let mut state = ordinary_window(); + let pending = state.prepare(Some(sample_session()), SaveReason::Quit).unwrap(); + assert!(state.saved.is_none()); + assert!(!state.quitting); + assert!(pending.session.clean_exit); + assert!(state.complete(pending)); + assert!(state.saved.as_ref().unwrap().clean_exit); + assert!(state.quitting); + } + + #[test] + fn cancelling_quit_invalidates_its_pending_completion() { + let mut state = ordinary_window(); + let pending = state.prepare(Some(sample_session()), SaveReason::Quit).unwrap(); + state.cancel_quit(); + assert!(!state.complete(pending)); + assert!(!state.quitting); + assert!(state.saved.is_none()); + let checkpoint = state.prepare(Some(sample_session()), SaveReason::Checkpoint).unwrap(); + assert!(!checkpoint.session.clean_exit); + assert!(state.complete(checkpoint)); + } + + #[test] + fn stale_background_completion_cannot_acknowledge_newer_session() { + let mut state = ordinary_window(); + let first = state.prepare(Some(sample_session()), SaveReason::Quit).unwrap(); + let mut changed = sample_session(); + changed.tabs[0].cwd = "D:/new-command".into(); + let second = state.prepare(Some(changed.clone()), SaveReason::Checkpoint).unwrap(); + assert!(!state.complete(first)); + assert!(state.saved.is_none()); + assert!(!state.quitting); + assert!(state.complete(second)); + assert_eq!(state.saved.as_ref(), Some(&changed)); + } + + #[test] + fn failed_background_write_is_retryable_without_remaining_windows() { + let mut state = ordinary_window(); + let _failed = state.prepare(Some(sample_session()), SaveReason::WindowClose).unwrap(); + let retry = state.prepare(None, SaveReason::Checkpoint).unwrap(); + assert!(retry.session.clean_exit); + assert!(state.complete(retry)); + assert_eq!(state.saved.as_ref().unwrap().tabs, sample_session().tabs); + } + + #[test] + fn reverting_to_saved_state_rewrites_disk_after_an_outstanding_write() { + let mut state = ordinary_window(); + let original = sample_session(); + state.save_with(Some(original.clone()), SaveReason::Checkpoint, |_| Ok(())).unwrap(); + let mut changed = original.clone(); + changed.tabs[0].cwd = "D:/discarded".into(); + let obsolete = state.prepare(Some(changed), SaveReason::Checkpoint).unwrap(); + // 旧后台任务可能已写入磁盘,但尚未回到 UI 确认;不能因为内存里的 + // saved 恰好等于新状态,就跳过修复磁盘所需的写入。 + let repair = state + .prepare(Some(original.clone()), SaveReason::Checkpoint) + .expect("an outstanding write may have changed disk"); + assert!(!state.complete(obsolete)); + assert!(state.complete(repair)); + assert_eq!(state.saved.as_ref(), Some(&original)); + } + #[test] fn all_windows_are_combined_with_the_active_tab_offset() { let first = sample_session(); diff --git a/nebula_app/src/gpui_shell/workspace/session_persistence/local_snapshot.rs b/nebula_app/src/gpui_shell/workspace/session_persistence/local_snapshot.rs new file mode 100644 index 000000000..f4077ee4b --- /dev/null +++ b/nebula_app/src/gpui_shell/workspace/session_persistence/local_snapshot.rs @@ -0,0 +1,302 @@ +//! 本机输出与可分享布局分离;编码和不可变引用在后台保存边界生成。 + +use crate::recent_output::{CommandRecord, storage::Archive}; +use crate::session::Session; +use std::collections::BTreeMap; +use std::io; + +pub(in crate::gpui_shell::workspace) struct LocalSnapshot { + pub(in crate::gpui_shell::workspace) session: Session, + pub(in crate::gpui_shell::workspace) outputs: Vec)>>, + pub(in crate::gpui_shell::workspace) window_id: u64, +} + +pub(in crate::gpui_shell::workspace) fn prepare_windows( + mut windows: Vec<(bool, LocalSnapshot)>, +) -> io::Result<(Option, Archive)> { + trim_outputs(&mut windows)?; + let mut sessions = Vec::new(); + let mut panes = BTreeMap::new(); + let mut seen = std::collections::HashSet::new(); + for (active, snapshot) in windows { + if !seen.insert(snapshot.window_id) { + return Err(io::Error::new(io::ErrorKind::InvalidData, "duplicate output window")); + } + let (session, mut archive) = snapshot.prepare()?; + for id in session.tabs.iter().flat_map(|tab| &tab.output_refs).filter(|id| !id.is_empty()) { + let records = archive.take_records(id).ok_or_else(|| { + io::Error::new(io::ErrorKind::InvalidData, "missing prepared output") + })?; + panes.insert(id.clone(), records); + } + sessions.push((active, session)); + } + Ok((crate::session::combine_sessions(sessions), Archive::new(panes))) +} + +/// 在生成不可变引用前淘汰全局最旧记录,不让超额输出阻断布局保存。 +fn trim_outputs(windows: &mut [(bool, LocalSnapshot)]) -> io::Result<()> { + let mut bytes = 1024usize; + let mut oldest = Vec::new(); + for (wi, (_, window)) in windows.iter().enumerate() { + for (ti, tab) in window.outputs.iter().enumerate() { + for (pi, (_, records)) in tab.iter().enumerate() { + crate::recent_output::RecentOutput::validate_records(records) + .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?; + // 引用最长 128 字节,额外预留 JSON 结构及两代交接的封装空间。 + bytes += 256; + for (ri, record) in records.iter().enumerate() { + let size = serde_json::to_vec(record)?.len() + 1; + bytes += size; + oldest.push((record.captured_at, wi, ti, pi, ri, size)); + } + } + } + } + oldest.sort_unstable(); + let mut removed = std::collections::HashSet::new(); + for (_, wi, ti, pi, ri, size) in oldest { + if bytes <= crate::recent_output::storage::MAX_STORE_BYTES { + break; + } + removed.insert((wi, ti, pi, ri)); + bytes = bytes.saturating_sub(size); + } + for (wi, (_, window)) in windows.iter_mut().enumerate() { + for (ti, tab) in window.outputs.iter_mut().enumerate() { + for (pi, (_, records)) in tab.iter_mut().enumerate() { + let mut ri = 0; + records.retain(|_| { + let keep = !removed.contains(&(wi, ti, pi, ri)); + ri += 1; + keep + }); + } + } + } + Ok(()) +} + +impl LocalSnapshot { + pub(in crate::gpui_shell::workspace) fn prepare(mut self) -> io::Result<(Session, Archive)> { + use sha2::{Digest, Sha256}; + + if self.session.tabs.len() != self.outputs.len() { + return Err(io::Error::new(io::ErrorKind::InvalidData, "output tab count mismatch")); + } + let mut panes = BTreeMap::new(); + let mut seen = std::collections::HashSet::new(); + for (tab, outputs) in self.session.tabs.iter_mut().zip(self.outputs) { + let count = tab.layout.as_ref().map_or(1, crate::session::LayoutSession::pane_count); + if count != outputs.len() { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + "output pane count mismatch", + )); + } + tab.output_refs.clear(); + for (pane_id, records) in outputs { + if !seen.insert(pane_id) { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + "duplicate output pane", + )); + } + crate::recent_output::RecentOutput::validate_records(&records) + .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?; + if records.is_empty() { + tab.output_refs.push(String::new()); + continue; + } + let bytes = serde_json::to_vec(&records)?; + let digest = Sha256::digest(&bytes); + let hash = digest.iter().map(|byte| format!("{byte:02x}")).collect::(); + let id = format!("{}-{pane_id}-{hash}", self.window_id); + if panes.insert(id.clone(), records).is_some() { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + "duplicate output pane", + )); + } + tab.output_refs.push(id); + } + } + Ok((self.session, Archive::new(panes))) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::session::TabSession; + + fn snapshot(records: Vec) -> LocalSnapshot { + LocalSnapshot { + session: Session::new( + 0, + vec![ + TabSession::single("C:/same".into(), None, None), + TabSession::single("C:/same".into(), None, None), + ], + ), + outputs: vec![vec![(11, records.clone())], vec![(12, records)]], + window_id: 7, + } + } + + fn records(label: &str) -> Vec { + use nebula_terminal::{ + event::VoidListener, + grid::Dimensions, + term::{Config, Term}, + vte::ansi, + }; + struct Size; + impl Dimensions for Size { + fn total_lines(&self) -> usize { + 4 + } + fn screen_lines(&self) -> usize { + 4 + } + fn columns(&self) -> usize { + 32 + } + } + let mut term = Term::new(Config::default(), &Size, VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut term, label.as_bytes()); + let mut recent = crate::recent_output::RecentOutput::default(); + recent.begin(term.grid()); + let mut records = recent.snapshot(term.grid()); + for record in &mut records { + record.captured_at = 0; + } + records + } + + #[test] + fn oversized_combined_output_evicts_old_records_without_losing_pane_ownership() { + let mut windows = Vec::new(); + for window in 0..96 { + let mut record = serde_json::to_value(records("retained").remove(0)).unwrap(); + // 合成合法的大记录;不同窗格的内容相同也不能共用身份。 + let row = record["prompt"]["rows"][0].clone(); + record["prompt"]["rows"] = serde_json::Value::Array(vec![row; 32]); + let mut record: CommandRecord = serde_json::from_value(record).unwrap(); + // 故意与窗口遍历顺序相反,防止按窗格位置而非时间淘汰。 + record.captured_at = 96 - window; + let mut captured = snapshot(vec![record; 5]); + captured.window_id = window; + windows.push((window == 95, captured)); + } + let (session, mut archive) = prepare_windows(windows).unwrap(); + let path = tempfile::tempdir().unwrap(); + archive.write_to(&path.path().join("output.json")).unwrap(); + assert!( + std::fs::metadata(path.path().join("output.json")).unwrap().len() <= 16 * 1024 * 1024 + ); + let session = session.unwrap(); + assert!(!session.tabs[0].output_refs[0].is_empty(), "newest window survives"); + assert!(session.tabs.last().unwrap().output_refs[0].is_empty(), "oldest window is evicted"); + let mut count = 0; + for tab in &session.tabs { + for reference in &tab.output_refs { + if !reference.is_empty() { + let restored = archive.take_records(reference).expect("exact pane reference"); + count += restored.len(); + assert!(!restored.is_empty()); + } + } + } + assert!(count > 0 && count < 960, "must evict records, not reject the save"); + } + + #[test] + fn combined_windows_keep_active_order_and_exact_output_ownership() { + let first = snapshot(records("first")); + let mut second = snapshot(records("second")); + second.window_id = 8; + second.session.active_tab = 1; + let (session, mut archive) = prepare_windows(vec![(false, first), (true, second)]).unwrap(); + let session = session.unwrap(); + assert_eq!(session.active_tab, 3); + let windows = session.into_update_windows().unwrap(); + assert_eq!(windows.len(), 2); + for (window, label) in windows.iter().zip(["first", "second"]) { + for tab in &window.tabs { + let restored = archive.take_records(&tab.output_refs[0]).unwrap(); + assert_eq!( + serde_json::to_value(restored).unwrap(), + serde_json::to_value(records(label)).unwrap() + ); + } + } + } + + #[test] + fn duplicated_window_identity_cannot_overwrite_another_windows_output() { + assert!( + prepare_windows(vec![ + (false, snapshot(records("first"))), + (true, snapshot(records("second"))), + ]) + .is_err() + ); + assert!(prepare_windows(Vec::new()).unwrap().0.is_none()); + } + + #[test] + fn local_snapshot_refs_are_stable_and_distinct_for_same_directory_panes() { + let records = records("same"); + let (first, mut archive) = snapshot(records.clone()).prepare().unwrap(); + let (again, _) = snapshot(records).prepare().unwrap(); + assert_eq!(first.tabs[0].output_refs, again.tabs[0].output_refs); + assert_ne!(first.tabs[0].output_refs, first.tabs[1].output_refs); + assert!(archive.take_records(&first.tabs[0].output_refs[0]).is_some()); + assert!(archive.take_records(&first.tabs[1].output_refs[0]).is_some()); + assert!(!serde_json::to_string(&first).unwrap().contains(&first.tabs[0].output_refs[0])); + } + + #[test] + fn changed_output_gets_new_reference_without_mutating_previous_snapshot() { + let (before, _) = snapshot(records("before")).prepare().unwrap(); + let (after, _) = snapshot(records("after")).prepare().unwrap(); + assert_ne!(before.tabs[0].output_refs, after.tabs[0].output_refs); + } + + #[test] + fn empty_output_keeps_leaf_position_without_persisting_a_record() { + let (session, _) = snapshot(Vec::new()).prepare().unwrap(); + assert_eq!(session.tabs[0].output_refs, [""]); + assert_eq!(session.tabs[1].output_refs, [""]); + } + + #[test] + fn duplicate_empty_panes_are_rejected_before_publication() { + let mut captured = snapshot(Vec::new()); + captured.outputs[1][0].0 = 11; + assert!(captured.prepare().is_err()); + } + + #[test] + fn invalid_record_is_rejected_before_reference_publication() { + let mut captured = snapshot(records("safe")); + captured.outputs[0][0].1 = vec![records("safe").remove(0); 6]; + assert!(captured.prepare().is_err()); + } + + #[test] + fn mismatched_leaf_capture_does_not_shift_other_pane_references() { + let mut captured = snapshot(records("safe")); + captured.outputs[0].push((13, records("other"))); + assert!(captured.prepare().is_err()); + } + + #[test] + fn mismatched_capture_does_not_publish_misattributed_references() { + let mut snapshot = snapshot(Vec::new()); + snapshot.outputs.pop(); + assert!(snapshot.prepare().is_err()); + } +} diff --git a/nebula_app/src/gpui_shell/workspace/session_recovery.rs b/nebula_app/src/gpui_shell/workspace/session_recovery.rs index 634bbbd4e..051614da7 100644 --- a/nebula_app/src/gpui_shell/workspace/session_recovery.rs +++ b/nebula_app/src/gpui_shell/workspace/session_recovery.rs @@ -11,9 +11,16 @@ impl NebulaWorkspace { cx: &mut Context, ) -> bool { let mut restored = false; + let mut output_targets = Vec::new(); for tab in &session.tabs { - restored |= self.restore_tab(tab, resume_ai, window, cx); + restored |= + self.restore_tab_with_outputs(tab, resume_ai, &mut output_targets, window, cx); } + TerminalView::restore_output_batch( + crate::recent_output::storage::archive_path(), + output_targets, + cx, + ); if restored { self.active = session.active_tab.min(self.tabs.len().saturating_sub(1)); self.focus_active(window, cx); @@ -50,11 +57,17 @@ impl NebulaWorkspace { let crashed = crate::session::was_crash(&session); crate::session::mark_boot_attempt(&mut session); let mut restored = 0usize; + let mut output_targets = Vec::new(); for tab in &session.tabs { - if self.restore_tab(tab, resume_ai, window, cx) { + if self.restore_tab_with_outputs(tab, resume_ai, &mut output_targets, window, cx) { restored += 1; } } + TerminalView::restore_output_batch( + crate::recent_output::storage::archive_path(), + output_targets, + cx, + ); if restored == 0 { return false; } @@ -78,6 +91,18 @@ impl NebulaWorkspace { resume_ai: bool, window: &mut Window, cx: &mut Context, + ) -> bool { + // 手动工作区导入不读取本机输出,即便调用方误传了本机引用。 + self.restore_tab_with_outputs(tab, resume_ai, &mut Vec::new(), window, cx) + } + + fn restore_tab_with_outputs( + &mut self, + tab: &crate::session::TabSession, + resume_ai: bool, + output_targets: &mut Vec<(String, gpui::WeakEntity)>, + window: &mut Window, + cx: &mut Context, ) -> bool { use crate::session::{LaunchSession, LayoutSession}; @@ -121,6 +146,9 @@ impl NebulaWorkspace { if resume_ai && let Some(agent) = agent { pane.view.update(cx, |view, cx| view.restore_agent(agent.clone(), cx)); } + if let Some(id) = tab.output_refs.get(index).filter(|id| !id.is_empty()) { + output_targets.push((id.clone(), pane.view.downgrade())); + } panes.push(pane); } if panes.is_empty() { @@ -149,6 +177,34 @@ impl NebulaWorkspace { true } + pub(super) fn snapshot_local_session(&self, cx: &App) -> session_persistence::LocalSnapshot { + let outputs = self + .tabs + .iter() + .filter_map(|tab| { + let WorkspaceTab::Terminal { panes, tree, .. } = tab else { return None }; + Some( + tree.leaves() + .iter() + .map(|id| { + let records = panes + .iter() + .find(|pane| pane.id == *id) + .map(|pane| pane.view.read(cx).recent_output_snapshot()) + .unwrap_or_default(); + (*id, records) + }) + .collect(), + ) + }) + .collect(); + session_persistence::LocalSnapshot { + session: self.snapshot_session(cx), + outputs, + window_id: self.runtime_window_id, + } + } + /// 当前工作区 → 共享 v4 快照。设置/文档/图片 tab 不进会话(旧壳同 /// 合同);AI 会话身份优先取 hook 直报的精确 id,退而取可解析的前台 /// 程序名(claude 无 id 恢复成 `--continue`,安全判定在 schema 层)。 diff --git a/nebula_settings/src/lib.rs b/nebula_settings/src/lib.rs index 81e8d8a32..38d6dc287 100644 --- a/nebula_settings/src/lib.rs +++ b/nebula_settings/src/lib.rs @@ -1035,6 +1035,8 @@ pub struct RuntimeSettings { /// Start the first window hidden when a system tray is available and enabled. pub silent_start: bool, pub restore_session: bool, + /// 仅本机有界命令输出;会话恢复关闭时不采集、不持久化。 + pub save_command_output: bool, pub resume_ai: bool, /// 常驻系统托盘图标。 pub tray: bool, @@ -1122,6 +1124,10 @@ pub const MIN_PANE_CARD_GUTTER: f32 = 0.0; pub const MAX_PANE_CARD_GUTTER: f32 = 32.0; pub const MAX_PANE_CARD_DIVIDER: f32 = 4.0; impl RuntimeSettings { + pub fn command_output_enabled(&self) -> bool { + self.restore_session && self.save_command_output + } + pub fn load() -> Self { Self::from_raw(&RawSettings::load()) } @@ -1216,6 +1222,7 @@ impl RuntimeSettings { keep_session: raw.bool_on("keep_session").unwrap_or(false), silent_start: raw.bool_on("silent_start").unwrap_or(false), restore_session: raw.bool_on("restore_session").unwrap_or(true), + save_command_output: raw.bool_on("save_command_output").unwrap_or(true), resume_ai: raw.bool_on("resume_ai").unwrap_or(true), tray: raw.bool_on("tray").unwrap_or(true), blur, @@ -1569,6 +1576,20 @@ mod tests { assert_eq!(settings.bell, BellModeName::Both); } + #[test] + fn recent_output_is_saved_only_when_both_recovery_switches_are_enabled() { + for (raw, enabled) in [ + ("", true), + ("save_command_output=0", false), + ("restore_session=0", false), + ("restore_session=0\nsave_command_output=1", false), + ("restore_session=1\nsave_command_output=1", true), + ] { + let settings = RuntimeSettings::from_raw(&RawSettings::from_text(raw)); + assert_eq!(settings.command_output_enabled(), enabled, "{raw}"); + } + } + #[test] fn automatic_update_checks_can_be_disabled_without_changing_the_default() { assert!(RuntimeSettings::from_raw(&RawSettings::default()).auto_check_updates); diff --git a/nebula_settings/src/reset.rs b/nebula_settings/src/reset.rs index 4760a134b..bb61b14b0 100644 --- a/nebula_settings/src/reset.rs +++ b/nebula_settings/src/reset.rs @@ -49,6 +49,7 @@ const RESET_KEYS: &[&str] = &[ "auto_download_updates", "keep_session", "restore_session", + "save_command_output", "resume_ai", "tray", "silent_start", From 149469f72fd9bd9e22ff656978a08726df6860e5 Mon Sep 17 00:00:00 2001 From: Kuddev <292709043+Kuddev@users.noreply.github.com> Date: Sat, 21 Nov 2026 12:03:52 +0800 Subject: [PATCH 2/2] Preserve the terminal reading position when command history arrives --- pebrel_app/src/gpui_shell/terminal/view.rs | 1 + .../src/gpui_shell/terminal/view/pointer.rs | 2 + .../gpui_shell/terminal/view/recent_output.rs | 18 +++++---- .../terminal/view/recent_output_tests.rs | 38 +++++++++++++++++++ .../src/gpui_shell/terminal/view/startup.rs | 1 + 5 files changed, 53 insertions(+), 7 deletions(-) diff --git a/pebrel_app/src/gpui_shell/terminal/view.rs b/pebrel_app/src/gpui_shell/terminal/view.rs index 550f3d178..0193722fd 100644 --- a/pebrel_app/src/gpui_shell/terminal/view.rs +++ b/pebrel_app/src/gpui_shell/terminal/view.rs @@ -358,6 +358,7 @@ pub struct TerminalView { recent_output: crate::recent_output::RecentOutput, recent_output_restore_closed: bool, recent_output_enabled: bool, + reveal_recent_output_on_restore: bool, restored_viewport_offset: Option, /// 进程树给出的反证:`command_running` 为真、但 shell 树下只剩交互式 /// shell 与 console plumbing 时置位,转圈据此熄灭(issue #42)。判据与 diff --git a/pebrel_app/src/gpui_shell/terminal/view/pointer.rs b/pebrel_app/src/gpui_shell/terminal/view/pointer.rs index 9a7ccc801..d47d2db8e 100644 --- a/pebrel_app/src/gpui_shell/terminal/view/pointer.rs +++ b/pebrel_app/src/gpui_shell/terminal/view/pointer.rs @@ -141,6 +141,7 @@ impl TerminalView { /// 把回滚位置落到 `target`(滚动条拖拽的落点提交)。 pub(super) fn scroll_to_offset(&mut self, target: usize, current: usize) { + self.reveal_recent_output_on_restore = false; self.restored_viewport_offset = None; if let Some(session) = &self.session && self.native_results.scroll_to(target, &mut session.term.lock()) @@ -1107,6 +1108,7 @@ impl TerminalView { } session.notifier.notify(bytes); } else if !application_only { + self.reveal_recent_output_on_restore = false; self.restored_viewport_offset = None; let (offset, history) = self .native_results diff --git a/pebrel_app/src/gpui_shell/terminal/view/recent_output.rs b/pebrel_app/src/gpui_shell/terminal/view/recent_output.rs index e9122e6b0..449d6bdc1 100644 --- a/pebrel_app/src/gpui_shell/terminal/view/recent_output.rs +++ b/pebrel_app/src/gpui_shell/terminal/view/recent_output.rs @@ -66,16 +66,20 @@ impl TerminalView { if term.mode().contains(TermMode::ALT_SCREEN) { return Ok(false); } + let reveal = self.reveal_recent_output_on_restore + && term.grid().display_offset() == 0 + && !term.mode().contains(TermMode::VI); recent.restore(term.grid_mut())?; // 恢复内容位于主屏之前;只移动视口,不改 ConPTY 的绝对光标坐标。 // 新输出逐步占用主屏下方空行,输入不能提前隐藏恢复内容。 - let grid = term.grid(); - use pebrel_terminal::grid::Dimensions; - let room = grid.screen_lines().saturating_sub(grid.cursor.point.line.0 as usize + 1); - let offset = room.min(grid.history_size()); - term.scroll_display(pebrel_terminal::grid::Scroll::Bottom); - term.scroll_display(pebrel_terminal::grid::Scroll::Delta(offset as i32)); - self.restored_viewport_offset = (offset > 0).then_some(offset); + if reveal { + let grid = term.grid(); + use pebrel_terminal::grid::Dimensions; + let room = grid.screen_lines().saturating_sub(grid.cursor.point.line.0 as usize + 1); + let offset = room.min(grid.history_size()); + term.scroll_display(pebrel_terminal::grid::Scroll::Delta(offset as i32)); + self.restored_viewport_offset = (offset > 0).then_some(offset); + } self.recent_output = recent; self.recent_output_restore_closed = true; drop(term); diff --git a/pebrel_app/src/gpui_shell/terminal/view/recent_output_tests.rs b/pebrel_app/src/gpui_shell/terminal/view/recent_output_tests.rs index 7f55ca564..c22269e60 100644 --- a/pebrel_app/src/gpui_shell/terminal/view/recent_output_tests.rs +++ b/pebrel_app/src/gpui_shell/terminal/view/recent_output_tests.rs @@ -470,3 +470,41 @@ fn runtime_submission_records_echo_only_after_barrier(cx: &mut TestAppContext) { assert!(restored_text(view).contains("echo runtime")); }); } + +#[gpui::test] +fn late_archive_preserves_the_live_output_selected_with_the_scrollbar(cx: &mut TestAppContext) { + use pebrel_terminal::grid::Dimensions; + + let (source, window, _) = open(cx); + let records = source.update(window, |view, cx| { + prompt(view, "echo archived"); + view.commit_line(cx); + feed(view, b"\r\narchived\r\n"); + prompt(view, ""); + view.finish_foreground_command(Some(0), cx); + view.recent_output_snapshot() + }); + assert!(!records.is_empty()); + let (target, window, _) = open(cx); + target.update(window, |view, cx| { + let rows = view.session.as_ref().unwrap().term.lock().screen_lines(); + for index in 0..rows + 12 { + feed(view, format!("startup line {index}\r\n").as_bytes()); + } + fn first_visible_line(view: &TerminalView) -> String { + let term = view.session.as_ref().unwrap().term.lock(); + let origin = term.viewport_origin_for(term.screen_lines()); + term.bounds_to_string( + TermPoint::new(origin, Column(0)), + TermPoint::new(origin, Column(term.columns() - 1)), + ) + } + + view.scroll_to_offset(7, 0); + let reading = first_visible_line(view); + assert!(reading.contains("startup line"), "{reading:?}"); + assert!(view.restore_recent_output(records, cx).unwrap()); + assert_eq!(first_visible_line(view), reading); + assert!(restored_text(view).contains("archived")); + }); +} diff --git a/pebrel_app/src/gpui_shell/terminal/view/startup.rs b/pebrel_app/src/gpui_shell/terminal/view/startup.rs index 2b300fa4f..056ffe1da 100644 --- a/pebrel_app/src/gpui_shell/terminal/view/startup.rs +++ b/pebrel_app/src/gpui_shell/terminal/view/startup.rs @@ -415,6 +415,7 @@ impl TerminalView { command_running: false, recent_output: crate::recent_output::RecentOutput::default(), recent_output_restore_closed: false, + reveal_recent_output_on_restore: true, restored_viewport_offset: None, recent_output_enabled: cx .try_global::()