diff --git a/architecture/notes/pebrel_app/gpui_shell/terminal/view/2026-11-20-recent-output-pane-capture.md b/architecture/notes/pebrel_app/gpui_shell/terminal/view/2026-11-20-recent-output-pane-capture.md new file mode 100644 index 000000000..c4d4ecf12 --- /dev/null +++ b/architecture/notes/pebrel_app/gpui_shell/terminal/view/2026-11-20-recent-output-pane-capture.md @@ -0,0 +1,47 @@ +# 逐窗格命令输出采集与本机引用 + +## Status + +本地候选;相关测试、正常产品构建及隔离 CMD 静态恢复验证已执行,尚未提交或推送。 + +## Context + +网格快照和有界输出存储已有共享实现,但尚需将已确认的 shell 命令与具体窗格关联。 +本阶段提供采集、静态恢复和不可变引用,不接入完整窗口输出保存队列或设置控件。 + +## Evidence + +- `pebrel_app/src/gpui_shell/terminal/view/completion.rs` 的 `commit_line` 从屏幕和提示符边界确认提交,运行中程序内部输入不能作为新命令。 +- `pebrel_app/src/recent_output.rs` 与 `pebrel_terminal/src/grid/snapshot.rs` 已提供容量约束和静态导入;视图不重复实现。 +- `pebrel_app/src/gpui_shell/workspace/session_persistence/shutdown_tests.rs` 保护系统拆除期间最后完整工作区,独立实例保存还须遵循更新预约通道。 +- 设置入口原有 1999 行,直接加入本阶段规则后为 2020 行;按启动与恢复准入职责提取后为 1993 行,不提高预算、不压缩格式或删测试。 + +## Decision + +- 只在 `commit_line` 确认分支开始采集;Runtime 输入沿用回显屏障及提交前保存的提示符。结束与快照读取主屏,即使备用屏正活动,也不采集其中的输入。 +- 恢复只导入显示数据,不执行命令;弱引用、退出状态、首次提交和关闭采集状态共同拒绝过期恢复。 +- 按窗口、窗格及内容摘要生成本机引用,先全局淘汰最旧记录再生成引用。分享工作区始终跳过本机引用,手动导入与复制标签不加载输出。 +- 在原会话保存器中保留 prepare/complete 代次边界,同时沿用最新系统退出候选选择、取消及更新预约隔离。prepare 返回 I/O 结果,不能把独立实例更新预约失败伪装成无待保存任务。 +- 启动与恢复准入规则集中在设置层 `startup.rs`;原目录校验方法原样迁入,调用接口不变,不改变配置格式和依赖方向。 + +## Rejected alternatives + +- 从任意 Enter、键击镜像、cwd 或运行徽章推断提交或归属:会记录程序内部输入或串档。 +- 恢复旧分支的完整会话保存器:会丢失关机冻结和独立实例更新预约行为。 +- 为本阶段复制已有快照、存储模块或接入完整输出保存队列:重复权威或越过阶段边界。 + +## Consequences + +保留最近五条和既有容量合同;历史显示不能恢复活进程。当前阶段仍不提供完整保存开关 UI 和窗口输出持久化接线,不应宣称完整产品恢复已接通。 + +## Validation + +终端 580 项、设置 111 项、应用相关去重 438 项通过;文件预算 2 项通过,格式与架构检查通过。正常 GPUI 产品构建及两个同目录原生 CMD 的隔离实测通过:各自恢复五条记录、中文可见、互不串档、继续输入不重复导入且不重跑旧命令。实测使用合成存档,仅证明本阶段静态恢复。启动补全组默认并行运行仍有失败,未修改上游亦可复现;候选串行运行 45 项通过,不将其描述为默认并行全绿。 + +## Supersedes + +None。 + +## Revisit when + +完整窗口输出保存接线落地,或命令确认、逐 pane 启动描述及系统退出保存合同改变时。 diff --git a/pebrel_app/src/gpui_shell/config.rs b/pebrel_app/src/gpui_shell/config.rs index 008e9cc05..3d5d6c95c 100644 --- a/pebrel_app/src/gpui_shell/config.rs +++ b/pebrel_app/src/gpui_shell/config.rs @@ -68,6 +68,7 @@ pub struct Settings { pub cursor_motion: pebrel_settings::CursorMotion, /// 选区完成即复制(旧壳 `copy_on_select` 设置)。 pub copy_on_select: bool, + pub(crate) command_output_enabled: bool, pub scrollback_lines: usize, pub scroll_speed: f32, pub scrollbar_visibility: pebrel_settings::ScrollbarVisibility, @@ -296,6 +297,7 @@ impl Settings { cursor_blink: runtime.cursor_blink, cursor_motion: runtime.cursor_motion, copy_on_select: runtime.copy_on_select, + command_output_enabled: runtime.command_output_enabled(), scrollback_lines: runtime.scrollback_lines, scroll_speed: runtime.scroll_speed, scrollbar_visibility: runtime.scrollbar_visibility, diff --git a/pebrel_app/src/gpui_shell/terminal/view.rs b/pebrel_app/src/gpui_shell/terminal/view.rs index 98afb0034..af93a3520 100644 --- a/pebrel_app/src/gpui_shell/terminal/view.rs +++ b/pebrel_app/src/gpui_shell/terminal/view.rs @@ -27,6 +27,9 @@ mod path_drop; mod pointer; mod program_status; mod reading; +mod recent_output; +#[cfg(all(test, feature = "gpui-test-support"))] +mod recent_output_tests; mod remote_activity; mod runtime; mod session_failure; @@ -352,6 +355,11 @@ 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, + reveal_recent_output_on_restore: bool, + restored_viewport_offset: Option, /// 进程树给出的反证:`command_running` 为真、但 shell 树下只剩交互式 /// shell 与 console plumbing 时置位,转圈据此熄灭(issue #42)。判据与 /// 节流都在 `runtime::reconcile_shell_activity`,裁定理由见那里。 @@ -645,6 +653,7 @@ impl TerminalView { } match event { TermEvent::Wakeup => { + self.follow_restored_viewport(); self.restore_shell_pointer_selection(); self.observe_reading_output(cx); self.flush_pending_runtime_submit(cx); @@ -973,11 +982,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(); if status_acknowledged { self.refresh_program_status(cx); } @@ -1177,6 +1189,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; @@ -1230,6 +1243,7 @@ impl TerminalView { term.reset_cursor_style_override(); } } + self.set_recent_output_enabled(command_output_enabled); self.restart_cursor_blink(cx); cx.notify(); } diff --git a/pebrel_app/src/gpui_shell/terminal/view/completion.rs b/pebrel_app/src/gpui_shell/terminal/view/completion.rs index ab814a022..1b81c9d4c 100644 --- a/pebrel_app/src/gpui_shell/terminal/view/completion.rs +++ b/pebrel_app/src/gpui_shell/terminal/view/completion.rs @@ -176,6 +176,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); self.classify_submitted_command(); cx.notify(); diff --git a/pebrel_app/src/gpui_shell/terminal/view/pointer.rs b/pebrel_app/src/gpui_shell/terminal/view/pointer.rs index 36f93fa23..990fa59d8 100644 --- a/pebrel_app/src/gpui_shell/terminal/view/pointer.rs +++ b/pebrel_app/src/gpui_shell/terminal/view/pointer.rs @@ -140,7 +140,9 @@ 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) { + 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()) { @@ -1124,6 +1126,8 @@ 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 .projection diff --git a/pebrel_app/src/gpui_shell/terminal/view/recent_output.rs b/pebrel_app/src/gpui_shell/terminal/view/recent_output.rs new file mode 100644 index 000000000..449d6bdc1 --- /dev/null +++ b/pebrel_app/src/gpui_shell/terminal/view/recent_output.rs @@ -0,0 +1,138 @@ +//! 命令恢复只消费已确认的 shell 提交,不从运行徽章推断提交。 + +use super::TerminalView; +use pebrel_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); + } + let reveal = self.reveal_recent_output_on_restore + && term.grid().display_offset() == 0 + && !term.mode().contains(TermMode::VI); + recent.restore(term.grid_mut())?; + // 恢复内容位于主屏之前;只移动视口,不改 ConPTY 的绝对光标坐标。 + // 新输出逐步占用主屏下方空行,输入不能提前隐藏恢复内容。 + 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); + cx.notify(); + Ok(true) + } + + pub(super) fn follow_restored_viewport(&mut self) { + use pebrel_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/pebrel_app/src/gpui_shell/terminal/view/recent_output_tests.rs b/pebrel_app/src/gpui_shell/terminal/view/recent_output_tests.rs new file mode 100644 index 000000000..c22269e60 --- /dev/null +++ b/pebrel_app/src/gpui_shell/terminal/view/recent_output_tests.rs @@ -0,0 +1,510 @@ +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 pebrel_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 pebrel_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 pebrel_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( + pebrel_settings::ThemeName::Nord, + pebrel_settings::RuntimeSettings::from_raw( + &pebrel_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(pebrel_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(); + pebrel_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")); + }); +} + +#[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/runtime.rs b/pebrel_app/src/gpui_shell/terminal/view/runtime.rs index 68b8554c0..10643b0d3 100644 --- a/pebrel_app/src/gpui_shell/terminal/view/runtime.rs +++ b/pebrel_app/src/gpui_shell/terminal/view/runtime.rs @@ -189,6 +189,7 @@ impl TerminalView { exit_code: Option, cx: &mut Context, ) { + self.finish_recent_output(); if self.command_running || self.running_program.is_some() { self.retire_command_images(cx); } @@ -1275,6 +1276,10 @@ impl TerminalView { self.term_mode(), ); self.pending_runtime_submit = None; + // 运行徽章在 echo 前已置位;只有启动前捕获的 shell 提示符允许记录。 + if self.suggest.pending_command_prompt.is_some() && self.runtime_agent().is_none() { + self.begin_recent_output(); + } self.write_input(submit_bytes, cx); } } diff --git a/pebrel_app/src/gpui_shell/terminal/view/startup.rs b/pebrel_app/src/gpui_shell/terminal/view/startup.rs index 7726b9f56..056ffe1da 100644 --- a/pebrel_app/src/gpui_shell/terminal/view/startup.rs +++ b/pebrel_app/src/gpui_shell/terminal/view/startup.rs @@ -413,6 +413,13 @@ impl TerminalView { branch: String::new(), running_program: None, 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::() + .is_none_or(|settings| settings.command_output_enabled), command_running_disproved: false, interactive_login: false, command_started: None, diff --git a/pebrel_app/src/gpui_shell/workspace/session_persistence.rs b/pebrel_app/src/gpui_shell/workspace/session_persistence.rs index b2a0671cf..3d2a39f65 100644 --- a/pebrel_app/src/gpui_shell/workspace/session_persistence.rs +++ b/pebrel_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, @@ -41,7 +54,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; } @@ -59,6 +98,17 @@ 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, + ) -> std::io::Result> { let retry_checkpoint = reason == SaveReason::Checkpoint && current.as_ref().is_none_or(|session| session.tabs.is_empty()); let system_ending = crate::platform::session_end::is_pending(); @@ -68,7 +118,7 @@ impl SessionPersistence { self.latest.clone().or_else(|| current.filter(|session| !session.tabs.is_empty())) } else if self.quitting { if reason != SaveReason::Quit { - return Ok(()); + return Ok(None); } self.latest.clone() } else { @@ -87,29 +137,38 @@ impl SessionPersistence { .or_else(|| self.latest.clone()), } }; - let Some(mut session) = candidate else { return Ok(()) }; + let Some(mut session) = candidate else { return Ok(None) }; 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) { - self.quitting |= reason == SaveReason::Quit && !system_ending; - return Ok(()); + let quitting = reason == SaveReason::Quit && !system_ending; + if !self.write_pending && self.saved.as_ref() == Some(&session) { + self.quitting |= quitting; + return Ok(None); } - // A failed final write is cancellable: windows stay live and subsequent - // checkpoints must still be able to save newly confirmed identities. if self.isolated { - // 未预约更新时只记忆当前会话,绝不写入普通会话文件或开启常规管理员恢复。 - if !crate::update_download::handoff::checkpoint_scheduled(&session)? { - self.quitting |= reason == SaveReason::Quit && !system_ending; - return Ok(()); + // 保留上游更新预约的唯一写入通道,不把独立实例送入普通输出保存队列。 + if crate::update_download::handoff::checkpoint_scheduled(&session)? { + self.saved = Some(session); } - } else { - write(&session)?; + self.quitting |= quitting; + return Ok(None); } - self.saved = Some(session); - self.quitting |= reason == SaveReason::Quit && !system_ending; - Ok(()) + self.write_pending = true; + Ok(Some(PendingSave { session, generation: self.generation, quitting })) + } + + // 只在后台写入成功后确认;失败不冻结退出,迟到的确认不覆盖新状态。 + 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 } } @@ -118,7 +177,7 @@ impl SessionPersistence { mod shutdown_tests; #[cfg(test)] -mod tests { +pub(super) mod tests { use super::*; #[test] @@ -139,7 +198,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::ordinary_for_test() @@ -244,6 +303,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().unwrap(); + assert!(failed.session.tabs[0].output_refs.is_empty()); + let retry = state.prepare(None, SaveReason::Checkpoint).unwrap().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(); @@ -318,6 +392,76 @@ 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().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().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().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().unwrap(); + let mut changed = sample_session(); + changed.tabs[0].cwd = "D:/new-command".into(); + let second = state.prepare(Some(changed.clone()), SaveReason::Checkpoint).unwrap().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().unwrap(); + let retry = state.prepare(None, SaveReason::Checkpoint).unwrap().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().unwrap(); + // 旧后台任务可能已写入磁盘,但尚未回到 UI 确认;不能因为内存里的 + // saved 恰好等于新状态,就跳过修复磁盘所需的写入。 + let repair = state + .prepare(Some(original.clone()), SaveReason::Checkpoint) + .unwrap() + .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/pebrel_app/src/gpui_shell/workspace/session_persistence/local_snapshot.rs b/pebrel_app/src/gpui_shell/workspace/session_persistence/local_snapshot.rs new file mode 100644 index 000000000..c7b64ce76 --- /dev/null +++ b/pebrel_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 pebrel_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/pebrel_app/src/gpui_shell/workspace/session_recovery.rs b/pebrel_app/src/gpui_shell/workspace/session_recovery.rs index aefff3268..01ed6eb01 100644 --- a/pebrel_app/src/gpui_shell/workspace/session_recovery.rs +++ b/pebrel_app/src/gpui_shell/workspace/session_recovery.rs @@ -38,9 +38,22 @@ 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, + self.tabs.len(), + &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); @@ -81,11 +94,24 @@ 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, + self.tabs.len(), + &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; } @@ -121,6 +147,19 @@ impl NebulaWorkspace { at: usize, window: &mut Window, cx: &mut Context, + ) -> bool { + // 手动导入和复制标签不读取本机输出,即便调用方误传了本机引用。 + self.restore_tab_with_outputs(tab, resume_ai, at, &mut Vec::new(), window, cx) + } + + fn restore_tab_with_outputs( + &mut self, + tab: &crate::session::TabSession, + resume_ai: bool, + at: usize, + output_targets: &mut Vec<(String, gpui::WeakEntity)>, + window: &mut Window, + cx: &mut Context, ) -> bool { use crate::session::{LaunchSession, LayoutSession}; @@ -189,6 +228,9 @@ impl NebulaWorkspace { { 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() { @@ -217,6 +259,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 层)。 @@ -281,6 +351,7 @@ impl NebulaWorkspace { launch: Some(launch), layout: Some(layout), active_pane, + output_refs: Vec::new(), }); } Session::new(active_out, tabs) diff --git a/pebrel_app/src/gpui_shell/workspace/tab_duplication.rs b/pebrel_app/src/gpui_shell/workspace/tab_duplication.rs index e245d7b73..d023e8235 100644 --- a/pebrel_app/src/gpui_shell/workspace/tab_duplication.rs +++ b/pebrel_app/src/gpui_shell/workspace/tab_duplication.rs @@ -223,6 +223,7 @@ impl NebulaWorkspace { color: meta.color, launch: meta.launch, active_pane: tree.leaves().iter().position(|id| id == focused).unwrap_or(0), + output_refs: Vec::new(), layout: Some(layout), }; if self.settings_open { diff --git a/pebrel_app/src/gpui_shell/workspace/tab_duplication/layout_tests.rs b/pebrel_app/src/gpui_shell/workspace/tab_duplication/layout_tests.rs index 73524c848..3acc03c96 100644 --- a/pebrel_app/src/gpui_shell/workspace/tab_duplication/layout_tests.rs +++ b/pebrel_app/src/gpui_shell/workspace/tab_duplication/layout_tests.rs @@ -125,6 +125,7 @@ fn duplicate_rebuilds_nested_mixed_layout_with_fresh_sessions(cx: &mut TestAppCo }), }), active_pane: 1, + output_refs: Vec::new(), }; let (_, window) = cx.add_window_view(|window, cx| { let workspace = cx.new(|cx| { diff --git a/pebrel_app/src/gpui_shell/workspace/tests.rs b/pebrel_app/src/gpui_shell/workspace/tests.rs index ab15586a9..7b13f58fa 100644 --- a/pebrel_app/src/gpui_shell/workspace/tests.rs +++ b/pebrel_app/src/gpui_shell/workspace/tests.rs @@ -980,6 +980,7 @@ mod boot_breaker_tests { launch: Some(launch), }), active_pane: 0, + output_refs: Vec::new(), }; // 第三次启动:磁盘上的计数已被 `mark_boot_attempt` 抬到 2。 let mut session = crate::session::Session::new(0, vec![tab]); diff --git a/pebrel_app/src/session.rs b/pebrel_app/src/session.rs index 8a474067a..4c9d33890 100644 --- a/pebrel_app/src/session.rs +++ b/pebrel_app/src/session.rs @@ -21,6 +21,7 @@ use serde::{Deserialize, Serialize}; use crate::display::color::Rgb; mod identity; +mod local_output; #[cfg(test)] mod recovery_tests; mod window_layout; @@ -234,12 +235,23 @@ pub struct TabSession { /// v4: focused leaf as a depth-first index into `layout`. #[serde(default)] pub active_pane: usize, + /// 本机 sidecar 的逐叶引用;共享工作区序列化始终排除。 + #[serde(skip)] + pub(crate) output_refs: Vec, } impl TabSession { /// A v3-shaped tab: one pane at `cwd`, default shell. pub fn single(cwd: String, custom_name: Option, color: Option) -> Self { - Self { cwd, custom_name, color, launch: None, layout: None, active_pane: 0 } + Self { + cwd, + custom_name, + color, + launch: None, + layout: None, + active_pane: 0, + output_refs: Vec::new(), + } } } @@ -299,7 +311,7 @@ impl Session { /// `%APPDATA%\Nebula\session.json` (or the `.config` fallback), next to the /// settings and history files. -fn session_path() -> PathBuf { +pub(crate) fn session_path() -> PathBuf { crate::display::nebula_data_dir().join("session.json") } @@ -316,7 +328,11 @@ fn parse(data: &str) -> Option { /// Load the previous session, if any and version-compatible. pub fn load() -> Option { - load_from(&session_path()) + load_local_from(&session_path()) +} + +pub(crate) fn load_local_from(path: &Path) -> Option { + local_output::parse(&std::fs::read_to_string(path).ok()?) } /// An update must not replace an unreadable workspace with an empty snapshot. @@ -328,7 +344,7 @@ pub(crate) fn load_update_windows() -> std::io::Result> { }, Err(error) => return Err(error), }; - let session = parse(&data).ok_or_else(|| { + let session = local_output::parse(&data).ok_or_else(|| { std::io::Error::new(std::io::ErrorKind::InvalidData, "Invalid saved workspace") })?; session.into_update_windows() @@ -349,8 +365,12 @@ pub fn save(session: &Session) { } pub(crate) fn try_save(session: &Session) -> std::io::Result<()> { - let json = serde_json::to_string(session).map_err(std::io::Error::other)?; - crate::atomic_file::write(&session_path(), json.as_bytes()) + save_local_to(&session_path(), session) +} + +pub(crate) fn save_local_to(path: &Path, session: &Session) -> std::io::Result<()> { + let json = local_output::encode(session).map_err(std::io::Error::other)?; + crate::atomic_file::write(path, json.as_bytes()) } /// Write a session as a named workspace file. Pretty-printed — workspace diff --git a/pebrel_app/src/session/local_output.rs b/pebrel_app/src/session/local_output.rs new file mode 100644 index 000000000..d63b1f7ae --- /dev/null +++ b/pebrel_app/src/session/local_output.rs @@ -0,0 +1,97 @@ +//! 仅自动恢复文档携带输出引用;共享 Session 编码不含本机身份。 + +use super::Session; + +pub(super) fn encode(session: &Session) -> serde_json::Result { + #[derive(serde::Serialize)] + struct LocalSession<'a> { + #[serde(flatten)] + session: &'a Session, + local_output_refs: Vec<&'a [String]>, + } + serde_json::to_string(&LocalSession { + session, + local_output_refs: session.tabs.iter().map(|tab| tab.output_refs.as_slice()).collect(), + }) +} + +pub(super) fn parse(data: &str) -> Option { + let mut session = super::parse(data)?; + // 引用损坏仅丢弃历史,不使仍有效的布局与 AI 身份无法恢复。 + let value: serde_json::Value = serde_json::from_str(data).ok()?; + if let Some(refs) = value + .get("local_output_refs") + .and_then(|refs| serde_json::from_value::>>(refs.clone()).ok()) + { + let mut seen = std::collections::HashSet::new(); + let valid = refs.len() == session.tabs.len() + && refs.iter().zip(&session.tabs).all(|(ids, tab)| { + let leaves = tab.layout.as_ref().map_or(1, super::LayoutSession::pane_count); + (ids.is_empty() || ids.len() == leaves) + && ids.iter().all(|id| { + id.is_empty() + || (id.len() <= 128 + && id.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-') + && seen.insert(id)) + }) + }); + if valid { + for (tab, ids) in session.tabs.iter_mut().zip(refs) { + tab.output_refs = ids; + } + } + } + Some(session) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::session::{TabSession, combine_sessions}; + + fn saved(id: &str) -> Session { + let mut tab = TabSession::single("C:/same-directory".into(), None, None); + tab.output_refs = vec![id.into()]; + Session::new(0, vec![tab]) + } + + #[test] + fn local_output_refs_survive_local_save_but_never_workspace_export_or_import() { + let original = saved("pane-one"); + let encoded = encode(&original).unwrap(); + assert_eq!(parse(&encoded).unwrap().tabs[0].output_refs, ["pane-one"]); + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("workspace.json"); + crate::session::save_to(&path, &original).unwrap(); + let exported = std::fs::read_to_string(&path).unwrap(); + assert!(!exported.contains("pane-one")); + // 即使输入的是本机自动存档,手动工作区导入仍不能带入引用。 + std::fs::write(&path, encoded).unwrap(); + assert!(crate::session::load_from(&path).unwrap().tabs[0].output_refs.is_empty()); + } + + #[test] + fn local_output_refs_follow_tabs_when_combining_and_restoring_windows() { + let combined = + combine_sessions([(false, saved("pane-one")), (true, saved("pane-two"))]).unwrap(); + let windows = parse(&encode(&combined).unwrap()).unwrap().into_update_windows().unwrap(); + assert_eq!(windows[0].tabs[0].output_refs, ["pane-one"]); + assert_eq!(windows[1].tabs[0].output_refs, ["pane-two"]); + } + + #[test] + fn malformed_local_output_refs_do_not_break_layout_recovery() { + let mut value = serde_json::to_value(saved("unused")).unwrap(); + for invalid in [ + serde_json::json!([["../escape"]]), + serde_json::json!([["one", "two"]]), + serde_json::json!([["same"], ["extra-tab"]]), + serde_json::json!("broken"), + ] { + value["local_output_refs"] = invalid; + let session = parse(&value.to_string()).unwrap(); + assert_eq!(session.tabs.len(), 1); + assert!(session.tabs[0].output_refs.is_empty()); + } + } +} diff --git a/pebrel_app/src/window_context/session_snapshot.rs b/pebrel_app/src/window_context/session_snapshot.rs index 43ecd9793..d37635d65 100644 --- a/pebrel_app/src/window_context/session_snapshot.rs +++ b/pebrel_app/src/window_context/session_snapshot.rs @@ -154,6 +154,7 @@ impl WindowContext { launch: Some(Self::launch_session(&tab.launch)), layout: Some(Self::layout_session(&tab.layout, &pane_cwd, &pane_agent)), active_pane: leaves.iter().position(|id| *id == tab.active_pane).unwrap_or(0), + output_refs: Vec::new(), } } diff --git a/pebrel_settings/src/lib.rs b/pebrel_settings/src/lib.rs index 84933061c..a90daf7fb 100644 --- a/pebrel_settings/src/lib.rs +++ b/pebrel_settings/src/lib.rs @@ -48,6 +48,7 @@ mod prompt_suggestions; pub use prompt_suggestions::PromptSuggestions; mod quick_terminal; mod scrolling; +mod startup; pub use scrolling::{ DEFAULT_SCROLL_SPEED, DEFAULT_SCROLLBACK_LINES, MAX_SCROLL_SPEED, MIN_SCROLL_SPEED, SCROLL_SPEED_STEP, SCROLLBACK_VALUES, ScrollbarVisibility, normalize_scroll_speed, @@ -1094,6 +1095,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, @@ -1191,16 +1194,6 @@ impl RuntimeSettings { Self::from_raw(&RawSettings::load()) } - /// 启动时再检查目录:保存后可能被删除,各启动入口应使用同一有效性规则。 - pub fn startup_directory_path(&self) -> Option { - let directory = self.startup_directory.as_deref()?.trim(); - if directory.is_empty() { - return None; - } - let path = std::path::PathBuf::from(directory); - path.is_dir().then_some(path) - } - pub fn from_raw(raw: &RawSettings) -> Self { let blur = raw.value("blur").and_then(BlurModeName::from_settings).unwrap_or_default(); let blur_explicit = raw.value("blur").and_then(BlurModeName::from_settings).is_some(); @@ -1301,6 +1294,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, diff --git a/pebrel_settings/src/reset.rs b/pebrel_settings/src/reset.rs index 2838a0e25..ed9b5521d 100644 --- a/pebrel_settings/src/reset.rs +++ b/pebrel_settings/src/reset.rs @@ -58,6 +58,7 @@ const RESET_KEYS: &[&str] = &[ "auto_download_updates", "keep_session", "restore_session", + "save_command_output", "resume_ai", "tray", "silent_start", diff --git a/pebrel_settings/src/startup.rs b/pebrel_settings/src/startup.rs new file mode 100644 index 000000000..b8cddffe5 --- /dev/null +++ b/pebrel_settings/src/startup.rs @@ -0,0 +1,39 @@ +//! 启动与恢复的共享准入规则;各启动入口不自行解释原始配置。 + +use crate::RuntimeSettings; + +impl RuntimeSettings { + pub fn command_output_enabled(&self) -> bool { + self.restore_session && self.save_command_output + } + + /// 启动时再检查目录:保存后可能被删除,各启动入口应使用同一有效性规则。 + pub fn startup_directory_path(&self) -> Option { + let directory = self.startup_directory.as_deref()?.trim(); + if directory.is_empty() { + return None; + } + let path = std::path::PathBuf::from(directory); + path.is_dir().then_some(path) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::RawSettings; + + #[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}"); + } + } +} diff --git a/pebrel_terminal/src/grid/snapshot.rs b/pebrel_terminal/src/grid/snapshot.rs index db4792b46..99c848c9e 100644 --- a/pebrel_terminal/src/grid/snapshot.rs +++ b/pebrel_terminal/src/grid/snapshot.rs @@ -129,6 +129,21 @@ mod tests { use crate::term::{Config, Term, test::TermSize}; use crate::vte::ansi; + #[test] + fn captures_primary_screen_while_alternate_screen_is_active() { + let mut term = Term::new(Config::default(), &TermSize::new(8, 2), VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut term, b"main"); + parser.advance(&mut term, b"\x1b[?1049halt"); + assert_eq!(term.grid()[Line(0)][Column(4)].c, 'a'); + + let snapshot = DisplaySnapshot::capture(term.primary_grid(), Line(0)..Line(1), 8); + let mut target = Grid::::new(2, 8, 10); + snapshot.restore_scrollback(&mut target).unwrap(); + assert_eq!(target[Line(-1)][Column(0)].c, 'm'); + assert_eq!(target[Line(-1)][Column(1)].c, 'a'); + } + #[test] fn restores_reflowed_unicode_before_existing_history_without_touching_prompt() { let mut source = Term::new(Config::default(), &TermSize::new(8, 3), VoidListener); diff --git a/pebrel_terminal/src/term/grid_content.rs b/pebrel_terminal/src/term/grid_content.rs index d12fc8fd2..fe552a2bf 100644 --- a/pebrel_terminal/src/term/grid_content.rs +++ b/pebrel_terminal/src/term/grid_content.rs @@ -7,6 +7,11 @@ use crate::inline_image::{ }; impl Term { + /// 主屏显示数据;备用屏活动时仍保留普通命令的输出,不包含 TUI 内容。 + pub fn primary_grid(&self) -> &Grid { + if self.mode.contains(TermMode::ALT_SCREEN) { &self.inactive_grid } else { &self.grid } + } + /// Mutable access to the raw grid data structure. pub fn grid_mut(&mut self) -> &mut Grid { self.reset_input_cluster();