From 92edd8e958517bf8f156c11aec44595754c594c0 Mon Sep 17 00:00:00 2001 From: galact <94279960+galact-byte@users.noreply.github.com> Date: Mon, 21 Sep 2026 09:04:20 +0800 Subject: [PATCH 01/10] feat(terminal): restore bounded recent command output per pane --- .../2026-09-21-bounded-local-output.md | 73 ++ nebula_app/i18n/en-US.json | 9 + nebula_app/i18n/zh-CN.json | 9 + nebula_app/src/gpui_shell/config.rs | 2 + nebula_app/src/gpui_shell/file_editor/mod.rs | 2 +- .../src/gpui_shell/file_editor/tests.rs | 11 + nebula_app/src/gpui_shell/settings_pane.rs | 9 +- .../settings_pane/command_output.rs | 69 ++ .../settings_pane/initialization.rs | 1 + .../gpui_shell/settings_pane/navigation.rs | 2 +- .../src/gpui_shell/settings_pane/tests.rs | 83 +++ nebula_app/src/gpui_shell/terminal/view.rs | 16 +- .../gpui_shell/terminal/view/completion.rs | 1 + .../src/gpui_shell/terminal/view/pointer.rs | 5 +- .../gpui_shell/terminal/view/recent_output.rs | 134 ++++ .../terminal/view/recent_output_tests.rs | 365 ++++++++++ .../src/gpui_shell/terminal/view/runtime.rs | 5 + .../src/gpui_shell/terminal/view/startup.rs | 6 + nebula_app/src/gpui_shell/workspace.rs | 24 +- .../src/gpui_shell/workspace/closing.rs | 40 +- .../src/gpui_shell/workspace/documents.rs | 27 + .../src/gpui_shell/workspace/residency.rs | 152 +++-- .../workspace/session_persistence.rs | 139 +++- .../session_persistence/local_snapshot.rs | 302 ++++++++ .../gpui_shell/workspace/session_recovery.rs | 61 +- .../gpui_shell/workspace/terminal_activity.rs | 15 +- .../src/gpui_shell/workspace/windowing.rs | 81 ++- .../workspace/windowing/output_persistence.rs | 643 ++++++++++++++++++ .../workspace/windowing/shutdown.rs | 21 +- .../workspace/windowing/transfer_tests.rs | 4 +- nebula_app/src/main.rs | 1 + nebula_app/src/recent_output.rs | 256 +++++++ nebula_app/src/recent_output/storage.rs | 253 +++++++ .../src/recent_output/storage/lifecycle.rs | 418 ++++++++++++ nebula_app/src/session.rs | 32 +- nebula_app/src/session/local_output.rs | 97 +++ .../src/window_context/session_snapshot.rs | 1 + nebula_settings/src/lib.rs | 21 + nebula_settings/src/reset.rs | 1 + nebula_terminal/src/grid/mod.rs | 1 + nebula_terminal/src/grid/snapshot.rs | 254 +++++++ .../src/grid/snapshot/serialization.rs | 85 +++ nebula_terminal/src/term/renderable.rs | 9 +- 43 files changed, 3589 insertions(+), 151 deletions(-) create mode 100644 architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md create mode 100644 nebula_app/src/gpui_shell/settings_pane/command_output.rs 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 create mode 100644 nebula_app/src/gpui_shell/workspace/windowing/output_persistence.rs create mode 100644 nebula_app/src/recent_output.rs create mode 100644 nebula_app/src/recent_output/storage.rs create mode 100644 nebula_app/src/recent_output/storage/lifecycle.rs create mode 100644 nebula_app/src/session/local_output.rs create mode 100644 nebula_terminal/src/grid/snapshot.rs create mode 100644 nebula_terminal/src/grid/snapshot/serialization.rs diff --git a/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md b/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md new file mode 100644 index 000000000..9c69753fb --- /dev/null +++ b/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md @@ -0,0 +1,73 @@ +# 本机有界命令输出恢复(#160) + +## Status + +已实现并完成本机 Windows CMD 验证,待提交审核;尚未发布。 + +## Context + +布局和 AI 原生身份恢复不包含终端显示内容。全局补全历史没有 pane 身份, +不能通过目录猜测旧输出归属。恢复内容必须是静态显示,不能重新执行历史命令。 + +## Evidence + +- `nebula_app/src/recent_output.rs`:命令记录、五条上限及输出尾部截取。 +- `nebula_app/src/recent_output/storage.rs` 与 `storage/lifecycle.rs`:容量、原子交接和清除。 +- `nebula_terminal/src/grid/snapshot.rs`:安全显示快照及 Unicode/重排测试。 +- `nebula_app/src/session/local_output.rs`:本机输出引用与会话导出边界。 +- `nebula_app/src/gpui_shell/workspace/windowing/output_persistence.rs`:异步保存生命周期。 + +## Decision + +terminal 层只导出、导入静态显示数据,去除链接动作,不回放 VT;app 层复用 +已确认的 shell 命令提交,每 pane 最多五条,每条编码不超过 256 KiB,保留命令 +与输出尾部。独立本机 sidecar 使用版本化格式和精确记录引用,不按 cwd 匹配。 + +正常快照总编码不超过 16 MiB,原子交接期间允许新旧两代临时合计最多 32 MiB, +各代仍单独限额。sidecar 写入成功后才发布会话引用,成功后回收旧代;崩溃重试 +保留已发布会话的有效引用,不累积第三代。总量超限先淘汰最旧记录再生成引用。 + +读取前检查大小,读取时限流,解码后校验。损坏输出降级且不阻断有效新保存; +真实 I/O 失败保留失败和重试语义。保存与清除串行提交,代次失效阻止旧快照 +在清除后写回。关闭保存使在途旧快照失效;关闭 pane 的成功保存移除对应引用。 + +会话恢复开启时默认有界保存,提供关闭与清除入口;独立会话导出不携带本机 +输出引用或正文。旧会话无引用时沿用原恢复行为。文档在等待保存期间被编辑时, +关窗路径重新检查脏状态,包括 Runtime 关窗,不能因之前确认而丢弃新编辑。 + +## Rejected alternatives + +- 保存、重放原始 VT:会重放控制动作,不是安全静态恢复。 +- 按目录分配全局历史:多个 pane 可有相同目录,无法证明归属。 +- 把全部输出嵌入可导出的 session:扩大隐私暴露和载入成本。 +- 不允许两代临时空间:有效旧快照会阻断正常原子替换。 +- 为恢复引入常驻线程或新依赖:现有异步执行和原子写机制足够。 + +## Consequences + +不恢复活进程,不重新执行命令,不恢复完整 AI 对话或 CMD 原生命令历史。 +不采集不可见密码输入、TUI 内部按键或 AI 会话文件,但无法自动识别所有已经 +显示在屏幕上的秘密。备用屏内容不作为普通历史导入。 + +活跃 AI 恢复时,静态旧输出和 AI 自身重绘可能同时留在终端历史中。 +禁用本功能可回退至原布局和 AI 恢复,不以回退脚本删除用户数据。 + +## Validation + +本机全量应用回归 1890 通过、0 失败、15 忽略;terminal 包 283 个单元测试、 +48 个集成测试及 1 个文档测试通过;i18n 合同 20 通过、1 忽略。 +架构检查使用基线 `5ce18ba0c4c82f13548ea2dca94d2078e22e11eb`,没有扩大预算。 + +实际 GPUI 构建验证 CMD 保存、关窗、重复重启、最近五条、多 pane 不串档、 +恢复期变窄、备用屏排除和活跃 Pi 原生会话身份保持。Pi 使用本机合成服务, +不是云端兼容性证明。两 pane 大输出测试恢复各自尾部;本机计时不是通用性能保证。 +此前单线程全量测试曾超时,默认并行全量通过;没有删除或新增忽略该测试。 + +## Supersedes + +None。 + +## Revisit when + +真实工具归属或有界成本不满足需求、需要改变采集范围,或需要跨设备导出输出时, +重新审核数据与隐私合同,不隐式扩大持久化。 diff --git a/nebula_app/i18n/en-US.json b/nebula_app/i18n/en-US.json index 96a5e6d06..1586e7385 100644 --- a/nebula_app/i18n/en-US.json +++ b/nebula_app/i18n/en-US.json @@ -13,6 +13,15 @@ "en_us": "English" }, "settings": { + "command_output": { + "save": "Remember recent command output", + "help": "With session restore enabled, keep up to five commands and their output per terminal on this device. Output may contain sensitive information; full-screen applications are not captured.", + "clear": "Clear saved command output", + "clear_help": "Remove saved output for all terminals on this device without clearing their screens. New commands are still saved while the option above is enabled.", + "clearing": "Clearing…", + "cleared": "Saved output cleared", + "clear_failed": "Clear failed — retry" + }, "scrolling": { "history": "Scrollback lines", "history_description": "History lines retained per terminal. Applies to new terminals only.", diff --git a/nebula_app/i18n/zh-CN.json b/nebula_app/i18n/zh-CN.json index 747d83819..2a106b031 100644 --- a/nebula_app/i18n/zh-CN.json +++ b/nebula_app/i18n/zh-CN.json @@ -13,6 +13,15 @@ "en_us": "English" }, "settings": { + "command_output": { + "save": "保存最近命令与输出", + "help": "开启会话恢复时,在本机为每个终端保留最近五条命令及输出。输出可能包含敏感信息;不采集全屏程序画面。", + "clear": "清除已保存的命令输出", + "clear_help": "移除本机所有终端已保存的输出,不清空当前屏幕。上方开关开启时,后续新命令仍会保存。", + "clearing": "正在清除…", + "cleared": "已清除保存的输出", + "clear_failed": "清除失败,点击重试" + }, "scrolling": { "history": "回滚行数", "history_description": "每个窗格保留的历史行数。仅适用于新窗格。", diff --git a/nebula_app/src/gpui_shell/config.rs b/nebula_app/src/gpui_shell/config.rs index 7f953c521..75f10b7fe 100644 --- a/nebula_app/src/gpui_shell/config.rs +++ b/nebula_app/src/gpui_shell/config.rs @@ -75,6 +75,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. @@ -274,6 +275,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/file_editor/mod.rs b/nebula_app/src/gpui_shell/file_editor/mod.rs index e269a76a3..d1399fb69 100644 --- a/nebula_app/src/gpui_shell/file_editor/mod.rs +++ b/nebula_app/src/gpui_shell/file_editor/mod.rs @@ -31,7 +31,7 @@ mod structure_commands; mod structure_tests; mod structure_view; #[cfg(all(test, feature = "gpui-test-support"))] -mod tests; +pub(in crate::gpui_shell) mod tests; use std::cell::RefCell; use std::path::PathBuf; diff --git a/nebula_app/src/gpui_shell/file_editor/tests.rs b/nebula_app/src/gpui_shell/file_editor/tests.rs index 05191c0d9..093640fa8 100644 --- a/nebula_app/src/gpui_shell/file_editor/tests.rs +++ b/nebula_app/src/gpui_shell/file_editor/tests.rs @@ -2,6 +2,17 @@ use super::*; use gpui::{TestAppContext, VisualTestContext}; use gpui_component::Root; +pub(in crate::gpui_shell) fn replace_draft( + file: &Entity, + text: &str, + window: &mut gpui::Window, + cx: &mut gpui::App, +) { + file.update(cx, |view, cx| { + view.input.update(cx, |input, cx| input.replace_all(text, window, cx)); + }); +} + pub(super) fn open( path: PathBuf, cx: &mut TestAppContext, diff --git a/nebula_app/src/gpui_shell/settings_pane.rs b/nebula_app/src/gpui_shell/settings_pane.rs index ac326b65a..eece0aa66 100644 --- a/nebula_app/src/gpui_shell/settings_pane.rs +++ b/nebula_app/src/gpui_shell/settings_pane.rs @@ -43,6 +43,7 @@ mod appearance_picker; #[path = "background_color.rs"] mod background_color; mod backup; +mod command_output; mod design; mod font_picker; mod providers; @@ -210,6 +211,7 @@ pub struct SettingsPane { /// 备份密码(masked;只在导出/恢复动作瞬时读取,不落任何配置)。 backup_pass_input: Entity, backup_status: Option, + command_output_clear: command_output::ClearState, /// 导出/恢复/推送进行中(按钮禁用 + 忽略过期完成回调)。 backup_busy: bool, backup_seq: u64, @@ -375,7 +377,10 @@ impl SettingsPane { cx.notify(); return; } - if matches!(key, "ai_toasts" | "focus_follows_mouse" | "dim_inactive_panes") { + if matches!( + key, + "ai_toasts" | "focus_follows_mouse" | "dim_inactive_panes" | "save_command_output" + ) { if let Err(error) = self.try_persist(&[(key, (value as u8).to_string())], cx) { let language = crate::gpui_shell::config::ui_language(cx); super::toast::toast( @@ -745,6 +750,7 @@ impl SettingsPane { "fetch" => flag!(fetch), "keep_session" => flag!(keep_session), "restore_session" => flag!(restore_session), + "save_command_output" => flag!(save_command_output), "resume_ai" => flag!(resume_ai), "tray" => flag!(tray), "panel_resize" => flag!(panel_resize), @@ -1260,6 +1266,7 @@ impl SettingsPane { self.runtime.restore_session, cx, )) + .child(self.command_output_controls(cx)) .child(self.switch_row( "resume_ai", language.pick("恢复时接续 AI 对话", "Resume AI conversations"), diff --git a/nebula_app/src/gpui_shell/settings_pane/command_output.rs b/nebula_app/src/gpui_shell/settings_pane/command_output.rs new file mode 100644 index 000000000..11138c29d --- /dev/null +++ b/nebula_app/src/gpui_shell/settings_pane/command_output.rs @@ -0,0 +1,69 @@ +//! 本机命令输出沿用会话恢复设置区域;清除成功必须等磁盘操作完成。 +use super::*; +use crate::i18n::Message; + +#[derive(Default)] +pub(super) enum ClearState { + #[default] + Idle, + Busy, + Done, + Failed, +} + +impl SettingsPane { + pub(super) fn command_output_controls(&self, cx: &mut Context) -> impl IntoElement { + let language = crate::gpui_shell::config::ui_language(cx); + let label = match self.command_output_clear { + ClearState::Idle => Message::SettingsCommandOutputClear, + ClearState::Busy => Message::SettingsCommandOutputClearing, + ClearState::Done => Message::SettingsCommandOutputCleared, + ClearState::Failed => Message::SettingsCommandOutputClearFailed, + }; + let control = crate::gpui_shell::widgets::NebulaButton::new("clear-command-output") + .label(language.text(label)) + .disabled(matches!(self.command_output_clear, ClearState::Busy)) + .on_click(cx.listener(|this, _, _, cx| this.clear_command_output(cx))); + #[cfg(any(test, feature = "gpui-test-support"))] + let control = div().debug_selector(|| "clear-command-output".to_owned()).child(control); + div() + .child(self.switch_row( + "save_command_output", + language.text(Message::SettingsCommandOutputSave), + language.text(Message::SettingsCommandOutputHelp), + self.runtime.save_command_output, + cx, + )) + .child(self.row( + language.text(Message::SettingsCommandOutputClear), + language.text(Message::SettingsCommandOutputClearHelp), + control, + cx, + )) + } + + fn clear_command_output(&mut self, cx: &mut Context) { + if matches!(self.command_output_clear, ClearState::Busy) { + return; + } + self.command_output_clear = ClearState::Busy; + let clear = crate::gpui_shell::workspace::windowing::clear_command_output(cx); + cx.notify(); + cx.spawn(async move |this, cx| { + let result = clear.await; + let state = match result { + Ok(true) => ClearState::Done, + Ok(false) => ClearState::Failed, + Err(error) => { + log::warn!("Could not clear command output: {error}"); + ClearState::Failed + }, + }; + let _ = this.update(cx, |this, cx| { + this.command_output_clear = state; + cx.notify(); + }); + }) + .detach(); + } +} diff --git a/nebula_app/src/gpui_shell/settings_pane/initialization.rs b/nebula_app/src/gpui_shell/settings_pane/initialization.rs index 571f41b7b..62999d384 100644 --- a/nebula_app/src/gpui_shell/settings_pane/initialization.rs +++ b/nebula_app/src/gpui_shell/settings_pane/initialization.rs @@ -655,6 +655,7 @@ impl SettingsPane { .placeholder(localized_input_placeholder("backup_password", language)) }), backup_status: None, + command_output_clear: super::command_output::ClearState::Idle, backup_busy: false, backup_seq: 0, backup_remote: { diff --git a/nebula_app/src/gpui_shell/settings_pane/navigation.rs b/nebula_app/src/gpui_shell/settings_pane/navigation.rs index 83c259914..fe9306f9a 100644 --- a/nebula_app/src/gpui_shell/settings_pane/navigation.rs +++ b/nebula_app/src/gpui_shell/settings_pane/navigation.rs @@ -34,7 +34,7 @@ pub(super) const SECTION_SEARCH_TERMS: [&str; 10] = [ "network 网络 proxy 代理 connectivity 连接", "interaction 交互 copy 复制 paste 粘贴 tab 标签 panel 面板 focus follows mouse 焦点跟随鼠标 自动聚焦", "keymap key binding shortcut quick terminal 快速终端 独立窗口 已有窗口 按键映射 快捷键", - "advanced 高级 session 会话 tray 托盘 restore 恢复 startup autostart login silent 自启动 静默启动 开机 登录", + "advanced 高级 session 会话 tray 托盘 restore 恢复 startup autostart login silent 自启动 静默启动 开机 登录 command output 命令输出 最近命令 清除输出", "backup cloud sync 云备份 云同步 云存储 备份 export 导出 restore 恢复 webdav s3 sftp 坚果云 123 123云盘 nextcloud synology 群晖 nas r2 minio snapshots 快照", ]; diff --git a/nebula_app/src/gpui_shell/settings_pane/tests.rs b/nebula_app/src/gpui_shell/settings_pane/tests.rs index 35dedab0f..8e4e6abaf 100644 --- a/nebula_app/src/gpui_shell/settings_pane/tests.rs +++ b/nebula_app/src/gpui_shell/settings_pane/tests.rs @@ -81,6 +81,89 @@ fn ai_toast_setting_is_searchable_and_has_a_visible_switch(cx: &mut gpui::TestAp ); } +#[cfg(feature = "gpui-test-support")] +#[gpui::test] +fn command_output_controls_are_searchable_and_visible(cx: &mut gpui::TestAppContext) { + cx.update(|cx| { + gpui_component::init(cx); + cx.set_global(crate::gpui_shell::config::Settings::load(ThemeName::Nord)); + }); + let mut pane = None; + let (_, cx) = cx.add_window_view(|window, cx| { + let view = cx.new(|cx| SettingsPane::new(window, cx)); + pane = Some(view.clone()); + gpui_component::Root::new(view, window, cx) + }); + let pane = pane.unwrap(); + cx.simulate_resize(gpui::size(px(1280.0), px(1600.0))); + for query in ["命令输出", "command output"] { + cx.update(|window, cx| { + pane.update(cx, |pane, cx| { + pane.settings_search_input + .update(cx, |input, cx| input.replace_all(query, window, cx)); + }); + }); + cx.run_until_parked(); + cx.update(|window, cx| { + window.draw(cx).clear(cx); + }); + assert_eq!(pane.read_with(cx, |pane, _| pane.active_section), 8); + for id in ["nebula-switch-save_command_output", "clear-command-output"] { + let bounds = cx.debug_bounds(id).expect("command output control is rendered"); + assert!(bounds.size.width > px(0.0) && bounds.size.height > px(0.0)); + assert!(bounds.origin.y >= px(0.0) && bounds.bottom() <= px(1600.0)); + } + } +} + +#[cfg(feature = "gpui-test-support")] +#[gpui::test] +fn command_output_clear_click_reports_failure_and_allows_retry(cx: &mut gpui::TestAppContext) { + use crate::gpui_shell::workspace::windowing; + let directory = tempfile::tempdir().unwrap(); + let output = directory.path().join("output.json"); + // A directory at the file path makes removal fail without touching user data. + std::fs::create_dir(&output).unwrap(); + cx.update(|cx| { + gpui_component::init(cx); + cx.set_global(crate::gpui_shell::config::Settings::load(ThemeName::Nord)); + windowing::initialize(cx, crate::runtime_api::RuntimeHub::new()); + windowing::set_command_output_test_path(cx, output.clone()); + }); + let mut pane = None; + let (_, cx) = cx.add_window_view(|window, cx| { + let view = cx.new(|cx| SettingsPane::new(window, cx)); + view.update(cx, |pane, _| pane.active_section = 8); + pane = Some(view.clone()); + gpui_component::Root::new(view, window, cx) + }); + let pane = pane.unwrap(); + cx.simulate_resize(gpui::size(px(1280.0), px(1600.0))); + for retry in [false, true] { + if retry { + std::fs::remove_dir(&output).unwrap(); + std::fs::write(&output, b"synthetic output").unwrap(); + } + cx.update(|window, cx| { + window.draw(cx).clear(cx); + }); + let bounds = cx.debug_bounds("clear-command-output").unwrap(); + cx.simulate_mouse_down( + bounds.center(), + gpui::MouseButton::Left, + gpui::Modifiers::default(), + ); + cx.simulate_mouse_up(bounds.center(), gpui::MouseButton::Left, gpui::Modifiers::default()); + cx.run_until_parked(); + assert!(pane.read_with(cx, |pane, _| if retry { + matches!(pane.command_output_clear, command_output::ClearState::Done) + } else { + matches!(pane.command_output_clear, command_output::ClearState::Failed) + })); + assert_eq!(output.exists(), !retry); + } +} + #[test] fn settings_nav_visibility_keeps_stable_routes_and_restores_backup() { let visibility: Vec<_> = (0..SECTION_IDS.len()).map(is_nav_section_visible).collect(); diff --git a/nebula_app/src/gpui_shell/terminal/view.rs b/nebula_app/src/gpui_shell/terminal/view.rs index 907859942..637b7395a 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..986a91d38 100644 --- a/nebula_app/src/gpui_shell/terminal/view/completion.rs +++ b/nebula_app/src/gpui_shell/terminal/view/completion.rs @@ -56,6 +56,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 25367d190..f93ae33a4 100644 --- a/nebula_app/src/gpui_shell/terminal/view/pointer.rs +++ b/nebula_app/src/gpui_shell/terminal/view/pointer.rs @@ -98,11 +98,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)); } } @@ -708,6 +709,7 @@ impl TerminalView { return true; } if let Some(session) = &self.session { + self.restored_viewport_offset = None; session.term.lock().scroll_display(Scroll::Delta(lines)); } // 滚动换了视口到绝对行的映射,选区末端必须按滚动后的网格重算—— @@ -894,6 +896,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..7c6617da5 --- /dev/null +++ b/nebula_app/src/gpui_shell/terminal/view/recent_output_tests.rs @@ -0,0 +1,365 @@ +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())); +} + +#[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 e81ee91bd..035e27fa9 100644 --- a/nebula_app/src/gpui_shell/terminal/view/runtime.rs +++ b/nebula_app/src/gpui_shell/terminal/view/runtime.rs @@ -159,6 +159,7 @@ impl TerminalView { exit_code: Option, cx: &mut Context, ) { + self.finish_recent_output(); self.notify_command_done(cx); self.last_command_failed = exit_code.is_some_and(|code| code != 0); if self.clear_foreground_agent_state(cx) { @@ -1051,6 +1052,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 19364aaf1..02ecda7bf 100644 --- a/nebula_app/src/gpui_shell/terminal/view/startup.rs +++ b/nebula_app/src/gpui_shell/terminal/view/startup.rs @@ -240,6 +240,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.rs b/nebula_app/src/gpui_shell/workspace.rs index a0e11702a..185ec7349 100644 --- a/nebula_app/src/gpui_shell/workspace.rs +++ b/nebula_app/src/gpui_shell/workspace.rs @@ -1662,15 +1662,6 @@ impl NebulaWorkspace { (0..self.tabs.len()).find_map(|tab_ix| self.busy_process_in_tab(tab_ix, None, cx)) } - fn save_clean_window_session(&mut self, cx: &mut App) -> std::io::Result<()> { - windowing::save_current_window_session( - self.runtime_window_id, - self.snapshot_session(cx), - session_persistence::SaveReason::WindowClose, - cx, - ) - } - fn request_close_pane( &mut self, tab_ix: usize, @@ -1871,14 +1862,17 @@ impl NebulaWorkspace { self.active -= 1; } self.active = self.active.min(self.tabs.len().saturating_sub(1)); - if let Err(error) = windowing::save_current_window_session( - self.runtime_window_id, - self.snapshot_session(cx), + let save = windowing::output_persistence::save( + Some(self.snapshot_local_session(cx)), session_persistence::SaveReason::TabsClosed, cx, - ) { - log::warn!("Could not save closed tabs: {error}"); - } + ); + cx.spawn(async move |_, _| { + if !matches!(save.await, Ok(true)) { + log::warn!("Could not save closed tabs"); + } + }) + .detach(); self.reveal_active_tab(); self.focus_active(window, cx); self.sync_side_panel_to_active(true, cx); diff --git a/nebula_app/src/gpui_shell/workspace/closing.rs b/nebula_app/src/gpui_shell/workspace/closing.rs index 199406f04..27200c37e 100644 --- a/nebula_app/src/gpui_shell/workspace/closing.rs +++ b/nebula_app/src/gpui_shell/workspace/closing.rs @@ -1,8 +1,19 @@ use super::*; impl NebulaWorkspace { - /// GPUI 的 should-close 回调必须同步返回:无繁忙进程时直接允许系统关闭; - /// 有繁忙进程时先返回 false,再由对话框确认回调显式移除窗口。 + pub(super) fn save_clean_window_session( + &mut self, + cx: &mut App, + ) -> gpui::Task> { + windowing::output_persistence::save( + Some(self.snapshot_local_session(cx)), + session_persistence::SaveReason::WindowClose, + cx, + ) + } + + /// GPUI 关闭回调必须同步返回;普通窗口先等待保存,繁忙窗口还须确认。 + /// 返回 false 后,由异步保存成功路径显式移除窗口。 pub(super) fn should_close_window( &mut self, window: &mut Window, @@ -84,13 +95,30 @@ impl NebulaWorkspace { fn finish_close_window(&mut self, _window: &mut Window, cx: &mut Context) { self.window_close_pending = true; + let documents = self.close_document_snapshot(cx); let panes = self.prepare_session_save(cx); let handle = self.window_handle; cx.spawn(async move |this, cx| { let ready = wait_for_session_ids(&panes, cx).await; + let saved = if ready { + let Ok(save) = + this.update(cx, |workspace, cx| workspace.save_clean_window_session(cx)) + else { + return; + }; + match save.await { + Ok(saved) => saved, + Err(error) => { + log::warn!("Window close cancelled because session save failed: {error}"); + false + }, + } + } else { + false + }; let _ = handle.update(cx, |_, window, cx| { let _ = this.update(cx, |workspace, cx| { - if !ready || workspace.save_clean_window_session(cx).is_err() { + if !saved { workspace.window_close_pending = false; let language = crate::gpui_shell::config::ui_language(cx); let message = if ready { @@ -107,6 +135,12 @@ impl NebulaWorkspace { cx.notify(); return; } + workspace.window_close_pending = false; + if !workspace.close_documents_unchanged(&documents, cx) { + workspace.guard_file_window_close(window, cx); + cx.notify(); + return; + } window.remove_window(); }); }); diff --git a/nebula_app/src/gpui_shell/workspace/documents.rs b/nebula_app/src/gpui_shell/workspace/documents.rs index 131c7ee27..25b639624 100644 --- a/nebula_app/src/gpui_shell/workspace/documents.rs +++ b/nebula_app/src/gpui_shell/workspace/documents.rs @@ -15,6 +15,33 @@ impl WorkspaceTab { } impl NebulaWorkspace { + pub(super) fn close_document_snapshot( + &self, + cx: &App, + ) -> Vec<(Entity, SharedString)> { + self.tabs + .iter() + .filter_map(|tab| tab.file_editor(cx)) + .map(|file| { + let draft = file.read(cx).draft(cx); + (file, draft) + }) + .collect() + } + + pub(super) fn close_documents_unchanged( + &self, + approved: &[(Entity, SharedString)], + cx: &App, + ) -> bool { + self.tabs.iter().filter_map(|tab| tab.file_editor(cx)).all(|file| { + let view = file.read(cx); + !view.is_saving() + && (!view.is_dirty() + || approved.iter().any(|(old, draft)| *old == file && *draft == view.draft(cx))) + }) + } + pub(super) fn sync_document_activity(&self, window: &mut Window, cx: &mut Context) { for (index, tab) in self.tabs.iter().enumerate() { let Some(file) = tab.file_editor(cx) else { continue }; diff --git a/nebula_app/src/gpui_shell/workspace/residency.rs b/nebula_app/src/gpui_shell/workspace/residency.rs index b15a1f321..9c93de615 100644 --- a/nebula_app/src/gpui_shell/workspace/residency.rs +++ b/nebula_app/src/gpui_shell/workspace/residency.rs @@ -148,9 +148,77 @@ impl NebulaWorkspace { fn drain_runtime_commands(&mut self, window: &mut Window, cx: &mut Context) { let pending = std::mem::take(&mut self.runtime_pending); for dispatch in pending { - let response = self.execute_runtime_command(&dispatch.command, window, cx); - dispatch.respond(response); + if let RuntimeCommand::CloseWindow { window_id } = &dispatch.command { + let close = self.runtime_close_window(*window_id, cx); + cx.spawn(async move |_, _| { + dispatch.respond(match close { + Ok(close) => close.await, + Err(error) => Err(error), + }); + }) + .detach(); + } else { + let response = self.execute_runtime_command(&dispatch.command, window, cx); + dispatch.respond(response); + } + } + } + + pub(super) fn runtime_close_window( + &mut self, + window_id: Option, + cx: &mut Context, + ) -> Result>, ApiError> { + self.runtime_window_requested(window_id)?; + if self.window_close_pending { + return Err(ApiError::new("close_pending", "window close is already pending")); + } + if !self.close_documents_unchanged(&[], cx) { + return Err(ApiError::new( + "requires_confirmation", + "unsaved documents require confirmation in the GUI", + )); } + if let Some(process) = self.busy_process_in_window(cx) { + return Err(runtime_close_confirmation( + process, + json!({ "target": "window", "window_id": self.runtime_window_id }), + )); + } + self.window_close_pending = true; + let panes = self.prepare_session_save(cx); + let handle = self.window_handle; + let id = self.runtime_window_id; + let tab_count = self.tabs.len(); + Ok(cx.spawn(async move |this, cx| { + let result = async { + if !super::closing::wait_for_session_ids(&panes, cx).await { + return Err(ApiError::new("session_identity_pending", "session identity is not ready")); + } + let save = this.update(cx, |workspace, cx| workspace.save_clean_window_session(cx)) + .map_err(|error| ApiError::new("target_not_found", error.to_string()))?; + match save.await { + Ok(true) => {}, + Ok(false) => return Err(ApiError::new("session_save_failed", "session save was superseded")), + Err(error) => return Err(ApiError::new("session_save_failed", error.to_string())), + } + let documents_safe = this.update(cx, |workspace, cx| { + workspace.close_documents_unchanged(&[], cx) + }).map_err(|error| ApiError::new("target_not_found", error.to_string()))?; + if !documents_safe { + return Err(ApiError::new("requires_confirmation", "documents changed while the window was saving")); + } + handle.update(cx, |_, window, cx| { + super::windowing::remove_saved_workspace_window(id, window, cx); + let snapshot = super::windowing::publish_runtime_snapshot(cx); + json!({ "action": { "window_id": id, "closed": true, "tabs_closed": tab_count }, "snapshot": snapshot }) + }).map_err(|error| ApiError::new("target_not_found", error.to_string())) + }.await; + if result.is_err() { + let _ = this.update(cx, |workspace, _| workspace.window_close_pending = false); + } + result + })) } pub(crate) fn execute_runtime_command( @@ -168,39 +236,10 @@ impl NebulaWorkspace { "runtime_unavailable", "window.create is not queued in the GPUI runtime", )), - RuntimeCommand::CloseWindow { window_id } => { - self.runtime_window_requested(*window_id)?; - if let Some(process) = self.busy_process_in_window(cx) { - return Err(runtime_close_confirmation( - process, - json!({ "target": "window", "window_id": self.runtime_window_id }), - )); - } - let tab_count = self.tabs.len(); - if self.tabs.is_empty() { - super::windowing::close_empty_workspace_window( - self.runtime_window_id, - window, - cx, - ); - } else { - super::windowing::close_saved_workspace_window( - self.runtime_window_id, - self.snapshot_session(cx), - window, - cx, - ); - } - let snapshot = super::windowing::publish_runtime_snapshot(cx); - Ok(json!({ - "action": { - "window_id": self.runtime_window_id, - "closed": true, - "tabs_closed": tab_count - }, - "snapshot": snapshot - })) - }, + RuntimeCommand::CloseWindow { .. } => Err(ApiError::new( + "runtime_unavailable", + "window.close requires asynchronous session publication", + )), RuntimeCommand::Focus { window_id, pane_id } => { self.runtime_window_requested(*window_id)?; if let Some(pane_id) = pane_id { @@ -1013,24 +1052,35 @@ impl NebulaWorkspace { { return false; } - if let Err(error) = super::windowing::save_current_window_session( - self.runtime_window_id, - self.snapshot_session(cx), + self.window_close_pending = true; + let save = super::windowing::output_persistence::save( + Some(self.snapshot_local_session(cx)), super::session_persistence::SaveReason::Checkpoint, cx, - ) { - log::warn!("Could not checkpoint before hiding window: {error}"); - let language = crate::gpui_shell::config::ui_language(cx); - crate::gpui_shell::toast::banner( - window, - cx, - crate::display::ToastKind::Warning, - language.text(crate::i18n::Message::SessionSaveFailed), - ); - return true; - } - crate::gpui_shell::hide_native_window(window); - self.window_hidden = true; + ); + let handle = self.window_handle; + cx.spawn(async move |this, cx| { + let saved = matches!(save.await, Ok(true)); + let _ = handle.update(cx, |_, window, cx| { + let _ = this.update(cx, |workspace, cx| { + workspace.window_close_pending = false; + if saved { + crate::gpui_shell::hide_native_window(window); + workspace.window_hidden = true; + } else { + let language = crate::gpui_shell::config::ui_language(cx); + crate::gpui_shell::toast::banner( + window, + cx, + crate::display::ToastKind::Warning, + language.text(crate::i18n::Message::SessionSaveFailed), + ); + } + cx.notify(); + }); + }); + }) + .detach(); true } diff --git a/nebula_app/src/gpui_shell/workspace/session_persistence.rs b/nebula_app/src/gpui_shell/workspace/session_persistence.rs index 9159a25ac..044fc3f8f 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,17 @@ impl SessionPersistence { .into_update_windows() } + 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 +76,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 +115,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 +166,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() } @@ -290,6 +336,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 5edfc07be..327f548e7 100644 --- a/nebula_app/src/gpui_shell/workspace/session_recovery.rs +++ b/nebula_app/src/gpui_shell/workspace/session_recovery.rs @@ -12,9 +12,16 @@ impl NebulaWorkspace { ) -> bool { self.recovery_boot_attempts = session.boot_attempts.saturating_add(1); 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); @@ -52,11 +59,17 @@ impl NebulaWorkspace { crate::session::mark_boot_attempt(&mut session); self.recovery_boot_attempts = session.boot_attempts; 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; } @@ -80,6 +93,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}; @@ -123,6 +148,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() { @@ -151,6 +179,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 层)。 @@ -200,6 +256,7 @@ impl NebulaWorkspace { launch: Some(launch), layout: Some(layout), active_pane, + output_refs: Vec::new(), }); } let mut session = Session::new(active_out, tabs); diff --git a/nebula_app/src/gpui_shell/workspace/terminal_activity.rs b/nebula_app/src/gpui_shell/workspace/terminal_activity.rs index 36af3592d..2009684a1 100644 --- a/nebula_app/src/gpui_shell/workspace/terminal_activity.rs +++ b/nebula_app/src/gpui_shell/workspace/terminal_activity.rs @@ -20,14 +20,17 @@ impl NebulaWorkspace { ) { match event { TerminalViewEvent::SessionIdentityChanged => { - if let Err(error) = windowing::save_current_window_session( - self.runtime_window_id, - self.snapshot_session(cx), + let save = windowing::output_persistence::save( + Some(self.snapshot_local_session(cx)), session_persistence::SaveReason::Checkpoint, cx, - ) { - log::warn!("Could not checkpoint native recovery identity: {error}"); - } + ); + cx.spawn(async move |_, _| { + if !matches!(save.await, Ok(true)) { + log::warn!("Could not checkpoint native recovery identity"); + } + }) + .detach(); }, // OSC 7 cwd 与标题共用这条事件。只有当前聚焦 pane 能驱动共享文件树; // 后台 pane 的提示符更新不能把前台目录覆盖掉。 diff --git a/nebula_app/src/gpui_shell/workspace/windowing.rs b/nebula_app/src/gpui_shell/workspace/windowing.rs index 2b9bef628..770a8e715 100644 --- a/nebula_app/src/gpui_shell/workspace/windowing.rs +++ b/nebula_app/src/gpui_shell/workspace/windowing.rs @@ -4,7 +4,11 @@ //! `NebulaWorkspace`。所有外部启动和 runtime 命令先在这里选择窗口,再把 //! 变更投递到对应 workspace,避免多个 receiver 竞争消费同一事件流。 +pub(super) mod output_persistence; mod shutdown; +pub(crate) use output_persistence::clear as clear_command_output; +#[cfg(all(test, feature = "gpui-test-support"))] +pub(crate) use output_persistence::set_command_output_test_path; pub(crate) use shutdown::{quit_all, quit_for_update}; #[cfg(windows)] @@ -137,6 +141,7 @@ pub(crate) struct WindowRegistry { entries: Vec, runtime_hub: crate::runtime_api::RuntimeHub, session_persistence: SessionPersistence, + output_persistence: output_persistence::OutputPersistence, quit_pending: bool, #[cfg(windows)] quick_terminal: Option, @@ -203,6 +208,7 @@ pub(crate) fn initialize(cx: &mut App, runtime_hub: crate::runtime_api::RuntimeH entries: Vec::new(), runtime_hub, session_persistence: SessionPersistence::default(), + output_persistence: output_persistence::OutputPersistence::default(), quit_pending: false, #[cfg(windows)] quick_terminal: None, @@ -214,19 +220,26 @@ pub(crate) fn initialize(cx: &mut App, runtime_hub: crate::runtime_api::RuntimeH let quit_subscription = cx.on_app_quit(|cx| { #[cfg(windows)] quick_window::persist_quick_size(cx); - if let Err(error) = save_combined_session(cx, true) { - log::warn!("Final session write: {error}"); + let save = output_persistence::save(None, SaveReason::Quit, cx); + async move { + if !matches!(save.await, Ok(true)) { + log::warn!("Final session write failed or was superseded"); + } } - async {} }); let closed_subscription = cx.on_window_closed(|cx, _window_id| { // A tab transfer can close its source while the destination workspace // is still borrowed. Snapshot all windows only after that update ends. cx.defer(save_after_window_closed); }); - cx.global_mut::() - ._subscriptions - .extend([quit_subscription, closed_subscription]); + let settings_subscription = cx.observe_global::(|cx| { + output_persistence::settings_changed(cx); + }); + cx.global_mut::()._subscriptions.extend([ + quit_subscription, + closed_subscription, + settings_subscription, + ]); cx.spawn(async move |cx| { loop { @@ -242,9 +255,7 @@ fn save_after_window_closed(cx: &mut App) { // 快速终端不能改变普通 session 的生命周期:最后一扇普通窗口关闭后, // 即使隐藏的 Quake 窗口仍存活,也不能再补写一份空的普通 session。 if cx.global::().entries.iter().any(|entry| entry.role == WindowRole::Regular) { - if let Err(error) = save_combined_session(cx, false) { - log::warn!("Session checkpoint: {error}"); - } + output_persistence::checkpoint(cx); } } @@ -1091,6 +1102,21 @@ fn dispatch_runtime(dispatch: Arc, cx: &mut App) { return; }, }; + if let RuntimeCommand::CloseWindow { window_id } = &dispatch.command { + let close = entry + .workspace + .update(cx, |workspace, cx| workspace.runtime_close_window(*window_id, cx)); + cx.spawn(async move |_| { + let response = match close { + Ok(Ok(close)) => close.await, + Ok(Err(error)) => Err(error), + Err(error) => Err(ApiError::new("target_not_found", error.to_string())), + }; + dispatch.respond(response); + }) + .detach(); + return; + } let command = dispatch.command.clone(); let workspace = entry.workspace.clone(); let result = entry.handle.update(cx, move |_, window, cx| { @@ -1360,10 +1386,10 @@ pub(crate) fn publish_runtime_snapshot_with_current( pub(crate) fn autosave_tick(cx: &mut App) { #[cfg(windows)] quick_window::persist_quick_size(cx); - if let Err(error) = save_combined_session(cx, false) { - log::warn!("Session checkpoint: {error}"); - return; - } + output_persistence::checkpoint(cx); +} + +fn acknowledge_session_restore(cx: &App) { let workspaces = cx .global::() .entries @@ -1415,27 +1441,6 @@ fn combined_session( combine_sessions(sessions) } -fn save_combined_session(cx: &mut App, clean: bool) -> std::io::Result<()> { - let session = combined_session(None, cx); - let reason = if clean { SaveReason::Quit } else { SaveReason::Checkpoint }; - cx.global_mut::().session_persistence.save(session, reason) -} - -pub(super) fn save_current_window_session( - runtime_window_id: u64, - session: crate::session::Session, - reason: SaveReason, - cx: &mut App, -) -> std::io::Result<()> { - if !cx.global::().entries.iter().any(|entry| { - entry.runtime_window_id == runtime_window_id && entry.role == WindowRole::Regular - }) { - return Ok(()); - } - let session = combined_session(Some((runtime_window_id, session)), cx); - cx.global_mut::().session_persistence.save(session, reason) -} - pub(crate) fn move_tab_to_new_window(payload: CrossWindowTabDrag, cx: &mut App) { let opened = open_workspace_window(cx, WorkspaceStartup::Empty, None, None, true, WindowRole::Regular); @@ -1501,17 +1506,11 @@ fn unregister(runtime_window_id: u64, cx: &mut App) { } } -pub(super) fn close_saved_workspace_window( +pub(super) fn remove_saved_workspace_window( runtime_window_id: u64, - session: crate::session::Session, window: &mut Window, cx: &mut App, ) { - if let Err(error) = - save_current_window_session(runtime_window_id, session, SaveReason::WindowClose, cx) - { - log::warn!("Could not checkpoint moved window: {error}"); - } unregister(runtime_window_id, cx); window.remove_window(); } diff --git a/nebula_app/src/gpui_shell/workspace/windowing/output_persistence.rs b/nebula_app/src/gpui_shell/workspace/windowing/output_persistence.rs new file mode 100644 index 000000000..9a319e1e1 --- /dev/null +++ b/nebula_app/src/gpui_shell/workspace/windowing/output_persistence.rs @@ -0,0 +1,643 @@ +//! 本机快照在 UI 线程采集;编码、sidecar 和会话提交交给后台执行器。 + +use super::super::session_persistence::{LocalSnapshot, prepare_windows}; +use super::*; +use crate::recent_output::storage::{Archive, OutputStore}; +use futures::{FutureExt, channel::oneshot, future::Shared}; +use std::io; + +pub(super) struct OutputPersistence { + store: OutputStore, + session_path: PathBuf, + tail: Option>>, + latest_archive: Option, + clear_epoch: u64, +} + +impl Default for OutputPersistence { + fn default() -> Self { + Self { + store: OutputStore::new(crate::recent_output::storage::archive_path()), + session_path: crate::session::session_path(), + tail: None, + latest_archive: None, + clear_epoch: 0, + } + } +} + +pub(super) fn settings_changed(cx: &mut App) { + if cx + .try_global::() + .is_none_or(|settings| settings.command_output_enabled) + { + return; + } + let registry = cx.global_mut::(); + registry.session_persistence.clear_output_references(); + let state = &mut registry.output_persistence; + state.clear_epoch += 1; + state.latest_archive = None; + // 同时拦截尚未编码的队列任务和已经交给后台的写入。 + state.store.next_generation(); +} + +fn capture(mut current: Option, cx: &App) -> Vec<(bool, LocalSnapshot)> { + let mut entries = cx + .global::() + .entries + .iter() + .filter(|entry| entry.role == WindowRole::Regular) + .cloned() + .collect::>(); + entries.sort_by_key(|entry| entry.runtime_window_id); + let active = cx + .active_window() + .filter(|handle| entries.iter().any(|entry| entry.handle == *handle)) + .or_else(|| { + entries.iter().max_by_key(|entry| entry.last_activated).map(|entry| entry.handle) + }); + entries + .into_iter() + .filter_map(|entry| { + let snapshot = if current + .as_ref() + .is_some_and(|snapshot| snapshot.window_id == entry.runtime_window_id) + { + current.take()? + } else { + entry.workspace.upgrade()?.read(cx).snapshot_local_session(cx) + }; + Some((active == Some(entry.handle), snapshot)) + }) + .collect() +} + +/// 按采集顺序串行提交,关窗/退出必须等待成功,不能把已入队当作已保存。 +pub(in crate::gpui_shell::workspace) fn save( + current: Option, + reason: SaveReason, + cx: &mut App, +) -> gpui::Task> { + let snapshots = capture(current, cx); + enqueue(snapshots, reason, cx) +} + +fn enqueue( + snapshots: Vec<(bool, LocalSnapshot)>, + reason: SaveReason, + cx: &mut App, +) -> gpui::Task> { + let epoch = cx.global::().output_persistence.clear_epoch; + let (done, receiver) = oneshot::channel(); + let previous = + cx.global_mut::().output_persistence.tail.replace(receiver.shared()); + cx.spawn(async move |cx| { + let result = async { + if let Some(previous) = previous { + let _ = previous.await; + } + let (mut session, mut archive) = + cx.background_executor().spawn(async move { prepare_windows(snapshots) }).await?; + let job = cx.update(|cx| { + let enabled = + cx.global::().command_output_enabled; + let registry = cx.global_mut::(); + // 清除前采集、清除后才完成编码的任务只能保存布局。 + if epoch != registry.output_persistence.clear_epoch || !enabled { + if let Some(session) = &mut session { + for tab in &mut session.tabs { + tab.output_refs.clear(); + } + } + archive = Archive::new(Default::default()); + } + // 最后一扇窗口已关闭时,沿用同一份快照的输出,不用空档覆盖它。 + if session.as_ref().is_some_and(|session| !session.tabs.is_empty()) + || reason == SaveReason::TabsClosed + { + registry.output_persistence.latest_archive = Some(archive); + } + let pending = registry.session_persistence.prepare(session, reason)?; + let archive = registry + .output_persistence + .latest_archive + .clone() + .unwrap_or_else(|| Archive::new(Default::default())); + let store = registry.output_persistence.store.clone(); + let generation = store.next_generation(); + Some(( + pending, + archive, + store, + generation, + registry.output_persistence.session_path.clone(), + )) + }); + let Some((pending, archive, store, generation, path)) = job else { return Ok(true) }; + let (pending, result) = cx + .background_executor() + .spawn(async move { + let references = crate::session::load_local_from(&path) + .map(|session| { + session + .tabs + .into_iter() + .flat_map(|tab| tab.output_refs) + .collect::>() + }) + .unwrap_or_default(); + let result = + store.save_referenced(generation, &archive, Some(&references), || { + crate::session::save_local_to(&path, &pending.session) + }); + (pending, result) + }) + .await; + if !result? { + return Ok(false); + } + Ok(cx.update(|cx| { + cx.global_mut::().session_persistence.complete(pending) + })) + } + .await; + let _ = done.send(()); + result + }) +} + +/// 清除作用于所有本机窗格,不清屏、不关终端;任务不依赖设置页存活。 +pub(crate) fn clear(cx: &mut App) -> gpui::Task> { + let views = cx + .global::() + .entries + .iter() + .filter_map(|entry| entry.workspace.upgrade()) + .flat_map(|workspace| { + workspace + .read(cx) + .tabs + .iter() + .flat_map(|tab| match tab { + WorkspaceTab::Terminal { panes, .. } => { + panes.iter().map(|pane| pane.view.clone()).collect() + }, + _ => Vec::new(), + }) + .collect::>() + }) + .collect::>(); + for view in views { + view.update(cx, |view, _| view.clear_recent_output()); + } + let registry = cx.global_mut::(); + registry.session_persistence.clear_output_references(); + let state = &mut registry.output_persistence; + state.clear_epoch += 1; + state.latest_archive = None; + state.store.next_generation(); + let store = state.store.clone(); + let (done, receiver) = oneshot::channel(); + let previous = state.tail.replace(receiver.shared()); + cx.spawn(async move |cx| { + if let Some(previous) = previous { + let _ = previous.await; + } + let result = cx + .background_executor() + .spawn(async move { store.clear(store.next_generation()) }) + .await; + let _ = done.send(()); + result + }) +} + +#[cfg(all(test, feature = "gpui-test-support"))] +pub(crate) fn set_command_output_test_path(cx: &mut App, path: PathBuf) { + let state = &mut cx.global_mut::().output_persistence; + state.session_path = path.with_file_name("session.json"); + state.store = OutputStore::new(path); +} + +#[cfg(all(test, feature = "gpui-test-support"))] +mod tests { + use super::*; + + #[gpui::test] + fn clear_invalidates_queued_output_and_does_not_erase_later_commands( + cx: &mut gpui::TestAppContext, + ) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let output = dir.path().join("output.json"); + let make_snapshot = |label: &str| { + use nebula_terminal::{ + event::VoidListener, + term::{Config, Term}, + vte::ansi, + }; + let mut term = Term::new( + Config::default(), + &crate::gpui_shell::terminal::session::GridSize { columns: 80, screen_lines: 24 }, + VoidListener, + ); + let mut parser: ansi::Processor = ansi::Processor::new(); + let mut recent = crate::recent_output::RecentOutput::default(); + parser.advance(&mut term, label.as_bytes()); + recent.begin(term.grid()); + parser.advance(&mut term, b"\r\nresult\r\n"); + recent.finish(term.grid()); + LocalSnapshot { + session: crate::session::Session::new( + 0, + vec![crate::session::TabSession::single("C:/test".into(), None, None)], + ), + outputs: vec![vec![(1, recent.snapshot(term.grid()))]], + window_id: 1, + } + }; + let (old, clearing) = cx.update(|cx| { + let mut settings = + crate::gpui_shell::config::Settings::load(nebula_settings::ThemeName::Nord); + settings.command_output_enabled = true; + cx.set_global(settings); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(output.clone()); + registry.output_persistence.session_path = dir.path().join("session.json"); + let old = enqueue(vec![(true, make_snapshot("old"))], SaveReason::Checkpoint, cx); + let clearing = clear(cx); + (old, clearing) + }); + cx.run_until_parked(); + let _ = old.now_or_never().expect("old save finishes"); + assert!(clearing.now_or_never().unwrap().unwrap()); + assert!(!output.exists(), "queued snapshots must not resurrect cleared output"); + let snapshot = make_snapshot("new"); + let expected = snapshot.outputs[0][0].1.clone(); + let new = cx.update(|cx| enqueue(vec![(true, snapshot)], SaveReason::Checkpoint, cx)); + cx.run_until_parked(); + assert!(new.now_or_never().unwrap().unwrap()); + let session: serde_json::Value = + serde_json::from_slice(&std::fs::read(dir.path().join("session.json")).unwrap()) + .unwrap(); + let reference = session["local_output_refs"][0][0].as_str().unwrap(); + let mut archive = Archive::read_from(&output).unwrap(); + let restored = archive.take_records(reference).expect("new command is published"); + assert_eq!( + serde_json::to_value(restored).unwrap(), + serde_json::to_value(expected).unwrap() + ); + } + + #[gpui::test] + fn runtime_close_waits_for_publication_and_reports_write_failure( + cx: &mut gpui::TestAppContext, + ) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let blocker = dir.path().join("not-a-directory"); + std::fs::write(&blocker, b"block").unwrap(); + let (handle, workspace, close) = cx.update(|cx| { + let (id, workspace) = super::super::transfer_tests::open_test_window(cx, 1); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(blocker.join("output.json")); + registry.output_persistence.session_path = dir.path().join("session.json"); + let handle = entry_by_id(id, cx).unwrap().handle; + let close = workspace + .update(cx, |workspace, cx| workspace.runtime_close_window(Some(id), cx)) + .unwrap(); + assert!(cx.windows().contains(&handle)); + (handle, workspace, close) + }); + cx.run_until_parked(); + let result = close.now_or_never().expect("close task must finish"); + assert_eq!(result.unwrap_err().code, "session_save_failed"); + cx.update(|cx| { + assert!(cx.windows().contains(&handle)); + assert!(!workspace.read(cx).window_close_pending); + cx.global_mut::().output_persistence.store = + OutputStore::new(dir.path().join("output.json")); + }); + let close = cx + .update(|cx| { + workspace.update(cx, |workspace, cx| workspace.runtime_close_window(None, cx)) + }) + .unwrap(); + cx.run_until_parked(); + let result = close.now_or_never().expect("close task must finish").unwrap(); + assert_eq!(result["action"]["closed"], true); + assert!(dir.path().join("output.json").is_file()); + assert!(dir.path().join("session.json").is_file()); + cx.update(|cx| assert!(!cx.windows().contains(&handle))); + } + + #[gpui::test] + fn application_quit_publishes_output_before_finishing(cx: &mut gpui::TestAppContext) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let output = dir.path().join("output.json"); + let session = dir.path().join("session.json"); + cx.update(|cx| { + super::super::transfer_tests::open_test_window(cx, 1); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(output.clone()); + registry.output_persistence.session_path = session.clone(); + super::super::shutdown::quit_all(cx); + assert!(!session.exists()); + }); + cx.run_until_parked(); + assert!(output.is_file(), "quit must save the output sidecar"); + let value: serde_json::Value = + serde_json::from_slice(&std::fs::read(session).unwrap()).unwrap(); + assert_eq!(value["tabs"].as_array().unwrap().len(), 1); + assert_eq!(value["clean_exit"], true); + } + + #[gpui::test] + fn application_quit_output_failure_is_retryable(cx: &mut gpui::TestAppContext) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let blocker = dir.path().join("not-a-directory"); + std::fs::write(&blocker, b"block").unwrap(); + cx.update(|cx| { + super::super::transfer_tests::open_test_window(cx, 1); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(blocker.join("output.json")); + registry.output_persistence.session_path = dir.path().join("session.json"); + super::super::shutdown::quit_all(cx); + }); + cx.run_until_parked(); + cx.update(|cx| { + assert!(!cx.global::().quit_pending, "failed save must cancel quit") + }); + assert!(!dir.path().join("session.json").exists()); + } + + #[gpui::test] + fn window_close_waits_for_output_and_session_publication(cx: &mut gpui::TestAppContext) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let output = dir.path().join("output.json"); + let session = dir.path().join("session.json"); + let handle = cx.update(|cx| { + let (id, workspace) = super::super::transfer_tests::open_test_window(cx, 1); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(output.clone()); + registry.output_persistence.session_path = session.clone(); + let handle = entry_by_id(id, cx).unwrap().handle; + handle + .update(cx, |_, window, cx| { + workspace.update(cx, |workspace, cx| { + assert!(!workspace.close_window_after_documents(window, cx)); + assert!(workspace.window_close_pending); + }) + }) + .unwrap(); + assert!(!session.exists()); + handle + }); + cx.run_until_parked(); + assert!(output.is_file(), "closing must publish the output sidecar"); + let value: serde_json::Value = + serde_json::from_slice(&std::fs::read(session).unwrap()).unwrap(); + assert_eq!(value["tabs"].as_array().unwrap().len(), 1); + assert_eq!(value["clean_exit"], true); + cx.update(|cx| assert!(!cx.windows().contains(&handle))); + } + + #[gpui::test] + fn window_close_preserves_document_edited_while_save_is_pending(cx: &mut gpui::TestAppContext) { + check_pending_close_draft(cx, false); + } + + #[gpui::test] + fn runtime_close_preserves_document_edited_while_save_is_pending( + cx: &mut gpui::TestAppContext, + ) { + check_pending_close_draft(cx, true); + } + + fn check_pending_close_draft(cx: &mut gpui::TestAppContext, runtime: bool) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let document = dir.path().join("draft.md"); + std::fs::write(&document, "original").unwrap(); + let (handle, workspace) = cx.update(|cx| { + let (id, workspace) = super::super::transfer_tests::open_test_window(cx, 1); + let handle = entry_by_id(id, cx).unwrap().handle; + handle + .update(cx, |_, window, cx| { + workspace.update(cx, |workspace, cx| { + workspace.open_document_at_startup(document.clone(), window, cx); + }); + }) + .unwrap(); + (handle, workspace) + }); + cx.run_until_parked(); + let (release, waiting) = oneshot::channel(); + cx.update(|cx| { + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(dir.path().join("output.json")); + registry.output_persistence.session_path = dir.path().join("session.json"); + registry.output_persistence.tail = Some(waiting.shared()); + handle + .update(cx, |_, window, cx| { + workspace.update(cx, |workspace, cx| { + if runtime { + workspace.runtime_close_window(None, cx).unwrap().detach(); + } else { + assert!(!workspace.should_close_window(window, cx)); + } + assert!(workspace.window_close_pending); + }); + }) + .unwrap(); + }); + cx.run_until_parked(); + let file = cx.update(|cx| { + let file = workspace.read(cx).tabs.iter().find_map(|tab| tab.file_editor(cx)).unwrap(); + handle + .update(cx, |_, window, cx| { + crate::gpui_shell::file_editor::tests::replace_draft( + &file, + "new unsaved draft", + window, + cx, + ); + }) + .unwrap(); + file + }); + cx.run_until_parked(); + cx.update(|cx| assert!(file.read(cx).is_dirty())); + release.send(()).unwrap(); + cx.run_until_parked(); + cx.update(|cx| { + assert!( + cx.windows().contains(&handle), + "new draft must prevent asynchronous window destruction" + ); + assert!(!workspace.read(cx).window_close_pending); + assert_eq!(file.read(cx).draft(cx).as_ref(), "new unsaved draft"); + }); + assert_eq!(std::fs::read_to_string(document).unwrap(), "original"); + } + + #[gpui::test] + fn disabling_then_enabling_output_invalidates_queued_snapshot(cx: &mut gpui::TestAppContext) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let output = dir.path().join("output.json"); + let session = dir.path().join("session.json"); + let (release, waiting) = oneshot::channel(); + let save = cx.update(|cx| { + use nebula_terminal::{ + event::VoidListener, + term::{Config, Term}, + vte::ansi, + }; + let mut term = Term::new( + Config::default(), + &crate::gpui_shell::terminal::session::GridSize { columns: 80, screen_lines: 24 }, + VoidListener, + ); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut term, b"old command"); + let mut recent = crate::recent_output::RecentOutput::default(); + recent.begin(term.grid()); + parser.advance(&mut term, b"\r\nold output\r\n"); + recent.finish(term.grid()); + let mut settings = + crate::gpui_shell::config::Settings::load(nebula_settings::ThemeName::Nord); + settings.command_output_enabled = true; + cx.set_global(settings); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(output.clone()); + registry.output_persistence.session_path = session.clone(); + registry.output_persistence.tail = Some(waiting.shared()); + enqueue( + vec![( + true, + LocalSnapshot { + session: crate::session::Session::new( + 0, + vec![crate::session::TabSession::single("C:/test".into(), None, None)], + ), + outputs: vec![vec![(1, recent.snapshot(term.grid()))]], + window_id: 1, + }, + )], + SaveReason::Checkpoint, + cx, + ) + }); + cx.run_until_parked(); + cx.update(|cx| { + cx.global_mut::().command_output_enabled = false + }); + cx.run_until_parked(); + cx.update(|cx| { + cx.global_mut::().command_output_enabled = true + }); + cx.run_until_parked(); + release.send(()).unwrap(); + cx.run_until_parked(); + assert!(save.now_or_never().unwrap().unwrap()); + let restored = crate::session::load_local_from(&session).unwrap(); + assert!( + restored.tabs.iter().all(|tab| tab.output_refs.is_empty()), + "re-enabling must not publish pre-disable snapshots" + ); + } + + #[gpui::test] + fn failed_output_write_keeps_window_open_for_retry(cx: &mut gpui::TestAppContext) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let blocker = dir.path().join("not-a-directory"); + std::fs::write(&blocker, b"block").unwrap(); + let session = dir.path().join("session.json"); + let (handle, workspace) = cx.update(|cx| { + let (id, workspace) = super::super::transfer_tests::open_test_window(cx, 1); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(blocker.join("output.json")); + registry.output_persistence.session_path = session.clone(); + let handle = entry_by_id(id, cx).unwrap().handle; + handle + .update(cx, |_, window, cx| { + workspace.update(cx, |workspace, cx| { + assert!(!workspace.close_window_after_documents(window, cx)); + }) + }) + .unwrap(); + (handle, workspace) + }); + cx.run_until_parked(); + cx.update(|cx| { + assert!( + cx.windows().contains(&handle), + "a failed save must not destroy the live terminal" + ); + assert!(!workspace.read(cx).window_close_pending, "close must be retryable"); + }); + assert!(!session.exists(), "failed sidecar must not publish new session references"); + } + + #[gpui::test] + fn autosave_tick_publishes_through_background_output_store(cx: &mut gpui::TestAppContext) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let output = dir.path().join("output.json"); + let session = dir.path().join("session.json"); + cx.update(|cx| { + super::super::transfer_tests::open_test_window(cx, 1); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(output.clone()); + registry.output_persistence.session_path = session.clone(); + autosave_tick(cx); + assert!(!session.exists(), "autosave must not perform disk I/O in the UI callback"); + }); + cx.run_until_parked(); + assert!(output.is_file(), "autosave must write sidecar before session publication"); + let value: serde_json::Value = + serde_json::from_slice(&std::fs::read(session).unwrap()).unwrap(); + assert_eq!(value["tabs"].as_array().unwrap().len(), 1); + assert_eq!(value["clean_exit"], false); + } +} + +pub(super) fn checkpoint(cx: &mut App) { + let registry = cx.global::(); + if registry.quit_pending + || registry.output_persistence.tail.as_ref().is_some_and(|tail| tail.peek().is_none()) + { + return; + } + let save = save(None, SaveReason::Checkpoint, cx); + cx.spawn(async move |cx| match save.await { + Ok(true) => cx.update(|cx| super::acknowledge_session_restore(cx)), + Ok(false) => {}, + Err(error) => log::warn!("Could not checkpoint command output and session: {error}"), + }) + .detach(); +} diff --git a/nebula_app/src/gpui_shell/workspace/windowing/shutdown.rs b/nebula_app/src/gpui_shell/workspace/windowing/shutdown.rs index 934a054d3..0469160e4 100644 --- a/nebula_app/src/gpui_shell/workspace/windowing/shutdown.rs +++ b/nebula_app/src/gpui_shell/workspace/windowing/shutdown.rs @@ -53,7 +53,7 @@ fn request_quit(update: Option, cx: &mut App) } else { None }; - cx.update(|cx| { + let save = cx.update(|cx| { // Recheck the current pane set after asynchronous preparation. A // window/pane opened during the handshake also needs a native target. let identities_ready = cx @@ -71,15 +71,24 @@ fn request_quit(update: Option, cx: &mut App) }); if !ready || !identities_ready { abort_quit(Message::SessionIdentityPending, cx); - return; + return None; } if !documents_unchanged(&approved, cx) { abort_quit(Message::UpdateDraftChanged, cx); - return; + return None; } - if let Err(error) = save_combined_session(cx, true) { - log::warn!("Shutdown cancelled because session save failed: {error}"); - abort_quit(Message::SessionSaveFailed, cx); + Some(output_persistence::save(None, SaveReason::Quit, cx)) + }); + let Some(save) = save else { return }; + if !matches!(save.await, Ok(true)) { + cx.update(|cx| abort_quit(Message::SessionSaveFailed, cx)); + return; + } + cx.update(|cx| { + // A document can change while the output is being written. + if !documents_unchanged(&approved, cx) { + cx.global_mut::().session_persistence.cancel_quit(); + abort_quit(Message::UpdateDraftChanged, cx); return; } if let Some(prepared) = prepared.as_mut() { diff --git a/nebula_app/src/gpui_shell/workspace/windowing/transfer_tests.rs b/nebula_app/src/gpui_shell/workspace/windowing/transfer_tests.rs index 220c87da3..ba86382f3 100644 --- a/nebula_app/src/gpui_shell/workspace/windowing/transfer_tests.rs +++ b/nebula_app/src/gpui_shell/workspace/windowing/transfer_tests.rs @@ -2,7 +2,7 @@ use super::*; use crate::gpui_shell::terminal::view::TerminalLaunch; use gpui::TestAppContext; -fn initialize_test(cx: &mut TestAppContext) { +pub(super) fn initialize_test(cx: &mut TestAppContext) { cx.update(|cx| { gpui_component::init(cx); crate::gpui_shell::math_view::register(cx); @@ -12,7 +12,7 @@ fn initialize_test(cx: &mut TestAppContext) { }); } -fn open_test_window(cx: &mut App, count: usize) -> (u64, Entity) { +pub(super) fn open_test_window(cx: &mut App, count: usize) -> (u64, Entity) { let (id, workspace) = open_workspace_window(cx, WorkspaceStartup::Empty, None, None, false, WindowRole::Regular) .unwrap(); diff --git a/nebula_app/src/main.rs b/nebula_app/src/main.rs index cf44c5a22..d8a13224d 100644 --- a/nebula_app/src/main.rs +++ b/nebula_app/src/main.rs @@ -96,6 +96,7 @@ mod polling; mod process_tree; mod provider_test; mod proxy_test; +mod recent_output; mod remote_dirs; mod render_cache; #[cfg(feature = "legacy-shell")] diff --git a/nebula_app/src/recent_output.rs b/nebula_app/src/recent_output.rs new file mode 100644 index 000000000..a6c082268 --- /dev/null +++ b/nebula_app/src/recent_output.rs @@ -0,0 +1,256 @@ +//! 逐终端的有界命令显示记录;调用方只提交已确认的 shell 命令。 + +use nebula_terminal::grid::snapshot::DisplaySnapshot; +use nebula_terminal::grid::{Dimensions, Grid}; +use nebula_terminal::index::Line; +use nebula_terminal::term::cell::{Cell, Flags}; +use serde::{Deserialize, Serialize}; + +pub(crate) mod storage; + +const MAX_RECORD_BYTES: usize = 256 * 1024; +const MAX_CAPTURE_CELLS: usize = 4096; + +// 仅在保存边界编码,按整行缩小,避免切断 UTF-8 或宽字符。 +fn capture_bounded( + grid: &Grid, + range: std::ops::Range, + byte_budget: usize, +) -> DisplaySnapshot { + let mut low = 0; + let mut high = MAX_CAPTURE_CELLS / grid.columns(); + let mut best = DisplaySnapshot::capture(grid, range.clone(), 0); + while low <= high { + let rows = low + (high - low) / 2; + let candidate = DisplaySnapshot::capture(grid, range.clone(), rows * grid.columns()); + if serde_json::to_vec(&candidate).is_ok_and(|bytes| bytes.len() <= byte_budget) { + best = candidate; + low = rows + 1; + } else if rows == 0 { + break; + } else { + high = rows - 1; + } + } + best +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub(crate) struct CommandRecord { + #[serde(default)] + pub(crate) captured_at: u64, + prompt: DisplaySnapshot, + output: DisplaySnapshot, +} + +#[derive(Default)] +pub(crate) struct RecentOutput { + records: Vec, + active_output_start: Option, +} + +impl RecentOutput { + pub(crate) fn begin(&mut self, grid: &Grid) { + let mut start = grid.cursor.point.line; + while start.0 > -(grid.history_size() as i32) + && grid[Line(start.0 - 1)][nebula_terminal::index::Column(grid.columns() - 1)] + .flags + .contains(Flags::WRAPLINE) + { + start.0 -= 1; + } + let end = Line(grid.cursor.point.line.0 + 1); + if self.records.len() == 5 { + self.records.remove(0); + } + self.records.push(CommandRecord { + captured_at: std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map_or(0, |duration| duration.as_micros().min(u64::MAX as u128) as u64), + prompt: capture_bounded(grid, start..end, MAX_RECORD_BYTES / 2), + output: DisplaySnapshot::capture(grid, end..end, 0), + }); + self.active_output_start = Some(grid.scrolled_out() + grid.history_size() + end.0 as usize); + } + + pub(crate) fn finish(&mut self, grid: &Grid) { + if let Some(output) = self.capture_active(grid, false) { + if let Some(record) = self.records.last_mut() { + record.output = output; + } + } + self.active_output_start = None; + } + + pub(crate) fn snapshot(&self, grid: &Grid) -> Vec { + let mut records = self.records.clone(); + if let Some(output) = self.capture_active(grid, true) { + if let Some(record) = records.last_mut() { + record.output = output; + } + } + records + } + + fn capture_active(&self, grid: &Grid, include_cursor: bool) -> Option { + let absolute = self.active_output_start?; + let origin = grid.scrolled_out() + grid.history_size(); + let start = (absolute as i128 - origin as i128).clamp(i32::MIN as i128, i32::MAX as i128); + let end = grid.cursor.point.line.0 + i32::from(include_cursor); + let prompt_bytes = serde_json::to_vec(&self.records.last()?.prompt).ok()?.len(); + // 为字段名、标点及采集时间预留空间,确保整条记录仍在预算内。 + let budget = MAX_RECORD_BYTES.saturating_sub(prompt_bytes + 64); + Some(capture_bounded(grid, Line(start as i32)..Line(end), budget)) + } + pub(crate) fn try_from_records(records: Vec) -> Result { + Self::validate_records(&records)?; + Ok(Self { records, active_output_start: None }) + } + + pub(crate) fn validate_records(records: &[CommandRecord]) -> Result<(), &'static str> { + if records.len() > 5 { + return Err("too many command records"); + } + for record in records { + let bytes = serde_json::to_vec(record).map_err(|_| "invalid command record")?; + if bytes.len() > MAX_RECORD_BYTES { + return Err("command record exceeds byte budget"); + } + } + Ok(()) + } + pub(crate) fn restore(&self, grid: &mut Grid) -> Result<(), &'static str> { + // 每次静态导入都插在现有历史之前,因此从最新记录的输出开始。 + for record in self.records.iter().rev() { + record.output.restore_scrollback(grid)?; + record.prompt.restore_scrollback(grid)?; + } + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use nebula_terminal::event::VoidListener; + use nebula_terminal::grid::Dimensions; + use nebula_terminal::index::{Column, Line}; + use nebula_terminal::term::{Config, Term}; + use nebula_terminal::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 + } + } + + #[test] + fn retains_five_commands_with_output_in_order_without_reexecuting() { + let mut term = Term::new(Config::default(), &Size, VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + let mut recent = RecentOutput::default(); + for index in 0..7 { + parser.advance(&mut term, format!("C:>echo {index}").as_bytes()); + recent.begin(term.grid()); + parser.advance(&mut term, format!("\r\nresult{index}\r\n").as_bytes()); + recent.finish(term.grid()); + } + let records = recent.snapshot(term.grid()); + assert_eq!(records.len(), 5); + let mut target = Term::new(Config::default(), &Size, VoidListener); + RecentOutput::try_from_records(records).unwrap().restore(target.grid_mut()).unwrap(); + let text = target.bounds_to_string( + nebula_terminal::index::Point::new( + Line(-(target.grid().history_size() as i32)), + Column(0), + ), + nebula_terminal::index::Point::new(Line(-1), Column(31)), + ); + assert!(!text.contains("echo 1")); + assert!(text.contains("echo 2")); + assert!(text.contains("result6")); + assert!(text.find("result2").unwrap() < text.find("result6").unwrap()); + assert_eq!(target.grid().cursor.point.line, Line(0)); + assert_eq!(target.grid()[Line(0)][Column(0)].c, ' '); + } + + #[test] + fn loading_rejects_excess_records_instead_of_growing_on_next_command() { + let mut term = Term::new(Config::default(), &Size, VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut term, b"C:>echo test"); + let mut recent = RecentOutput::default(); + recent.begin(term.grid()); + let record = recent.snapshot(term.grid()).remove(0); + assert!(RecentOutput::try_from_records(vec![record; 6]).is_err()); + } + + #[test] + fn loading_rejects_oversize_records_before_restore() { + let mut term = Term::new(Config::default(), &Size, VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + for _ in 0..200 { + parser.advance(&mut term, b"long unbounded output\r\n"); + } + let snapshot = DisplaySnapshot::capture(term.grid(), Line(-200)..Line(0), 6400); + let record = CommandRecord { captured_at: 0, prompt: snapshot.clone(), output: snapshot }; + assert!(serde_json::to_vec(&record).unwrap().len() > MAX_RECORD_BYTES); + assert!(RecentOutput::try_from_records(vec![record]).is_err()); + } + + #[test] + fn encoded_record_keeps_command_and_tail_within_256_kib() { + let mut term = Term::new(Config::default(), &Size, VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut term, b"C:>large-tool"); + let mut recent = RecentOutput::default(); + recent.begin(term.grid()); + for index in 0..300 { + parser.advance( + &mut term, + format!("\r\n\x1b[38;2;123;234;245mrow{index:03} output\x1b[0m").as_bytes(), + ); + } + let records = recent.snapshot(term.grid()); + let encoded = serde_json::to_vec(&records[0]).unwrap(); + assert!(encoded.len() <= 256 * 1024, "{} encoded bytes", encoded.len()); + let mut target = Term::new(Config::default(), &Size, VoidListener); + RecentOutput::try_from_records(records).unwrap().restore(target.grid_mut()).unwrap(); + let text = target.bounds_to_string( + nebula_terminal::index::Point::new( + Line(-(target.grid().history_size() as i32)), + Column(0), + ), + nebula_terminal::index::Point::new(Line(-1), Column(31)), + ); + assert!(text.contains("C:>large-tool")); + assert!(text.contains("row299 output")); + assert!(!text.contains("row000 output")); + } + + #[test] + fn active_output_is_captured_and_two_restores_do_not_duplicate_records() { + let mut term = Term::new(Config::default(), &Size, VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut term, b"C:>tool"); + let mut recent = RecentOutput::default(); + recent.begin(term.grid()); + parser.advance(&mut term, b"\r\npartial"); + let records = recent.snapshot(term.grid()); + assert_eq!(records.len(), 1); + let encoded = serde_json::to_vec(&records).unwrap(); + let restored = + RecentOutput::try_from_records(serde_json::from_slice(&encoded).unwrap()).unwrap(); + let empty = Term::new(Config::default(), &Size, VoidListener); + let encoded_again = serde_json::to_vec(&restored.snapshot(empty.grid())).unwrap(); + assert_eq!(encoded_again, encoded); + } +} diff --git a/nebula_app/src/recent_output/storage.rs b/nebula_app/src/recent_output/storage.rs new file mode 100644 index 000000000..27863051a --- /dev/null +++ b/nebula_app/src/recent_output/storage.rs @@ -0,0 +1,253 @@ +//! 本机 sidecar 编解码边界;调用方拥有保存顺序和清除代次。 + +use std::collections::BTreeMap; +use std::io::{self, Read, Write}; +use std::path::Path; + +use serde::{Deserialize, Serialize}; + +use super::CommandRecord; + +pub(crate) const MAX_STORE_BYTES: usize = 16 * 1024 * 1024; +const MAX_TRANSACTION_BYTES: usize = 2 * MAX_STORE_BYTES; + +pub(crate) fn archive_path() -> std::path::PathBuf { + crate::display::nebula_data_dir().join("command-output.json") +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub(crate) struct Archive { + version: u32, + panes: BTreeMap>, + #[serde(default, skip_serializing_if = "Option::is_none")] + previous: Option>, +} + +impl Archive { + pub(crate) fn new(panes: BTreeMap>) -> Self { + Self { version: 1, panes, previous: None } + } + + pub(crate) fn take_records(&mut self, id: &str) -> Option> { + self.panes.remove(id).or_else(|| self.previous.as_mut()?.take_records(id)) + } + + fn validate(&self) -> io::Result<()> { + if self.version != 1 || self.panes.len() > 4096 { + return Err(invalid("unsupported or oversized output archive")); + } + for (id, records) in &self.panes { + if id.is_empty() + || id.len() > 128 + || !id.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-') + { + return Err(invalid("invalid pane reference")); + } + super::RecentOutput::validate_records(records).map_err(invalid)?; + } + Ok(()) + } + + fn encode(&self) -> io::Result> { + self.validate()?; + if let Some(previous) = &self.previous { + if previous.previous.is_some() { + return Err(invalid("nested output transaction")); + } + // 两代各自仍受正常上限约束,不能用交接额度保存一份过大的快照。 + previous.encode()?; + Self::new(self.panes.clone()).encode()?; + } + let limit = if self.previous.is_some() { MAX_TRANSACTION_BYTES } else { MAX_STORE_BYTES }; + let mut encoded = LimitedBuffer { bytes: Vec::new(), limit }; + serde_json::to_writer(&mut encoded, self).map_err(io::Error::other)?; + Ok(encoded.bytes) + } + + pub(crate) fn write_to(&self, path: &Path) -> io::Result<()> { + crate::atomic_file::write(path, &self.encode()?) + } + + /// 从中断的两代交接中只保留已发布会话实际引用的记录。 + fn retain_references(&mut self, references: &[String]) { + let mut panes = BTreeMap::new(); + for id in references { + if let Some(records) = self.take_records(id) { + panes.insert(id.clone(), records); + } + } + *self = Self::new(panes); + } + + pub(crate) fn read_from(path: &Path) -> io::Result { + let file = std::fs::File::open(path)?; + if file.metadata()?.len() > MAX_TRANSACTION_BYTES as u64 { + return Err(invalid("output archive exceeds byte budget")); + } + // metadata 之后仍可能增长,读取也必须限流。 + let mut bytes = Vec::new(); + file.take(MAX_TRANSACTION_BYTES as u64 + 1).read_to_end(&mut bytes)?; + if bytes.len() > MAX_TRANSACTION_BYTES { + return Err(invalid("output archive exceeds byte budget")); + } + let archive: Self = serde_json::from_slice(&bytes).map_err(invalid)?; + // 普通文件不能借助读入上限突破 16 MiB;交接文件逐代复核。 + if archive.previous.is_none() && bytes.len() > MAX_STORE_BYTES { + return Err(invalid("output archive exceeds byte budget")); + } + archive.encode().map_err(invalid)?; + Ok(archive) + } +} + +fn invalid(message: impl std::fmt::Display) -> io::Error { + io::Error::new(io::ErrorKind::InvalidData, message.to_string()) +} + +struct LimitedBuffer { + bytes: Vec, + limit: usize, +} + +impl Write for LimitedBuffer { + fn write(&mut self, bytes: &[u8]) -> io::Result { + if bytes.len() > self.limit.saturating_sub(self.bytes.len()) { + return Err(invalid("output archive exceeds byte budget")); + } + self.bytes.extend_from_slice(bytes); + Ok(bytes.len()) + } + + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } +} + +mod lifecycle; +pub(crate) use lifecycle::OutputStore; + +#[cfg(test)] +mod tests { + use super::*; + use crate::recent_output::RecentOutput; + use nebula_terminal::event::VoidListener; + use nebula_terminal::grid::Dimensions; + use nebula_terminal::term::{Config, Term}; + use nebula_terminal::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 + } + } + + pub(super) fn records(command: &str) -> Vec { + let mut term = Term::new(Config::default(), &Size, VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut term, command.as_bytes()); + let mut recent = RecentOutput::default(); + recent.begin(term.grid()); + parser.advance(&mut term, b"\r\nresult\r\n"); + recent.finish(term.grid()); + let mut records = recent.snapshot(term.grid()); + for record in &mut records { + record.captured_at = 0; + } + records + } + + #[test] + fn atomic_round_trip_keeps_same_directory_panes_separate() { + let directory = tempfile::tempdir().unwrap(); + let path = directory.path().join("outputs.json"); + let archive = Archive::new(BTreeMap::from([ + ("pane-one".into(), records("C:>echo one")), + ("pane-two".into(), records("C:>echo two")), + ])); + archive.write_to(&path).unwrap(); + let loaded = Archive::read_from(&path).unwrap(); + assert_eq!(loaded.panes.len(), 2); + assert_eq!(serde_json::to_value(loaded).unwrap(), serde_json::to_value(archive).unwrap()); + } + + #[test] + fn restore_resolves_exact_identity_once_and_never_falls_back_to_another_pane() { + let mut archive = Archive::new(BTreeMap::from([ + ("pane-one".into(), records("C:>echo one")), + ("pane-two".into(), records("C:>echo two")), + ])); + assert!(archive.take_records("missing").is_none()); + let one = archive.take_records("pane-one").unwrap(); + assert!(archive.take_records("pane-one").is_none()); + assert_eq!( + serde_json::to_value(one).unwrap(), + serde_json::to_value(records("C:>echo one")).unwrap() + ); + assert!(archive.take_records("pane-two").is_some()); + } + + #[test] + fn invalid_write_does_not_replace_last_good_archive() { + let directory = tempfile::tempdir().unwrap(); + let path = directory.path().join("outputs.json"); + let mut archive = Archive::new(BTreeMap::from([("pane".into(), records("C:>good"))])); + archive.write_to(&path).unwrap(); + let before = std::fs::read(&path).unwrap(); + archive.version = 999; + assert!(archive.write_to(&path).is_err()); + assert_eq!(std::fs::read(path).unwrap(), before); + } + + #[test] + fn transaction_cannot_hide_oversized_generation_or_nested_transactions() { + let directory = tempfile::tempdir().unwrap(); + let path = directory.path().join("outputs.json"); + let record = records("C:>safe"); + let bytes = serde_json::to_vec(&record).unwrap().len(); + let oversized = Archive::new( + (0..(17 * 1024 * 1024 / bytes)) + .map(|index| (format!("pane-{index}"), record.clone())) + .collect(), + ); + let mut transaction = Archive::new(BTreeMap::new()); + transaction.previous = Some(Box::new(oversized)); + std::fs::write(&path, serde_json::to_vec(&transaction).unwrap()).unwrap(); + assert!(Archive::read_from(&path).is_err()); + assert!(transaction.write_to(&path).is_err()); + let mut nested = Archive::new(BTreeMap::new()); + nested.previous = Some(Box::new(Archive::new(BTreeMap::new()))); + transaction.previous = Some(Box::new(nested)); + std::fs::write(&path, serde_json::to_vec(&transaction).unwrap()).unwrap(); + assert!(Archive::read_from(&path).is_err()); + let oversized = std::fs::File::create(&path).unwrap(); + oversized.set_len(MAX_TRANSACTION_BYTES as u64 + 1).unwrap(); + drop(oversized); + assert!(Archive::read_from(&path).is_err()); + } + + #[test] + fn malformed_version_oversize_and_excess_records_are_rejected() { + let directory = tempfile::tempdir().unwrap(); + let path = directory.path().join("outputs.json"); + for contents in [b"broken".as_slice(), b"{\"version\":2,\"panes\":{}}"] { + std::fs::write(&path, contents).unwrap(); + assert!(Archive::read_from(&path).is_err()); + } + let oversized = std::fs::File::create(&path).unwrap(); + oversized.set_len(MAX_STORE_BYTES as u64 + 1).unwrap(); + drop(oversized); + assert!(Archive::read_from(&path).is_err()); + let record = records("C:>test").remove(0); + let archive = Archive::new(BTreeMap::from([("pane".into(), vec![record; 6])])); + std::fs::write(&path, serde_json::to_vec(&archive).unwrap()).unwrap(); + assert!(Archive::read_from(&path).is_err()); + } +} diff --git a/nebula_app/src/recent_output/storage/lifecycle.rs b/nebula_app/src/recent_output/storage/lifecycle.rs new file mode 100644 index 000000000..56fc05bf0 --- /dev/null +++ b/nebula_app/src/recent_output/storage/lifecycle.rs @@ -0,0 +1,418 @@ +//! 后台串行文件操作;UI 仅递增代次,不持有磁盘 I/O 锁。 + +use std::io; +use std::path::PathBuf; +use std::sync::atomic::{AtomicU64, Ordering}; +use std::sync::{Arc, Mutex}; + +use super::Archive; + +#[derive(Clone)] +pub(crate) struct OutputStore { + inner: Arc, +} + +struct StoreState { + path: PathBuf, + generation: AtomicU64, + writer: Mutex<()>, +} + +impl OutputStore { + pub(crate) fn new(path: PathBuf) -> Self { + Self { + inner: Arc::new(StoreState { + path, + generation: AtomicU64::new(0), + writer: Mutex::new(()), + }), + } + } + + pub(crate) fn next_generation(&self) -> u64 { + self.inner.generation.fetch_add(1, Ordering::SeqCst) + 1 + } + + /// 仅由后台执行器调用;返回 false 表示快照已被更新或清除取代。 + pub(crate) fn save(&self, generation: u64, archive: &Archive) -> io::Result { + self.with_generation(generation, || archive.write_to(&self.inner.path)) + } + + /// 后台保存 sidecar 后再发布本机会话引用;发布失败保留上一份有效输出。 + pub(crate) fn save_and_publish( + &self, + generation: u64, + archive: &Archive, + publish: impl FnOnce() -> io::Result<()>, + ) -> io::Result { + self.save_referenced(generation, archive, None, publish) + } + + pub(crate) fn save_referenced( + &self, + generation: u64, + archive: &Archive, + references: Option<&[String]>, + publish: impl FnOnce() -> io::Result<()>, + ) -> io::Result { + self.with_generation(generation, || { + // 新快照先校验,绝不因为旧文件损坏而接受无效的新内容。 + archive.encode()?; + let mut previous = match Archive::read_from(&self.inner.path) { + Ok(archive) => Some(archive), + Err(error) if error.kind() == io::ErrorKind::NotFound => None, + Err(error) if error.kind() == io::ErrorKind::InvalidData => { + log::warn!("Ignoring invalid command output archive: {error}"); + None + }, + Err(error) => return Err(error), + }; + // 引用必须标识不可变快照,提交期间两代同时可读。进程在发布前 + // 退出时旧 session 仍有效,发布后退出时新 session 也有效。 + if let Some(previous) = &mut previous { + if previous.previous.is_some() { + let references = references.ok_or_else(|| { + io::Error::new( + io::ErrorKind::InvalidData, + "interrupted output publication requires session references", + ) + })?; + previous.retain_references(references); + } + } + let mut staged = archive.clone(); + for (id, records) in &archive.panes { + if let Some(old) = previous.as_ref().and_then(|previous| previous.panes.get(id)) + && serde_json::to_vec(old)? != serde_json::to_vec(records)? + { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + "output reference reused for different data", + )); + } + } + staged.previous = previous.clone().map(Box::new); + staged.write_to(&self.inner.path)?; + if generation != self.inner.generation.load(Ordering::SeqCst) { + return self.restore_previous(previous.as_ref()); + } + if let Err(error) = publish() { + self.restore_previous(previous.as_ref()).map_err(|rollback| { + io::Error::other(format!( + "session publish failed: {error}; output rollback failed: {rollback}" + )) + })?; + return Err(error); + } + // 发布已成功,压缩失败不回滚引用;旧数据留到下一次成功提交清理。 + if let Err(error) = archive.write_to(&self.inner.path) { + log::warn!("Could not prune previous command output: {error}"); + } + Ok(()) + }) + } + + fn restore_previous(&self, previous: Option<&Archive>) -> io::Result<()> { + match previous { + Some(archive) => archive.write_to(&self.inner.path), + None => std::fs::remove_file(&self.inner.path), + } + } + + /// 清除完成后旧写入不能重新出现;调用方须等待结果再显示成功。 + pub(crate) fn clear(&self, generation: u64) -> io::Result { + self.with_generation(generation, || match std::fs::remove_file(&self.inner.path) { + Ok(()) => Ok(()), + Err(error) if error.kind() == io::ErrorKind::NotFound => Ok(()), + Err(error) => Err(error), + }) + } + + fn with_generation( + &self, + generation: u64, + operation: impl FnOnce() -> io::Result<()>, + ) -> io::Result { + let _writer = + self.inner.writer.lock().map_err(|_| io::Error::other("output writer poisoned"))?; + if generation != self.inner.generation.load(Ordering::SeqCst) { + return Ok(false); + } + operation()?; + // UI 可在 I/O 中使代次失效;后续清除在同一锁之后执行。 + Ok(generation == self.inner.generation.load(Ordering::SeqCst)) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::recent_output::storage::{Archive, tests::records}; + use std::collections::BTreeMap; + + fn archive(id: &str) -> Archive { + Archive::new(BTreeMap::from([(id.into(), records("C:>echo safe"))])) + } + + #[test] + fn regression_corrupt_archive_does_not_block_new_session_publication() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + std::fs::write(&path, b"{broken archive").unwrap(); + let store = OutputStore::new(path.clone()); + let published = std::cell::Cell::new(false); + assert!( + store + .save_and_publish(store.next_generation(), &archive("new"), || { + published.set(true); + Ok(()) + }) + .unwrap() + ); + assert!(published.get()); + assert!(Archive::read_from(&path).unwrap().panes.contains_key("new")); + } + + #[test] + fn regression_two_valid_large_generations_do_not_block_publication() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let records = records("C:>echo safe"); + let entry_bytes = serde_json::to_vec(&records).unwrap().len(); + let count = 9 * 1024 * 1024 / entry_bytes; + let large = |prefix: &str| { + Archive::new( + (0..count).map(|index| (format!("{prefix}-{index}"), records.clone())).collect(), + ) + }; + let previous = large("previous"); + let next = large("next"); + previous.write_to(&path).unwrap(); + let old_len = std::fs::metadata(&path).unwrap().len(); + assert!(old_len > 8 * 1024 * 1024 && old_len < 16 * 1024 * 1024); + let store = OutputStore::new(path.clone()); + assert!( + store + .save_and_publish(store.next_generation(), &next, || { + let staged = Archive::read_from(&path)?; + let mut staged = staged; + assert!(staged.take_records("previous-0").is_some()); + assert!(staged.take_records("next-0").is_some()); + Ok(()) + }) + .unwrap() + ); + let restored = Archive::read_from(&path).unwrap(); + assert!(restored.panes.contains_key("next-0")); + assert!(!restored.panes.contains_key("previous-0")); + } + + #[test] + fn interrupted_publication_keeps_only_referenced_generation_on_retry() { + for reference in ["previous", "next"] { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let mut interrupted = archive("next"); + interrupted.previous = Some(Box::new(archive("previous"))); + interrupted.write_to(&path).unwrap(); + let store = OutputStore::new(path.clone()); + let references = vec![reference.to_string()]; + assert!( + store + .save_referenced( + store.next_generation(), + &archive("third"), + Some(&references), + || { + let mut during = Archive::read_from(&path)?; + assert!(during.take_records(reference).is_some()); + assert!(during.take_records("third").is_some()); + let unreferenced = + if reference == "previous" { "next" } else { "previous" }; + assert!(during.take_records(unreferenced).is_none()); + Ok(()) + } + ) + .unwrap() + ); + let after = Archive::read_from(&path).unwrap(); + assert!(after.previous.is_none()); + assert_eq!(after.panes.len(), 1); + } + } + + #[test] + fn interrupted_publication_failed_retry_preserves_referenced_output() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let mut interrupted = archive("next"); + interrupted.previous = Some(Box::new(archive("previous"))); + interrupted.write_to(&path).unwrap(); + let store = OutputStore::new(path.clone()); + assert!( + store + .save_referenced( + store.next_generation(), + &archive("third"), + Some(&["previous".into()]), + || { Err(io::Error::other("publication failed")) } + ) + .is_err() + ); + let mut after = Archive::read_from(&path).unwrap(); + assert!(after.take_records("previous").is_some()); + assert!(after.take_records("third").is_none()); + } + + #[test] + fn delayed_save_cannot_resurrect_cleared_output() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let store = OutputStore::new(path.clone()); + let old = store.next_generation(); + let clear = store.next_generation(); + store.clear(clear).unwrap(); + assert!(!store.save(old, &archive("old")).unwrap()); + assert!(!path.exists()); + let new = store.next_generation(); + assert!(store.save(new, &archive("new")).unwrap()); + assert!(Archive::read_from(&path).unwrap().panes.contains_key("new")); + } + + #[test] + fn out_of_order_save_cannot_reintroduce_closed_pane() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let store = OutputStore::new(path.clone()); + let old = store.next_generation(); + let new = store.next_generation(); + store.save(new, &archive("remaining")).unwrap(); + assert!(!store.save(old, &archive("closed")).unwrap()); + let archive = Archive::read_from(&path).unwrap(); + assert_eq!(archive.panes.len(), 1); + assert!(archive.panes.contains_key("remaining")); + } + + #[test] + fn checkpoint_publishes_references_only_after_output_is_durable() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let store = OutputStore::new(path.clone()); + let generation = store.next_generation(); + let published = std::cell::Cell::new(false); + assert!( + store + .save_and_publish(generation, &archive("new"), || { + assert!(Archive::read_from(&path)?.panes.contains_key("new")); + published.set(true); + Ok(()) + }) + .unwrap() + ); + assert!(published.get()); + assert!( + !store + .save_and_publish(generation - 1, &archive("stale"), || { + panic!("stale checkpoint must not publish session references") + }) + .unwrap() + ); + } + + #[test] + fn previous_references_remain_readable_until_new_session_is_published() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let store = OutputStore::new(path.clone()); + store.save(store.next_generation(), &archive("previous")).unwrap(); + let next = store.next_generation(); + store + .save_and_publish(next, &archive("new"), || { + let mut during = Archive::read_from(&path)?; + assert!( + during.take_records("previous").is_some(), + "old session must survive a crash before publication" + ); + assert!(during.panes.contains_key("new")); + Ok(()) + }) + .unwrap(); + let after = Archive::read_from(&path).unwrap(); + assert!(after.panes.contains_key("new")); + assert!(!after.panes.contains_key("previous")); + } + + #[test] + fn failed_session_publication_restores_previous_output_archive() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let store = OutputStore::new(path.clone()); + let old = store.next_generation(); + store.save(old, &archive("previous")).unwrap(); + let before = std::fs::read(&path).unwrap(); + let next = store.next_generation(); + assert!( + store + .save_and_publish(next, &archive("new"), || { + Err(io::Error::other("session write failed")) + }) + .is_err() + ); + assert_eq!(std::fs::read(&path).unwrap(), before); + assert!(store.save_and_publish(next, &archive("new"), || Ok(())).unwrap()); + } + + #[test] + fn reusing_reference_for_different_output_does_not_overwrite_previous_data() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let store = OutputStore::new(path.clone()); + store.save(store.next_generation(), &archive("same-id")).unwrap(); + let before = std::fs::read(&path).unwrap(); + let changed = + Archive::new(BTreeMap::from([("same-id".into(), records("C:>different command"))])); + assert!( + store + .save_and_publish(store.next_generation(), &changed, || { + panic!("a conflicting identity must never be published") + }) + .is_err() + ); + assert_eq!(std::fs::read(path).unwrap(), before); + } + + #[test] + fn invalidation_during_publication_does_not_acknowledge_or_resurrect_cleared_output() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let store = OutputStore::new(path.clone()); + let generation = store.next_generation(); + let clear = std::cell::Cell::new(0); + assert!( + !store + .save_and_publish(generation, &archive("new"), || { + clear.set(store.next_generation()); + Ok(()) + }) + .unwrap() + ); + assert!(store.clear(clear.get()).unwrap()); + assert!(!store.save(generation, &archive("new")).unwrap()); + assert!(!path.exists()); + } + + #[test] + fn failed_save_preserves_previous_archive_and_allows_retry() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let store = OutputStore::new(path.clone()); + let first = store.next_generation(); + store.save(first, &archive("before")).unwrap(); + let next = store.next_generation(); + let mut invalid = archive("after"); + invalid.version = 999; + assert!(store.save(next, &invalid).is_err()); + assert!(Archive::read_from(&path).unwrap().panes.contains_key("before")); + assert!(store.save(next, &archive("after")).unwrap()); + } +} diff --git a/nebula_app/src/session.rs b/nebula_app/src/session.rs index e02873827..0a865c1ba 100644 --- a/nebula_app/src/session.rs +++ b/nebula_app/src/session.rs @@ -20,6 +20,7 @@ use serde::{Deserialize, Serialize}; use crate::display::color::Rgb; +mod local_output; mod window_layout; pub use window_layout::WindowLayout; pub(crate) use window_layout::combine_sessions; @@ -199,12 +200,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(), + } } } @@ -261,7 +273,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") } @@ -278,7 +290,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. @@ -290,7 +306,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() @@ -311,8 +327,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/nebula_app/src/session/local_output.rs b/nebula_app/src/session/local_output.rs new file mode 100644 index 000000000..d63b1f7ae --- /dev/null +++ b/nebula_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/nebula_app/src/window_context/session_snapshot.rs b/nebula_app/src/window_context/session_snapshot.rs index c449b39bc..19ce8a194 100644 --- a/nebula_app/src/window_context/session_snapshot.rs +++ b/nebula_app/src/window_context/session_snapshot.rs @@ -77,6 +77,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/nebula_settings/src/lib.rs b/nebula_settings/src/lib.rs index 2df4bc670..66859e4d2 100644 --- a/nebula_settings/src/lib.rs +++ b/nebula_settings/src/lib.rs @@ -1019,6 +1019,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, @@ -1106,6 +1108,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()) } @@ -1196,6 +1202,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, @@ -1546,6 +1553,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 cad23d848..d4571e9dc 100644 --- a/nebula_settings/src/reset.rs +++ b/nebula_settings/src/reset.rs @@ -48,6 +48,7 @@ const RESET_KEYS: &[&str] = &[ "auto_download_updates", "keep_session", "restore_session", + "save_command_output", "resume_ai", "tray", "silent_start", diff --git a/nebula_terminal/src/grid/mod.rs b/nebula_terminal/src/grid/mod.rs index dcde45a67..88afd649f 100644 --- a/nebula_terminal/src/grid/mod.rs +++ b/nebula_terminal/src/grid/mod.rs @@ -12,6 +12,7 @@ use crate::vte::ansi::{CharsetIndex, StandardCharset}; pub mod resize; mod row; +pub mod snapshot; mod storage; #[cfg(test)] mod tests; diff --git a/nebula_terminal/src/grid/snapshot.rs b/nebula_terminal/src/grid/snapshot.rs new file mode 100644 index 000000000..80ffdb9ba --- /dev/null +++ b/nebula_terminal/src/grid/snapshot.rs @@ -0,0 +1,254 @@ +//! 安全显示数据快照:不保存终端协议、链接动作或运行状态。 + +use super::{Dimensions, Grid}; +use crate::index::{Column, Line}; +use crate::term::cell::Cell; + +#[cfg(feature = "serde")] +mod serialization; + +// 解码后的防灾上限;持久化层还须独立限制每条记录的编码字节数。 +const MAX_SNAPSHOT_CELLS: usize = 262_144; + +#[derive(Clone, Debug, Default)] +pub struct DisplaySnapshot { + columns: usize, + rows: Vec>, +} + +impl DisplaySnapshot { + pub fn capture(grid: &Grid, range: std::ops::Range, max_cells: usize) -> Self { + let max_cells = max_cells.min(MAX_SNAPSHOT_CELLS); + let columns = grid.columns(); + let end = range.end.0.min(grid.screen_lines() as i32); + let start = range.start.0.max(-(grid.history_size() as i32)); + let start = + start.max(end.saturating_sub((max_cells / columns).min(i32::MAX as usize) as i32)); + let rows = (start..end) + .map(|line| { + (0..columns) + .map(|column| { + let mut cell = grid[Line(line)][Column(column)].clone(); + cell.set_hyperlink(None); + cell + }) + .collect() + }) + .collect(); + Self { columns, rows } + } + + fn validate(&self) -> Result<(), &'static str> { + if self.columns == 0 + || self.rows.len() > MAX_SNAPSHOT_CELLS / self.columns + || self.rows.iter().any(|row| { + row.len() != self.columns + || row.iter().any(|cell| { + (cell.c.is_control() && cell.c != '\t') + || cell.hyperlink().is_some() + || cell + .zerowidth() + .is_some_and(|chars| chars.iter().any(|c| c.is_control())) + }) + }) + { + return Err("invalid display snapshot"); + } + Ok(()) + } + + pub fn restore_scrollback(&self, grid: &mut Grid) -> Result<(), &'static str> { + self.validate()?; + if self.rows.is_empty() { + return Ok(()); + } + if self.columns != grid.columns() { + // 只重排快照,不 resize 活终端;复用已有宽字符/软换行规则。 + let reflow_capacity = self.rows.len().saturating_mul(self.columns); + let mut staging = Grid::::new(1, self.columns, reflow_capacity); + self.restore_scrollback(&mut staging)?; + staging.resize(true, 1, grid.columns()); + let reflowed = Self::capture( + &staging, + Line(-(staging.history_size() as i32))..Line(0), + usize::MAX, + ); + return reflowed.restore_scrollback(grid); + } + let old_history = grid.history_size(); + let count = self.rows.len().min(grid.max_scroll_limit.saturating_sub(old_history)); + grid.raw.initialize(count, grid.columns()); + let top = -((old_history + count) as i32); + for (index, row) in self.rows.iter().rev().take(count).rev().enumerate() { + for (column, cell) in row.iter().enumerate() { + grid[Line(top + index as i32)][Column(column)] = cell.clone(); + } + } + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::event::VoidListener; + use crate::term::{Config, Term, test::TermSize}; + use crate::vte::ansi; + + #[test] + fn restores_reflowed_unicode_before_existing_history_without_touching_prompt() { + let mut source = Term::new(Config::default(), &TermSize::new(8, 3), VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut source, "ab中文e\u{301}XYZ\r\n".as_bytes()); + let snapshot = DisplaySnapshot::capture(source.grid(), Line(0)..Line(2), 100); + let mut target = Term::new(Config::default(), &TermSize::new(5, 2), VoidListener); + parser.advance(&mut target, b"keep\r\nlast\r\nnew>"); + snapshot.restore_scrollback(target.grid_mut()).unwrap(); + assert_eq!(target.grid().history_size(), 4); + let text: String = (-4..-1) + .flat_map(|line| (0..5).map(move |col| (line, col))) + .filter_map(|(line, col)| { + let cell = &target.grid()[Line(line)][Column(col)]; + (!cell.flags.intersects( + crate::term::cell::Flags::WIDE_CHAR_SPACER + | crate::term::cell::Flags::LEADING_WIDE_CHAR_SPACER, + ) && cell.c != ' ') + .then_some(cell.c) + }) + .collect(); + assert_eq!(text, "ab中文eXYZ"); + assert_eq!(target.grid()[Line(-3)][Column(2)].zerowidth(), Some(&['\u{301}'][..])); + assert_eq!(target.grid()[Line(-1)][Column(0)].c, 'k'); + assert_eq!(target.grid()[Line(1)][Column(0)].c, 'n'); + assert_eq!(target.grid().cursor.point, crate::index::Point::new(Line(1), Column(4))); + } + + #[cfg(feature = "serde")] + #[test] + fn serialized_snapshot_round_trips_display_only_and_rejects_actions() { + let mut source = Term::new(Config::default(), &TermSize::new(4, 2), VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut source, "\x1b[38;2;12;34;56me\u{301}中".as_bytes()); + let snapshot = DisplaySnapshot::capture(source.grid(), Line(0)..Line(1), 4); + let value = serde_json::to_value(&snapshot).unwrap(); + let decoded: DisplaySnapshot = serde_json::from_value(value.clone()).unwrap(); + let mut target = Grid::::new(2, 4, 10); + decoded.restore_scrollback(&mut target).unwrap(); + assert_eq!(target[Line(-1)][Column(0)].zerowidth(), Some(&['\u{301}'][..])); + assert_eq!(target[Line(-1)][Column(1)].c, '中'); + assert_eq!( + target[Line(-1)][Column(0)].fg, + ansi::Color::Spec(crate::vte::ansi::Rgb { r: 12, g: 34, b: 56 }) + ); + assert!(value["rows"][0][0].get("extra").is_none()); + let mut invalid = value; + invalid["rows"][0][0]["hyperlink"] = serde_json::json!("https://example.invalid"); + assert!(serde_json::from_value::(invalid).is_err()); + } + + #[cfg(feature = "serde")] + #[test] + fn deserialization_rejects_invalid_dimensions_and_control_data() { + for value in [ + serde_json::json!({ "columns": 0, "rows": [[]] }), + serde_json::json!({ "columns": 4, "rows": [[]] }), + serde_json::json!({ "columns": 262145, "rows": [[]] }), + ] { + assert!(serde_json::from_value::(value).is_err()); + } + let snapshot = DisplaySnapshot { + columns: 1, + rows: vec![vec![Cell { c: '\u{1b}', ..Cell::default() }]], + }; + let value = serde_json::to_value(&snapshot).unwrap(); + assert!(serde_json::from_value::(value).is_err()); + } + + #[test] + fn rejects_malformed_rows_before_changing_live_grid() { + let mut target = Grid::::new(2, 4, 10); + target[Line(0)][Column(0)].c = 'x'; + let snapshot = DisplaySnapshot { columns: 4, rows: vec![vec![Cell::default(); 5]] }; + assert!(snapshot.restore_scrollback(&mut target).is_err()); + assert_eq!(target.history_size(), 0); + assert_eq!(target[Line(0)][Column(0)].c, 'x'); + } + + #[test] + fn rejects_actions_and_control_characters_before_restoring() { + let mut target = Grid::::new(2, 4, 10); + for cell in [Cell { c: '\u{1b}', ..Cell::default() }, { + let mut cell = Cell::default(); + cell.set_hyperlink(Some(crate::term::cell::Hyperlink::new( + None::, + "https://example.invalid".into(), + ))); + cell + }] { + let snapshot = DisplaySnapshot { columns: 4, rows: vec![vec![cell; 4]] }; + assert!(snapshot.restore_scrollback(&mut target).is_err()); + assert_eq!(target.history_size(), 0); + } + } + + #[test] + fn restores_parser_tab_cells_as_inert_display_data() { + let mut source = Term::new(Config::default(), &TermSize::new(12, 2), VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut source, b"a\tb"); + let snapshot = DisplaySnapshot::capture(source.grid(), Line(0)..Line(1), 12); + let mut target = Grid::::new(2, 12, 10); + snapshot.restore_scrollback(&mut target).unwrap(); + assert_eq!(target[Line(-1)][Column(0)].c, 'a'); + assert_eq!(target[Line(-1)][Column(8)].c, 'b'); + } + + #[test] + fn rejects_oversized_snapshot_before_allocating_history() { + let snapshot = DisplaySnapshot { columns: 1, rows: vec![vec![Cell::default()]; 262_145] }; + let mut target = Grid::::new(2, 4, 10); + assert!(snapshot.restore_scrollback(&mut target).is_err()); + assert_eq!(target.history_size(), 0); + } + + #[test] + fn capture_keeps_only_complete_tail_rows_within_budget() { + let mut source = Term::new(Config::default(), &TermSize::new(4, 3), VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut source, b"one\r\ntwo\r\nend"); + let snapshot = DisplaySnapshot::capture(source.grid(), Line(-100)..Line(100), 9); + let mut target = Grid::::new(2, 4, 10); + snapshot.restore_scrollback(&mut target).unwrap(); + assert_eq!(target.history_size(), 2); + assert_eq!(target[Line(-2)][Column(0)].c, 't'); + assert_eq!(target[Line(-1)][Column(0)].c, 'e'); + let empty = DisplaySnapshot::capture(source.grid(), Line(2)..Line(1), 9); + empty.restore_scrollback(&mut target).unwrap(); + assert_eq!(target.history_size(), 2); + } + + #[test] + fn restores_display_without_replaying_hyperlink_or_changing_live_screen() { + let mut source = Term::new(Config::default(), &TermSize::new(12, 3), VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance( + &mut source, + b"\x1b]8;;https://example.invalid\x1b\\\x1b[31mold\x1b]8;;\x1b\\\r\n", + ); + let snapshot = DisplaySnapshot::capture(source.grid(), Line(0)..Line(1), 100); + let mut target = Term::new(Config::default(), &TermSize::new(12, 3), VoidListener); + parser.advance(&mut target, b"new>"); + let cursor = target.grid().cursor.clone(); + snapshot.restore_scrollback(target.grid_mut()).unwrap(); + assert_eq!(target.grid().history_size(), 1); + assert_eq!(target.grid()[Line(-1)][Column(0)].c, 'o'); + assert_eq!( + target.grid()[Line(-1)][Column(0)].fg, + ansi::Color::Named(ansi::NamedColor::Red) + ); + assert!(target.grid()[Line(-1)][Column(0)].hyperlink().is_none()); + assert_eq!(target.grid()[Line(0)][Column(0)].c, 'n'); + assert_eq!(target.grid().cursor.point, cursor.point); + assert_eq!(target.grid().cursor.template, cursor.template); + } +} diff --git a/nebula_terminal/src/grid/snapshot/serialization.rs b/nebula_terminal/src/grid/snapshot/serialization.rs new file mode 100644 index 000000000..05039bbec --- /dev/null +++ b/nebula_terminal/src/grid/snapshot/serialization.rs @@ -0,0 +1,85 @@ +//! 持久化只暴露显示字段;不沿用 Cell 的链接及未来协议字段。 + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +use super::DisplaySnapshot; +use crate::term::cell::{Cell, Flags}; +use crate::vte::ansi::Color; + +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct DisplayCell { + c: char, + fg: Color, + bg: Color, + flags: Flags, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + combining: Vec, + #[serde(default, skip_serializing_if = "Option::is_none")] + underline: Option, +} + +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct WireSnapshot { + columns: usize, + rows: Vec>, +} + +impl Serialize for DisplaySnapshot { + fn serialize(&self, serializer: S) -> Result { + WireSnapshot { + columns: self.columns, + rows: self + .rows + .iter() + .map(|row| { + row.iter() + .map(|cell| DisplayCell { + c: cell.c, + fg: cell.fg, + bg: cell.bg, + flags: cell.flags, + combining: cell.zerowidth().unwrap_or_default().to_vec(), + underline: cell.underline_color(), + }) + .collect() + }) + .collect(), + } + .serialize(serializer) + } +} + +impl<'de> Deserialize<'de> for DisplaySnapshot { + fn deserialize>(deserializer: D) -> Result { + let wire = WireSnapshot::deserialize(deserializer)?; + let snapshot = Self { + columns: wire.columns, + rows: wire + .rows + .into_iter() + .map(|row| { + row.into_iter() + .map(|value| { + let mut cell = Cell { + c: value.c, + fg: value.fg, + bg: value.bg, + flags: value.flags, + extra: None, + }; + for character in value.combining { + cell.push_zerowidth(character); + } + cell.set_underline_color(value.underline); + cell + }) + .collect() + }) + .collect(), + }; + snapshot.validate().map_err(serde::de::Error::custom)?; + Ok(snapshot) + } +} diff --git a/nebula_terminal/src/term/renderable.rs b/nebula_terminal/src/term/renderable.rs index 30049ba37..6f4f1ad59 100644 --- a/nebula_terminal/src/term/renderable.rs +++ b/nebula_terminal/src/term/renderable.rs @@ -1,6 +1,6 @@ //! Read-only terminal viewport assembled for the renderer. -use crate::grid::{Dimensions, GridIterator}; +use crate::grid::{Dimensions, Grid, GridIterator}; use crate::index::{Line, Point}; use crate::selection::SelectionRange; use crate::term::cell::{Cell, Flags}; @@ -8,6 +8,13 @@ use crate::term::color::Colors; use crate::term::{Term, TermMode}; use crate::vte::ansi::CursorShape; +impl Term { + /// 主屏显示数据;备用屏活动时仍保留普通命令的输出,不包含 TUI 内容。 + pub fn primary_grid(&self) -> &Grid { + if self.mode.contains(TermMode::ALT_SCREEN) { &self.inactive_grid } else { &self.grid } + } +} + /// Terminal cursor rendering information. #[derive(Copy, Clone, PartialEq, Eq)] pub struct RenderableCursor { From aa93047371e78772b4f711e5641c11c698544d15 Mon Sep 17 00:00:00 2001 From: galact <94279960+galact-byte@users.noreply.github.com> Date: Mon, 21 Sep 2026 13:47:13 +0800 Subject: [PATCH 02/10] docs(recent-output): fix decision note validation and refresh evidence --- .../2026-09-21-bounded-local-output.md | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md b/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md index 9c69753fb..3169475de 100644 --- a/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md +++ b/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md @@ -1,8 +1,9 @@ -# 本机有界命令输出恢复(#160) +# 本机有界命令输出恢复 ## Status -已实现并完成本机 Windows CMD 验证,待提交审核;尚未发布。 +已实现并完成本机 Windows CMD 验证,已提交至贡献分支供上游审核。 +对应 Issue #160;此记录不表示已合入上游或正式发布。 ## Context @@ -54,13 +55,17 @@ terminal 层只导出、导入静态显示数据,去除链接动作,不回 ## Validation -本机全量应用回归 1890 通过、0 失败、15 忽略;terminal 包 283 个单元测试、 -48 个集成测试及 1 个文档测试通过;i18n 合同 20 通过、1 忽略。 -架构检查使用基线 `5ce18ba0c4c82f13548ea2dca94d2078e22e11eb`,没有扩大预算。 +合并上游基线 `07afade392919c49b846c3e59556b43aef79be35` 后,另加入独立的 +CLI 补全修复 `f66ae68` 做组合应用回归:1948 通过、0 失败、15 忽略。 +本功能分支不包含该补全修复;此结果不表示未修复基线补全问题的独立分支全绿。 +terminal 包复测 284 个单元测试、48 个集成测试及 1 个文档测试通过。 +合并后 GPUI 构建、同一上游基线的架构检查和格式检查通过,没有扩大预算。 +i18n 合同此前为 20 通过、1 忽略,未将其计作合并后的重新执行结果。 实际 GPUI 构建验证 CMD 保存、关窗、重复重启、最近五条、多 pane 不串档、 恢复期变窄、备用屏排除和活跃 Pi 原生会话身份保持。Pi 使用本机合成服务, 不是云端兼容性证明。两 pane 大输出测试恢复各自尾部;本机计时不是通用性能保证。 +合并后新构建再次验证 CMD 保存、关窗、连续两次重启,原命令和输出各保留一份。 此前单线程全量测试曾超时,默认并行全量通过;没有删除或新增忽略该测试。 ## Supersedes From ec9fba4ba6d786665fbaa3935be010b36f26b40a Mon Sep 17 00:00:00 2001 From: galact <94279960+galact-byte@users.noreply.github.com> Date: Mon, 21 Sep 2026 15:22:37 +0800 Subject: [PATCH 03/10] fix(terminal): confirm recent output submissions on all platforms --- .../gpui_shell/terminal/view/completion.rs | 3 +- .../terminal/view/recent_output_tests.rs | 107 ++++++++++++++++++ 2 files changed, 108 insertions(+), 2 deletions(-) diff --git a/nebula_app/src/gpui_shell/terminal/view/completion.rs b/nebula_app/src/gpui_shell/terminal/view/completion.rs index 986a91d38..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) { 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 index 7c6617da5..096cab93e 100644 --- a/nebula_app/src/gpui_shell/terminal/view/recent_output_tests.rs +++ b/nebula_app/src/gpui_shell/terminal/view/recent_output_tests.rs @@ -350,6 +350,113 @@ fn batch_restore_reads_exact_references_and_skips_changed_panes(cx: &mut TestApp 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); From 997e05fbcbfe8e247390f4939f2842c79c8c3334 Mon Sep 17 00:00:00 2001 From: galact <94279960+galact-byte@users.noreply.github.com> Date: Mon, 21 Sep 2026 15:44:36 +0800 Subject: [PATCH 04/10] fix(cli): sync Windows completions on output restore branch --- extra/completions/windows/_pebrel | 4 +++- extra/completions/windows/pebrel.bash | 10 +++++++++- extra/completions/windows/pebrel.fish | 2 ++ 3 files changed, 14 insertions(+), 2 deletions(-) diff --git a/extra/completions/windows/_pebrel b/extra/completions/windows/_pebrel index 6ae91d1e2..082fa2b22 100644 --- a/extra/completions/windows/_pebrel +++ b/extra/completions/windows/_pebrel @@ -1129,7 +1129,9 @@ _arguments "${_arguments_options[@]}" : \ ;; (setup-ai) _arguments "${_arguments_options[@]}" : \ -'--ssh=[Install or remove hooks on an SSH host (alias or user@host)]:DESTINATION:_default' \ +'(--wsl)--ssh=[Install or remove hooks on an SSH host (alias or user@host)]:DESTINATION:_default' \ +'--wsl=[Install or remove hooks in a WSL distribution'\''s own user configuration]:DISTRIBUTION:_default' \ +'--wsl-user=[WSL user; defaults to that distribution'\''s configured user]:USER:_default' \ '--remove[Remove Pebrel'\''s hooks from claude'\''s settings.json instead of installing them]' \ '-h[Print help]' \ '--help[Print help]' \ diff --git a/extra/completions/windows/pebrel.bash b/extra/completions/windows/pebrel.bash index 9f8c63f51..33b772210 100644 --- a/extra/completions/windows/pebrel.bash +++ b/extra/completions/windows/pebrel.bash @@ -3880,7 +3880,7 @@ _pebrel() { return 0 ;; pebrel__setup__ai) - opts="-h --remove --ssh --help" + opts="-h --remove --ssh --wsl --wsl-user --help" if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") ) return 0 @@ -3890,6 +3890,14 @@ _pebrel() { COMPREPLY=($(compgen -f "${cur}")) return 0 ;; + --wsl) + COMPREPLY=($(compgen -f "${cur}")) + return 0 + ;; + --wsl-user) + COMPREPLY=($(compgen -f "${cur}")) + return 0 + ;; *) COMPREPLY=() ;; diff --git a/extra/completions/windows/pebrel.fish b/extra/completions/windows/pebrel.fish index 7210a2be5..d1b4a4b76 100644 --- a/extra/completions/windows/pebrel.fish +++ b/extra/completions/windows/pebrel.fish @@ -519,6 +519,8 @@ complete -c pebrel -n "__fish_pebrel_using_subcommand config; and __fish_seen_su complete -c pebrel -n "__fish_pebrel_using_subcommand config; and __fish_seen_subcommand_from help" -f -a "help" -d 'Print this message or the help of the given subcommand(s)' complete -c pebrel -n "__fish_pebrel_using_subcommand notify-test" -s h -l help -d 'Print help' complete -c pebrel -n "__fish_pebrel_using_subcommand setup-ai" -l ssh -d 'Install or remove hooks on an SSH host (alias or user@host)' -r +complete -c pebrel -n "__fish_pebrel_using_subcommand setup-ai" -l wsl -d 'Install or remove hooks in a WSL distribution\'s own user configuration' -r +complete -c pebrel -n "__fish_pebrel_using_subcommand setup-ai" -l wsl-user -d 'WSL user; defaults to that distribution\'s configured user' -r complete -c pebrel -n "__fish_pebrel_using_subcommand setup-ai" -l remove -d 'Remove Pebrel\'s hooks from claude\'s settings.json instead of installing them' complete -c pebrel -n "__fish_pebrel_using_subcommand setup-ai" -s h -l help -d 'Print help' complete -c pebrel -n "__fish_pebrel_using_subcommand ssh" -s h -l help -d 'Print help' From ad812bb4ab9acce5581b6ad014ac8b6a69923759 Mon Sep 17 00:00:00 2001 From: galact <94279960+galact-byte@users.noreply.github.com> Date: Mon, 21 Sep 2026 23:12:58 +0800 Subject: [PATCH 05/10] test: fix Unix fixture collision and macOS path selection --- nebula_app/src/gpui_shell/workspace/details_panel_tests.rs | 5 +++-- nebula_app/src/platform/agent_integrations.rs | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/nebula_app/src/gpui_shell/workspace/details_panel_tests.rs b/nebula_app/src/gpui_shell/workspace/details_panel_tests.rs index c679fe2ad..279a5545e 100644 --- a/nebula_app/src/gpui_shell/workspace/details_panel_tests.rs +++ b/nebula_app/src/gpui_shell/workspace/details_panel_tests.rs @@ -70,7 +70,8 @@ fn file_path_edit_navigates_and_keeps_the_last_directory_on_error_or_escape( cx.update(|window, cx| window.draw(cx).clear(cx)); let path_button = cx.debug_bounds("file-tree-path").unwrap(); cx.simulate_click(path_button.center(), Modifiers::default()); - cx.simulate_keystrokes("ctrl-a"); + let select_all = if cfg!(target_os = "macos") { "cmd-a" } else { "ctrl-a" }; + cx.simulate_keystrokes(select_all); cx.simulate_input("中文 folder"); cx.simulate_keystrokes("enter"); cx.run_until_parked(); @@ -103,7 +104,7 @@ fn file_path_edit_navigates_and_keeps_the_last_directory_on_error_or_escape( cx.update(|window, cx| window.draw(cx).clear(cx)); let path_button = cx.debug_bounds("file-tree-path").unwrap(); cx.simulate_click(path_button.center(), Modifiers::default()); - cx.simulate_keystrokes("ctrl-a"); + cx.simulate_keystrokes(select_all); cx.simulate_input("missing-directory"); cx.simulate_keystrokes("enter"); cx.run_until_parked(); diff --git a/nebula_app/src/platform/agent_integrations.rs b/nebula_app/src/platform/agent_integrations.rs index 01d5f92a5..1105be065 100644 --- a/nebula_app/src/platform/agent_integrations.rs +++ b/nebula_app/src/platform/agent_integrations.rs @@ -189,7 +189,7 @@ mod tests { let dir = tempfile::tempdir().unwrap(); let grok_dir = dir.path().join(".grok/bin"); let grok = executable(&grok_dir, "agent"); - let cursor_dir = dir.path().join("cursor-agent/versions/current"); + let cursor_dir = dir.path().join("installations/cursor-agent/versions/current"); let cursor = executable(&cursor_dir, "agent"); let dirs = vec![grok_dir, cursor_dir]; assert_eq!(find_executable(AgentKind::Cursor, &dirs), Some(cursor)); From 49a69428c22de0c78cd31aaff4337c109e1ed747 Mon Sep 17 00:00:00 2001 From: galact <94279960+galact-byte@users.noreply.github.com> Date: Wed, 23 Sep 2026 14:22:42 +0800 Subject: [PATCH 06/10] test: initialize output refs in workspace recovery fixture --- nebula_app/src/gpui_shell/workspace/tests.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/nebula_app/src/gpui_shell/workspace/tests.rs b/nebula_app/src/gpui_shell/workspace/tests.rs index a9da3d88f..8178dc3b0 100644 --- a/nebula_app/src/gpui_shell/workspace/tests.rs +++ b/nebula_app/src/gpui_shell/workspace/tests.rs @@ -867,6 +867,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]); 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 07/10] 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 35fe05561c4b0929f359bb69a829710153e7cd97 Mon Sep 17 00:00:00 2001 From: galact <94279960+galact-byte@users.noreply.github.com> Date: Sat, 26 Sep 2026 23:42:51 +0800 Subject: [PATCH 08/10] feat: persist and restore recent output across window lifecycle --- .../2026-09-21-bounded-local-output.md | 82 +- nebula_app/i18n/en-US.json | 9 + nebula_app/i18n/zh-CN.json | 9 + nebula_app/src/gpui_shell/file_editor/mod.rs | 2 +- .../src/gpui_shell/file_editor/tests.rs | 11 + nebula_app/src/gpui_shell/settings_pane.rs | 9 +- .../settings_pane/command_output.rs | 69 ++ .../settings_pane/initialization.rs | 1 + .../gpui_shell/settings_pane/navigation.rs | 2 +- .../src/gpui_shell/settings_pane/tests.rs | 83 ++ nebula_app/src/gpui_shell/workspace.rs | 24 +- .../src/gpui_shell/workspace/closing.rs | 61 +- .../src/gpui_shell/workspace/documents.rs | 27 + .../src/gpui_shell/workspace/residency.rs | 152 ++-- .../gpui_shell/workspace/terminal_activity.rs | 15 +- .../src/gpui_shell/workspace/windowing.rs | 81 +- .../workspace/windowing/output_persistence.rs | 847 ++++++++++++++++++ .../workspace/windowing/shutdown.rs | 21 +- .../workspace/windowing/transfer_tests.rs | 4 +- 19 files changed, 1328 insertions(+), 181 deletions(-) create mode 100644 nebula_app/src/gpui_shell/settings_pane/command_output.rs create mode 100644 nebula_app/src/gpui_shell/workspace/windowing/output_persistence.rs diff --git a/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md b/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md index 4223b6b5d..3169475de 100644 --- a/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md +++ b/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md @@ -1,59 +1,72 @@ -# 静态输出快照与本机引用的持久化边界 +# 本机有界命令输出恢复 ## Status -供审核的持久化基础;尚未接入命令采集、设置控件或窗口输出恢复。 -关联 #160,本阶段不代表完整功能已交付。 +已实现并完成本机 Windows CMD 验证,已提交至贡献分支供上游审核。 +对应 Issue #160;此记录不表示已合入上游或正式发布。 ## Context -终端显示、输出文件和布局会话的生命周期不同。多个 pane 可以处于同一目录, -因此目录不能作为旧输出归属。直接回放原始 VT 会再次执行控制动作; -把输出及引用放进共享工作区格式,又会让导出携带本机历史。 +布局和 AI 原生身份恢复不包含终端显示内容。全局补全历史没有 pane 身份, +不能通过目录猜测旧输出归属。恢复内容必须是静态显示,不能重新执行历史命令。 ## Evidence -- [显示快照与校验](../../../../nebula_terminal/src/grid/snapshot.rs)覆盖主屏、Unicode 重排、容量和控制数据拒绝。 -- [有界输出存储](../../../../nebula_app/src/recent_output/storage.rs)复用原子文件写入。 -- [发布生命周期](../../../../nebula_app/src/recent_output/storage/lifecycle.rs)的回归测试覆盖两代交接、失败重试和发布回调内失效。 -- [本机会话引用](../../../../nebula_app/src/session/local_output.rs)验证引用只随自动恢复格式保存,损坏引用不破坏布局恢复。 +- `nebula_app/src/recent_output.rs`:命令记录、五条上限及输出尾部截取。 +- `nebula_app/src/recent_output/storage.rs` 与 `storage/lifecycle.rs`:容量、原子交接和清除。 +- `nebula_terminal/src/grid/snapshot.rs`:安全显示快照及 Unicode/重排测试。 +- `nebula_app/src/session/local_output.rs`:本机输出引用与会话导出边界。 +- `nebula_app/src/gpui_shell/workspace/windowing/output_persistence.rs`:异步保存生命周期。 ## Decision -terminal 层仅捕获和恢复主屏的静态显示字段,恢复到历史区,不重放 VT, -不改活终端屏幕或光标。反序列化与恢复先校验结构、容量和控制数据。 +terminal 层只导出、导入静态显示数据,去除链接动作,不回放 VT;app 层复用 +已确认的 shell 命令提交,每 pane 最多五条,每条编码不超过 256 KiB,保留命令 +与输出尾部。独立本机 sidecar 使用版本化格式和精确记录引用,不按 cwd 匹配。 -app 层以独立 sidecar 保存有界记录,每 pane 最多五条,每条最多 256 KiB。 -正常归档最多 16 MiB,两代原子交接最多 32 MiB;超量先裁剪旧记录再生成引用。 -精确引用只属于本机自动恢复文档,共享工作区的导入和导出不携带这些引用。 +正常快照总编码不超过 16 MiB,原子交接期间允许新旧两代临时合计最多 32 MiB, +各代仍单独限额。sidecar 写入成功后才发布会话引用,成功后回收旧代;崩溃重试 +保留已发布会话的有效引用,不累积第三代。总量超限先淘汰最旧记录再生成引用。 -先持久化输出,再发布会话引用,发布成功前保留旧引用可读取的那一代。 -发布失败恢复旧归档;成功后才能回收旧代。回调成功意味着会话已经落盘, -即使回调内代次失效,也必须报告真实的持久化结果并保留交接数据。 -后续接入者负责通过同一串行边界提交新的 checkpoint;无引用 checkpoint -不能等同清除全部旧历史,显式清除使用独立操作。 +读取前检查大小,读取时限流,解码后校验。损坏输出降级且不阻断有效新保存; +真实 I/O 失败保留失败和重试语义。保存与清除串行提交,代次失效阻止旧快照 +在清除后写回。关闭保存使在途旧快照失效;关闭 pane 的成功保存移除对应引用。 + +会话恢复开启时默认有界保存,提供关闭与清除入口;独立会话导出不携带本机 +输出引用或正文。旧会话无引用时沿用原恢复行为。文档在等待保存期间被编辑时, +关窗路径重新检查脏状态,包括 Runtime 关窗,不能因之前确认而丢弃新编辑。 ## Rejected alternatives -- 回放原始 VT:会重放控制动作,无法保证只恢复显示。 -- 按 cwd 匹配:同目录多 pane 无法确定归属。 -- 在共享会话中嵌入输出或本机引用:扩大导出范围和载入成本。 -- 发布引用前覆盖旧代:中断后旧会话可能引用已丢失的数据。 -- 发布成功后仅凭代次变化返回未提交:内存结果会与实际磁盘状态矛盾。 +- 保存、重放原始 VT:会重放控制动作,不是安全静态恢复。 +- 按目录分配全局历史:多个 pane 可有相同目录,无法证明归属。 +- 把全部输出嵌入可导出的 session:扩大隐私暴露和载入成本。 +- 不允许两代临时空间:有效旧快照会阻断正常原子替换。 +- 为恢复引入常驻线程或新依赖:现有异步执行和原子写机制足够。 ## Consequences -存储和终端边界可各自验证,后续采集及窗口接入复用同一规则。 -本阶段不会自动记录命令或恢复终端输出,也不新增用户设置。 -调用方须在后台执行磁盘操作,并承担持久化完成后的生命周期收尾。 +不恢复活进程,不重新执行命令,不恢复完整 AI 对话或 CMD 原生命令历史。 +不采集不可见密码输入、TUI 内部按键或 AI 会话文件,但无法自动识别所有已经 +显示在屏幕上的秘密。备用屏内容不作为普通历史导入。 + +活跃 AI 恢复时,静态旧输出和 AI 自身重绘可能同时留在终端历史中。 +禁用本功能可回退至原布局和 AI 恢复,不以回退脚本删除用户数据。 ## Validation -Windows 上实际运行:存储 24 项、会话相关 105 项、启动恢复 1 项通过; -`cargo test --locked -p nebula_terminal --features serde` 的 352 项通过, -包含使用现有打包资产执行的 ConPTY 生命周期测试。 -应用测试启用 `gpui-test-support`;仅关闭应用测试目标的调试符号,断言不变。 -这些结果验证本阶段边界,不作为尚未接入的窗口输出恢复验收。 +合并上游基线 `07afade392919c49b846c3e59556b43aef79be35` 后,另加入独立的 +CLI 补全修复 `f66ae68` 做组合应用回归:1948 通过、0 失败、15 忽略。 +本功能分支不包含该补全修复;此结果不表示未修复基线补全问题的独立分支全绿。 +terminal 包复测 284 个单元测试、48 个集成测试及 1 个文档测试通过。 +合并后 GPUI 构建、同一上游基线的架构检查和格式检查通过,没有扩大预算。 +i18n 合同此前为 20 通过、1 忽略,未将其计作合并后的重新执行结果。 + +实际 GPUI 构建验证 CMD 保存、关窗、重复重启、最近五条、多 pane 不串档、 +恢复期变窄、备用屏排除和活跃 Pi 原生会话身份保持。Pi 使用本机合成服务, +不是云端兼容性证明。两 pane 大输出测试恢复各自尾部;本机计时不是通用性能保证。 +合并后新构建再次验证 CMD 保存、关窗、连续两次重启,原命令和输出各保留一份。 +此前单线程全量测试曾超时,默认并行全量通过;没有删除或新增忽略该测试。 ## Supersedes @@ -61,4 +74,5 @@ None。 ## Revisit when -需要改变容量、引用身份、原子交接协议,或允许跨设备导出输出时重新审核。 +真实工具归属或有界成本不满足需求、需要改变采集范围,或需要跨设备导出输出时, +重新审核数据与隐私合同,不隐式扩大持久化。 diff --git a/nebula_app/i18n/en-US.json b/nebula_app/i18n/en-US.json index 4b9a99d35..2956242a8 100644 --- a/nebula_app/i18n/en-US.json +++ b/nebula_app/i18n/en-US.json @@ -13,6 +13,15 @@ "en_us": "English" }, "settings": { + "command_output": { + "save": "Remember recent command output", + "help": "With session restore enabled, keep up to five commands and their output per terminal on this device. Output may contain sensitive information; full-screen applications are not captured.", + "clear": "Clear saved command output", + "clear_help": "Remove saved output for all terminals on this device without clearing their screens. New commands are still saved while the option above is enabled.", + "clearing": "Clearing…", + "cleared": "Saved output cleared", + "clear_failed": "Clear failed — retry" + }, "scrolling": { "history": "Scrollback lines", "history_description": "History lines retained per terminal. Applies to new terminals only.", diff --git a/nebula_app/i18n/zh-CN.json b/nebula_app/i18n/zh-CN.json index a78fd32e2..27462c83e 100644 --- a/nebula_app/i18n/zh-CN.json +++ b/nebula_app/i18n/zh-CN.json @@ -13,6 +13,15 @@ "en_us": "English" }, "settings": { + "command_output": { + "save": "保存最近命令与输出", + "help": "开启会话恢复时,在本机为每个终端保留最近五条命令及输出。输出可能包含敏感信息;不采集全屏程序画面。", + "clear": "清除已保存的命令输出", + "clear_help": "移除本机所有终端已保存的输出,不清空当前屏幕。上方开关开启时,后续新命令仍会保存。", + "clearing": "正在清除…", + "cleared": "已清除保存的输出", + "clear_failed": "清除失败,点击重试" + }, "scrolling": { "history": "回滚行数", "history_description": "每个窗格保留的历史行数。仅适用于新窗格。", diff --git a/nebula_app/src/gpui_shell/file_editor/mod.rs b/nebula_app/src/gpui_shell/file_editor/mod.rs index c3e28afb7..71e3d8595 100644 --- a/nebula_app/src/gpui_shell/file_editor/mod.rs +++ b/nebula_app/src/gpui_shell/file_editor/mod.rs @@ -41,7 +41,7 @@ mod structure_inline_view; mod structure_tests; mod structure_view; #[cfg(all(test, feature = "gpui-test-support"))] -mod tests; +pub(in crate::gpui_shell) mod tests; use std::cell::RefCell; use std::path::PathBuf; diff --git a/nebula_app/src/gpui_shell/file_editor/tests.rs b/nebula_app/src/gpui_shell/file_editor/tests.rs index 9058ac7da..5e1e9668e 100644 --- a/nebula_app/src/gpui_shell/file_editor/tests.rs +++ b/nebula_app/src/gpui_shell/file_editor/tests.rs @@ -2,6 +2,17 @@ use super::*; use gpui::{TestAppContext, VisualTestContext}; use gpui_component::Root; +pub(in crate::gpui_shell) fn replace_draft( + file: &Entity, + text: &str, + window: &mut gpui::Window, + cx: &mut gpui::App, +) { + file.update(cx, |view, cx| { + view.input.update(cx, |input, cx| input.replace_all(text, window, cx)); + }); +} + pub(super) fn open( path: PathBuf, cx: &mut TestAppContext, diff --git a/nebula_app/src/gpui_shell/settings_pane.rs b/nebula_app/src/gpui_shell/settings_pane.rs index 6a7aa805e..cf5f5c4d0 100644 --- a/nebula_app/src/gpui_shell/settings_pane.rs +++ b/nebula_app/src/gpui_shell/settings_pane.rs @@ -44,6 +44,7 @@ mod appearance_picker; #[path = "background_color.rs"] mod background_color; mod backup; +mod command_output; mod design; mod font_picker; mod providers; @@ -215,6 +216,7 @@ pub struct SettingsPane { /// 备份密码(masked;只在导出/恢复动作瞬时读取,不落任何配置)。 backup_pass_input: Entity, backup_status: Option, + command_output_clear: command_output::ClearState, /// 导出/恢复/推送进行中(按钮禁用 + 忽略过期完成回调)。 backup_busy: bool, backup_seq: u64, @@ -380,7 +382,10 @@ impl SettingsPane { cx.notify(); return; } - if matches!(key, "ai_toasts" | "focus_follows_mouse" | "dim_inactive_panes") { + if matches!( + key, + "ai_toasts" | "focus_follows_mouse" | "dim_inactive_panes" | "save_command_output" + ) { if let Err(error) = self.try_persist(&[(key, (value as u8).to_string())], cx) { let language = crate::gpui_shell::config::ui_language(cx); super::toast::toast( @@ -750,6 +755,7 @@ impl SettingsPane { "fetch" => flag!(fetch), "keep_session" => flag!(keep_session), "restore_session" => flag!(restore_session), + "save_command_output" => flag!(save_command_output), "resume_ai" => flag!(resume_ai), "tray" => flag!(tray), "panel_resize" => flag!(panel_resize), @@ -1265,6 +1271,7 @@ impl SettingsPane { self.runtime.restore_session, cx, )) + .child(self.command_output_controls(cx)) .child(self.switch_row( "resume_ai", language.pick("恢复时接续 AI 对话", "Resume AI conversations"), diff --git a/nebula_app/src/gpui_shell/settings_pane/command_output.rs b/nebula_app/src/gpui_shell/settings_pane/command_output.rs new file mode 100644 index 000000000..11138c29d --- /dev/null +++ b/nebula_app/src/gpui_shell/settings_pane/command_output.rs @@ -0,0 +1,69 @@ +//! 本机命令输出沿用会话恢复设置区域;清除成功必须等磁盘操作完成。 +use super::*; +use crate::i18n::Message; + +#[derive(Default)] +pub(super) enum ClearState { + #[default] + Idle, + Busy, + Done, + Failed, +} + +impl SettingsPane { + pub(super) fn command_output_controls(&self, cx: &mut Context) -> impl IntoElement { + let language = crate::gpui_shell::config::ui_language(cx); + let label = match self.command_output_clear { + ClearState::Idle => Message::SettingsCommandOutputClear, + ClearState::Busy => Message::SettingsCommandOutputClearing, + ClearState::Done => Message::SettingsCommandOutputCleared, + ClearState::Failed => Message::SettingsCommandOutputClearFailed, + }; + let control = crate::gpui_shell::widgets::NebulaButton::new("clear-command-output") + .label(language.text(label)) + .disabled(matches!(self.command_output_clear, ClearState::Busy)) + .on_click(cx.listener(|this, _, _, cx| this.clear_command_output(cx))); + #[cfg(any(test, feature = "gpui-test-support"))] + let control = div().debug_selector(|| "clear-command-output".to_owned()).child(control); + div() + .child(self.switch_row( + "save_command_output", + language.text(Message::SettingsCommandOutputSave), + language.text(Message::SettingsCommandOutputHelp), + self.runtime.save_command_output, + cx, + )) + .child(self.row( + language.text(Message::SettingsCommandOutputClear), + language.text(Message::SettingsCommandOutputClearHelp), + control, + cx, + )) + } + + fn clear_command_output(&mut self, cx: &mut Context) { + if matches!(self.command_output_clear, ClearState::Busy) { + return; + } + self.command_output_clear = ClearState::Busy; + let clear = crate::gpui_shell::workspace::windowing::clear_command_output(cx); + cx.notify(); + cx.spawn(async move |this, cx| { + let result = clear.await; + let state = match result { + Ok(true) => ClearState::Done, + Ok(false) => ClearState::Failed, + Err(error) => { + log::warn!("Could not clear command output: {error}"); + ClearState::Failed + }, + }; + let _ = this.update(cx, |this, cx| { + this.command_output_clear = state; + cx.notify(); + }); + }) + .detach(); + } +} diff --git a/nebula_app/src/gpui_shell/settings_pane/initialization.rs b/nebula_app/src/gpui_shell/settings_pane/initialization.rs index 1ff1abe86..0e5c70061 100644 --- a/nebula_app/src/gpui_shell/settings_pane/initialization.rs +++ b/nebula_app/src/gpui_shell/settings_pane/initialization.rs @@ -657,6 +657,7 @@ impl SettingsPane { .placeholder(localized_input_placeholder("backup_password", language)) }), backup_status: None, + command_output_clear: super::command_output::ClearState::Idle, backup_busy: false, backup_seq: 0, backup_remote: { diff --git a/nebula_app/src/gpui_shell/settings_pane/navigation.rs b/nebula_app/src/gpui_shell/settings_pane/navigation.rs index fc4f81a97..807b915fe 100644 --- a/nebula_app/src/gpui_shell/settings_pane/navigation.rs +++ b/nebula_app/src/gpui_shell/settings_pane/navigation.rs @@ -35,7 +35,7 @@ pub(super) const SECTION_SEARCH_TERMS: [&str; 11] = [ "network 网络 proxy 代理 connectivity 连接", "interaction 交互 copy 复制 paste 粘贴 tab 标签 panel 面板 focus follows mouse 焦点跟随鼠标 自动聚焦", "keymap key binding shortcut quick terminal 快速终端 独立窗口 已有窗口 按键映射 快捷键", - "advanced 高级 session 会话 tray 托盘 restore 恢复 startup autostart login silent 自启动 静默启动 开机 登录", + "advanced 高级 session 会话 tray 托盘 restore 恢复 startup autostart login silent 自启动 静默启动 开机 登录 command output 命令输出 最近命令 清除输出", "backup cloud sync 云备份 云同步 云存储 备份 export 导出 restore 恢复 webdav s3 sftp 坚果云 123 123云盘 nextcloud synology 群晖 nas r2 minio snapshots 快照", "agents agent hook hooks 智能体 钩子 接入 claude codex opencode cursor kimi pi omp copilot grok", ]; diff --git a/nebula_app/src/gpui_shell/settings_pane/tests.rs b/nebula_app/src/gpui_shell/settings_pane/tests.rs index d88ae431b..01349bd81 100644 --- a/nebula_app/src/gpui_shell/settings_pane/tests.rs +++ b/nebula_app/src/gpui_shell/settings_pane/tests.rs @@ -125,6 +125,89 @@ fn ai_toast_setting_is_searchable_and_has_a_visible_switch(cx: &mut gpui::TestAp ); } +#[cfg(feature = "gpui-test-support")] +#[gpui::test] +fn command_output_controls_are_searchable_and_visible(cx: &mut gpui::TestAppContext) { + cx.update(|cx| { + gpui_component::init(cx); + cx.set_global(crate::gpui_shell::config::Settings::load(ThemeName::Nord)); + }); + let mut pane = None; + let (_, cx) = cx.add_window_view(|window, cx| { + let view = cx.new(|cx| SettingsPane::new(window, cx)); + pane = Some(view.clone()); + gpui_component::Root::new(view, window, cx) + }); + let pane = pane.unwrap(); + cx.simulate_resize(gpui::size(px(1280.0), px(1600.0))); + for query in ["命令输出", "command output"] { + cx.update(|window, cx| { + pane.update(cx, |pane, cx| { + pane.settings_search_input + .update(cx, |input, cx| input.replace_all(query, window, cx)); + }); + }); + cx.run_until_parked(); + cx.update(|window, cx| { + window.draw(cx).clear(cx); + }); + assert_eq!(pane.read_with(cx, |pane, _| pane.active_section), 8); + for id in ["nebula-switch-save_command_output", "clear-command-output"] { + let bounds = cx.debug_bounds(id).expect("command output control is rendered"); + assert!(bounds.size.width > px(0.0) && bounds.size.height > px(0.0)); + assert!(bounds.origin.y >= px(0.0) && bounds.bottom() <= px(1600.0)); + } + } +} + +#[cfg(feature = "gpui-test-support")] +#[gpui::test] +fn command_output_clear_click_reports_failure_and_allows_retry(cx: &mut gpui::TestAppContext) { + use crate::gpui_shell::workspace::windowing; + let directory = tempfile::tempdir().unwrap(); + let output = directory.path().join("output.json"); + // A directory at the file path makes removal fail without touching user data. + std::fs::create_dir(&output).unwrap(); + cx.update(|cx| { + gpui_component::init(cx); + cx.set_global(crate::gpui_shell::config::Settings::load(ThemeName::Nord)); + windowing::initialize(cx, crate::runtime_api::RuntimeHub::new()); + windowing::set_command_output_test_path(cx, output.clone()); + }); + let mut pane = None; + let (_, cx) = cx.add_window_view(|window, cx| { + let view = cx.new(|cx| SettingsPane::new(window, cx)); + view.update(cx, |pane, _| pane.active_section = 8); + pane = Some(view.clone()); + gpui_component::Root::new(view, window, cx) + }); + let pane = pane.unwrap(); + cx.simulate_resize(gpui::size(px(1280.0), px(1600.0))); + for retry in [false, true] { + if retry { + std::fs::remove_dir(&output).unwrap(); + std::fs::write(&output, b"synthetic output").unwrap(); + } + cx.update(|window, cx| { + window.draw(cx).clear(cx); + }); + let bounds = cx.debug_bounds("clear-command-output").unwrap(); + cx.simulate_mouse_down( + bounds.center(), + gpui::MouseButton::Left, + gpui::Modifiers::default(), + ); + cx.simulate_mouse_up(bounds.center(), gpui::MouseButton::Left, gpui::Modifiers::default()); + cx.run_until_parked(); + assert!(pane.read_with(cx, |pane, _| if retry { + matches!(pane.command_output_clear, command_output::ClearState::Done) + } else { + matches!(pane.command_output_clear, command_output::ClearState::Failed) + })); + assert_eq!(output.exists(), !retry); + } +} + #[test] fn settings_nav_visibility_keeps_stable_routes_and_hides_backup() { let visibility: Vec<_> = (0..SECTION_IDS.len()).map(is_nav_section_visible).collect(); diff --git a/nebula_app/src/gpui_shell/workspace.rs b/nebula_app/src/gpui_shell/workspace.rs index 71aec1ff6..d7e7b4f3a 100644 --- a/nebula_app/src/gpui_shell/workspace.rs +++ b/nebula_app/src/gpui_shell/workspace.rs @@ -1647,15 +1647,6 @@ impl NebulaWorkspace { (0..self.tabs.len()).find_map(|tab_ix| self.busy_process_in_tab(tab_ix, None, cx)) } - fn save_clean_window_session(&mut self, cx: &mut App) -> std::io::Result<()> { - windowing::save_current_window_session( - self.runtime_window_id, - self.snapshot_session(cx), - session_persistence::SaveReason::WindowClose, - cx, - ) - } - /// 聚焦另一个 pane(点击上报或方向导航落点)。 fn focus_pane( &mut self, @@ -1796,14 +1787,17 @@ impl NebulaWorkspace { self.active -= 1; } self.active = self.active.min(self.tabs.len().saturating_sub(1)); - if let Err(error) = windowing::save_current_window_session( - self.runtime_window_id, - self.snapshot_session(cx), + let save = windowing::output_persistence::save( + Some(self.snapshot_local_session(cx)), session_persistence::SaveReason::TabsClosed, cx, - ) { - log::warn!("Could not save closed tabs: {error}"); - } + ); + cx.spawn(async move |_, _| { + if !matches!(save.await, Ok(true)) { + log::warn!("Could not save closed tabs"); + } + }) + .detach(); self.reveal_active_tab(); self.focus_active(window, cx); self.sync_side_panel_to_active(true, cx); diff --git a/nebula_app/src/gpui_shell/workspace/closing.rs b/nebula_app/src/gpui_shell/workspace/closing.rs index 0e4571d8f..ca4a6c827 100644 --- a/nebula_app/src/gpui_shell/workspace/closing.rs +++ b/nebula_app/src/gpui_shell/workspace/closing.rs @@ -2,6 +2,17 @@ use super::*; use crate::i18n::Message; impl NebulaWorkspace { + pub(super) fn save_clean_window_session( + &mut self, + cx: &mut App, + ) -> gpui::Task> { + windowing::output_persistence::save( + Some(self.snapshot_local_session(cx)), + session_persistence::SaveReason::WindowClose, + cx, + ) + } + pub(super) fn request_close_pane( &mut self, tab_ix: usize, @@ -71,8 +82,8 @@ impl NebulaWorkspace { }); } - /// GPUI 的 should-close 回调必须同步返回:无繁忙进程时直接允许系统关闭; - /// 有繁忙进程时先返回 false,再由对话框确认回调显式移除窗口。 + /// GPUI 关闭回调必须同步返回;普通窗口先等待保存,繁忙窗口还须确认。 + /// 返回 false 后,由异步保存成功路径显式移除窗口。 pub(super) fn should_close_window( &mut self, window: &mut Window, @@ -157,16 +168,8 @@ impl NebulaWorkspace { fn finish_close_window(&mut self, _window: &mut Window, cx: &mut Context) { self.window_close_pending = true; + let documents = self.close_document_snapshot(cx); let panes = self.prepare_session_save(cx); - let approved_drafts: Vec<_> = self - .tabs - .iter() - .filter_map(|tab| tab.file_editor(cx)) - .map(|file| { - let draft = file.read(cx).draft(cx); - (file, draft) - }) - .collect(); let handle = self.window_handle; cx.spawn(async move |this, cx| { let ready = wait_for_session_ids(&panes, cx).await; @@ -177,16 +180,9 @@ impl NebulaWorkspace { }); return; } - let _ = handle.update(cx, |_, window, cx| { - let _ = this.update(cx, |workspace, cx| { - if workspace.tabs.iter().filter_map(|tab| tab.file_editor(cx)).any(|file| { - let view = file.read(cx); - view.is_saving() - || (view.is_dirty() - && !approved_drafts.iter().any(|(approved, draft)| { - approved == &file && *draft == view.draft(cx) - })) - }) { + let save = handle.update(cx, |_, window, cx| { + this.update(cx, |workspace, cx| { + if !workspace.close_documents_unchanged(&documents, cx) { workspace.window_close_pending = false; let language = crate::gpui_shell::config::ui_language(cx); crate::gpui_shell::toast::banner( @@ -196,9 +192,22 @@ impl NebulaWorkspace { language.text(crate::i18n::Message::UpdateDraftChanged), ); cx.notify(); - return; + return None; } - if workspace.save_clean_window_session(cx).is_err() { + Some(workspace.save_clean_window_session(cx)) + }) + }); + let Ok(Ok(Some(save))) = save else { return }; + let saved = match save.await { + Ok(saved) => saved, + Err(error) => { + log::warn!("Window close cancelled because session save failed: {error}"); + false + }, + }; + let _ = handle.update(cx, |_, window, cx| { + let _ = this.update(cx, |workspace, cx| { + if !saved { workspace.window_close_pending = false; let language = crate::gpui_shell::config::ui_language(cx); crate::gpui_shell::toast::banner( @@ -210,6 +219,12 @@ impl NebulaWorkspace { cx.notify(); return; } + workspace.window_close_pending = false; + if !workspace.close_documents_unchanged(&documents, cx) { + workspace.guard_file_window_close(window, cx); + cx.notify(); + return; + } window.remove_window(); }); }); diff --git a/nebula_app/src/gpui_shell/workspace/documents.rs b/nebula_app/src/gpui_shell/workspace/documents.rs index 131c7ee27..25b639624 100644 --- a/nebula_app/src/gpui_shell/workspace/documents.rs +++ b/nebula_app/src/gpui_shell/workspace/documents.rs @@ -15,6 +15,33 @@ impl WorkspaceTab { } impl NebulaWorkspace { + pub(super) fn close_document_snapshot( + &self, + cx: &App, + ) -> Vec<(Entity, SharedString)> { + self.tabs + .iter() + .filter_map(|tab| tab.file_editor(cx)) + .map(|file| { + let draft = file.read(cx).draft(cx); + (file, draft) + }) + .collect() + } + + pub(super) fn close_documents_unchanged( + &self, + approved: &[(Entity, SharedString)], + cx: &App, + ) -> bool { + self.tabs.iter().filter_map(|tab| tab.file_editor(cx)).all(|file| { + let view = file.read(cx); + !view.is_saving() + && (!view.is_dirty() + || approved.iter().any(|(old, draft)| *old == file && *draft == view.draft(cx))) + }) + } + pub(super) fn sync_document_activity(&self, window: &mut Window, cx: &mut Context) { for (index, tab) in self.tabs.iter().enumerate() { let Some(file) = tab.file_editor(cx) else { continue }; diff --git a/nebula_app/src/gpui_shell/workspace/residency.rs b/nebula_app/src/gpui_shell/workspace/residency.rs index 8b5f3fa26..2d1c437e7 100644 --- a/nebula_app/src/gpui_shell/workspace/residency.rs +++ b/nebula_app/src/gpui_shell/workspace/residency.rs @@ -161,11 +161,79 @@ impl NebulaWorkspace { fn drain_runtime_commands(&mut self, window: &mut Window, cx: &mut Context) { let pending = std::mem::take(&mut self.runtime_pending); for dispatch in pending { - let response = self.execute_runtime_command(&dispatch.command, window, cx); - dispatch.respond(response); + if let RuntimeCommand::CloseWindow { window_id } = &dispatch.command { + let close = self.runtime_close_window(*window_id, cx); + cx.spawn(async move |_, _| { + dispatch.respond(match close { + Ok(close) => close.await, + Err(error) => Err(error), + }); + }) + .detach(); + } else { + let response = self.execute_runtime_command(&dispatch.command, window, cx); + dispatch.respond(response); + } } } + pub(super) fn runtime_close_window( + &mut self, + window_id: Option, + cx: &mut Context, + ) -> Result>, ApiError> { + self.runtime_window_requested(window_id)?; + if self.window_close_pending { + return Err(ApiError::new("close_pending", "window close is already pending")); + } + if !self.close_documents_unchanged(&[], cx) { + return Err(ApiError::new( + "requires_confirmation", + "unsaved documents require confirmation in the GUI", + )); + } + if let Some(process) = self.busy_process_in_window(cx) { + return Err(runtime_close_confirmation( + process, + json!({ "target": "window", "window_id": self.runtime_window_id }), + )); + } + self.window_close_pending = true; + let panes = self.prepare_session_save(cx); + let handle = self.window_handle; + let id = self.runtime_window_id; + let tab_count = self.tabs.len(); + Ok(cx.spawn(async move |this, cx| { + let result = async { + if !super::closing::wait_for_session_ids(&panes, cx).await { + return Err(ApiError::new("session_identity_pending", "session identity is not ready")); + } + let save = this.update(cx, |workspace, cx| workspace.save_clean_window_session(cx)) + .map_err(|error| ApiError::new("target_not_found", error.to_string()))?; + match save.await { + Ok(true) => {}, + Ok(false) => return Err(ApiError::new("session_save_failed", "session save was superseded")), + Err(error) => return Err(ApiError::new("session_save_failed", error.to_string())), + } + let documents_safe = this.update(cx, |workspace, cx| { + workspace.close_documents_unchanged(&[], cx) + }).map_err(|error| ApiError::new("target_not_found", error.to_string()))?; + if !documents_safe { + return Err(ApiError::new("requires_confirmation", "documents changed while the window was saving")); + } + handle.update(cx, |_, window, cx| { + super::windowing::remove_saved_workspace_window(id, window, cx); + let snapshot = super::windowing::publish_runtime_snapshot(cx); + json!({ "action": { "window_id": id, "closed": true, "tabs_closed": tab_count }, "snapshot": snapshot }) + }).map_err(|error| ApiError::new("target_not_found", error.to_string())) + }.await; + if result.is_err() { + let _ = this.update(cx, |workspace, _| workspace.window_close_pending = false); + } + result + })) + } + pub(crate) fn execute_runtime_command( &mut self, command: &RuntimeCommand, @@ -181,39 +249,10 @@ impl NebulaWorkspace { "runtime_unavailable", "window.create is not queued in the GPUI runtime", )), - RuntimeCommand::CloseWindow { window_id } => { - self.runtime_window_requested(*window_id)?; - if let Some(process) = self.busy_process_in_window(cx) { - return Err(runtime_close_confirmation( - process, - json!({ "target": "window", "window_id": self.runtime_window_id }), - )); - } - let tab_count = self.tabs.len(); - if self.tabs.is_empty() { - super::windowing::close_empty_workspace_window( - self.runtime_window_id, - window, - cx, - ); - } else { - super::windowing::close_saved_workspace_window( - self.runtime_window_id, - self.snapshot_session(cx), - window, - cx, - ); - } - let snapshot = super::windowing::publish_runtime_snapshot(cx); - Ok(json!({ - "action": { - "window_id": self.runtime_window_id, - "closed": true, - "tabs_closed": tab_count - }, - "snapshot": snapshot - })) - }, + RuntimeCommand::CloseWindow { .. } => Err(ApiError::new( + "runtime_unavailable", + "window.close requires asynchronous session publication", + )), RuntimeCommand::Focus { window_id, pane_id } => { self.runtime_window_requested(*window_id)?; if let Some(pane_id) = pane_id { @@ -1026,24 +1065,35 @@ impl NebulaWorkspace { { return false; } - if let Err(error) = super::windowing::save_current_window_session( - self.runtime_window_id, - self.snapshot_session(cx), + self.window_close_pending = true; + let save = super::windowing::output_persistence::save( + Some(self.snapshot_local_session(cx)), super::session_persistence::SaveReason::Checkpoint, cx, - ) { - log::warn!("Could not checkpoint before hiding window: {error}"); - let language = crate::gpui_shell::config::ui_language(cx); - crate::gpui_shell::toast::banner( - window, - cx, - crate::display::ToastKind::Warning, - language.text(crate::i18n::Message::SessionSaveFailed), - ); - return true; - } - crate::gpui_shell::hide_native_window(window); - self.window_hidden = true; + ); + let handle = self.window_handle; + cx.spawn(async move |this, cx| { + let saved = matches!(save.await, Ok(true)); + let _ = handle.update(cx, |_, window, cx| { + let _ = this.update(cx, |workspace, cx| { + workspace.window_close_pending = false; + if saved { + crate::gpui_shell::hide_native_window(window); + workspace.window_hidden = true; + } else { + let language = crate::gpui_shell::config::ui_language(cx); + crate::gpui_shell::toast::banner( + window, + cx, + crate::display::ToastKind::Warning, + language.text(crate::i18n::Message::SessionSaveFailed), + ); + } + cx.notify(); + }); + }); + }) + .detach(); true } diff --git a/nebula_app/src/gpui_shell/workspace/terminal_activity.rs b/nebula_app/src/gpui_shell/workspace/terminal_activity.rs index 36af3592d..2009684a1 100644 --- a/nebula_app/src/gpui_shell/workspace/terminal_activity.rs +++ b/nebula_app/src/gpui_shell/workspace/terminal_activity.rs @@ -20,14 +20,17 @@ impl NebulaWorkspace { ) { match event { TerminalViewEvent::SessionIdentityChanged => { - if let Err(error) = windowing::save_current_window_session( - self.runtime_window_id, - self.snapshot_session(cx), + let save = windowing::output_persistence::save( + Some(self.snapshot_local_session(cx)), session_persistence::SaveReason::Checkpoint, cx, - ) { - log::warn!("Could not checkpoint native recovery identity: {error}"); - } + ); + cx.spawn(async move |_, _| { + if !matches!(save.await, Ok(true)) { + log::warn!("Could not checkpoint native recovery identity"); + } + }) + .detach(); }, // OSC 7 cwd 与标题共用这条事件。只有当前聚焦 pane 能驱动共享文件树; // 后台 pane 的提示符更新不能把前台目录覆盖掉。 diff --git a/nebula_app/src/gpui_shell/workspace/windowing.rs b/nebula_app/src/gpui_shell/workspace/windowing.rs index 8bf78b2df..269b3d31b 100644 --- a/nebula_app/src/gpui_shell/workspace/windowing.rs +++ b/nebula_app/src/gpui_shell/workspace/windowing.rs @@ -4,7 +4,11 @@ //! `NebulaWorkspace`。所有外部启动和 runtime 命令先在这里选择窗口,再把 //! 变更投递到对应 workspace,避免多个 receiver 竞争消费同一事件流。 +pub(super) mod output_persistence; mod shutdown; +pub(crate) use output_persistence::clear as clear_command_output; +#[cfg(all(test, feature = "gpui-test-support"))] +pub(crate) use output_persistence::set_command_output_test_path; pub(crate) use shutdown::{quit_all, quit_for_update}; #[cfg(windows)] @@ -137,6 +141,7 @@ pub(crate) struct WindowRegistry { entries: Vec, runtime_hub: crate::runtime_api::RuntimeHub, session_persistence: SessionPersistence, + output_persistence: output_persistence::OutputPersistence, quit_pending: bool, #[cfg(windows)] quick_terminal: Option, @@ -203,6 +208,7 @@ pub(crate) fn initialize(cx: &mut App, runtime_hub: crate::runtime_api::RuntimeH entries: Vec::new(), runtime_hub, session_persistence: SessionPersistence::default(), + output_persistence: output_persistence::OutputPersistence::default(), quit_pending: false, #[cfg(windows)] quick_terminal: None, @@ -214,19 +220,26 @@ pub(crate) fn initialize(cx: &mut App, runtime_hub: crate::runtime_api::RuntimeH let quit_subscription = cx.on_app_quit(|cx| { #[cfg(windows)] quick_window::persist_quick_size(cx); - if let Err(error) = save_combined_session(cx, true) { - log::warn!("Final session write: {error}"); + let save = output_persistence::save(None, SaveReason::Quit, cx); + async move { + if !matches!(save.await, Ok(true)) { + log::warn!("Final session write failed or was superseded"); + } } - async {} }); let closed_subscription = cx.on_window_closed(|cx, _window_id| { // A tab transfer can close its source while the destination workspace // is still borrowed. Snapshot all windows only after that update ends. cx.defer(save_after_window_closed); }); - cx.global_mut::() - ._subscriptions - .extend([quit_subscription, closed_subscription]); + let settings_subscription = cx.observe_global::(|cx| { + output_persistence::settings_changed(cx); + }); + cx.global_mut::()._subscriptions.extend([ + quit_subscription, + closed_subscription, + settings_subscription, + ]); cx.spawn(async move |cx| { loop { @@ -242,9 +255,7 @@ fn save_after_window_closed(cx: &mut App) { // 快速终端不能改变普通 session 的生命周期:最后一扇普通窗口关闭后, // 即使隐藏的 Quake 窗口仍存活,也不能再补写一份空的普通 session。 if cx.global::().entries.iter().any(|entry| entry.role == WindowRole::Regular) { - if let Err(error) = save_combined_session(cx, false) { - log::warn!("Session checkpoint: {error}"); - } + output_persistence::checkpoint(cx); } } @@ -1097,6 +1108,21 @@ fn dispatch_runtime(dispatch: Arc, cx: &mut App) { return; }, }; + if let RuntimeCommand::CloseWindow { window_id } = &dispatch.command { + let close = entry + .workspace + .update(cx, |workspace, cx| workspace.runtime_close_window(*window_id, cx)); + cx.spawn(async move |_| { + let response = match close { + Ok(Ok(close)) => close.await, + Ok(Err(error)) => Err(error), + Err(error) => Err(ApiError::new("target_not_found", error.to_string())), + }; + dispatch.respond(response); + }) + .detach(); + return; + } let command = dispatch.command.clone(); let workspace = entry.workspace.clone(); let result = entry.handle.update(cx, move |_, window, cx| { @@ -1377,10 +1403,10 @@ pub(crate) fn publish_runtime_snapshot_with_current( pub(crate) fn autosave_tick(cx: &mut App) { #[cfg(windows)] quick_window::persist_quick_size(cx); - if let Err(error) = save_combined_session(cx, false) { - log::warn!("Session checkpoint: {error}"); - return; - } + output_persistence::checkpoint(cx); +} + +fn acknowledge_session_restore(cx: &App) { let workspaces = cx .global::() .entries @@ -1432,27 +1458,6 @@ fn combined_session( combine_sessions(sessions) } -fn save_combined_session(cx: &mut App, clean: bool) -> std::io::Result<()> { - let session = combined_session(None, cx); - let reason = if clean { SaveReason::Quit } else { SaveReason::Checkpoint }; - cx.global_mut::().session_persistence.save(session, reason) -} - -pub(super) fn save_current_window_session( - runtime_window_id: u64, - session: crate::session::Session, - reason: SaveReason, - cx: &mut App, -) -> std::io::Result<()> { - if !cx.global::().entries.iter().any(|entry| { - entry.runtime_window_id == runtime_window_id && entry.role == WindowRole::Regular - }) { - return Ok(()); - } - let session = combined_session(Some((runtime_window_id, session)), cx); - cx.global_mut::().session_persistence.save(session, reason) -} - pub(crate) fn move_tab_to_new_window(payload: CrossWindowTabDrag, cx: &mut App) { let opened = open_workspace_window(cx, WorkspaceStartup::Empty, None, None, true, WindowRole::Regular); @@ -1518,17 +1523,11 @@ fn unregister(runtime_window_id: u64, cx: &mut App) { } } -pub(super) fn close_saved_workspace_window( +pub(super) fn remove_saved_workspace_window( runtime_window_id: u64, - session: crate::session::Session, window: &mut Window, cx: &mut App, ) { - if let Err(error) = - save_current_window_session(runtime_window_id, session, SaveReason::WindowClose, cx) - { - log::warn!("Could not checkpoint moved window: {error}"); - } unregister(runtime_window_id, cx); window.remove_window(); } diff --git a/nebula_app/src/gpui_shell/workspace/windowing/output_persistence.rs b/nebula_app/src/gpui_shell/workspace/windowing/output_persistence.rs new file mode 100644 index 000000000..280810ca2 --- /dev/null +++ b/nebula_app/src/gpui_shell/workspace/windowing/output_persistence.rs @@ -0,0 +1,847 @@ +//! 本机快照在 UI 线程采集;编码、sidecar 和会话提交交给后台执行器。 + +use super::super::session_persistence::{LocalSnapshot, prepare_windows}; +use super::*; +use crate::recent_output::storage::{Archive, OutputStore}; +use futures::{FutureExt, channel::oneshot, future::Shared}; +use std::io; + +pub(super) struct OutputPersistence { + store: OutputStore, + session_path: PathBuf, + tail: Option>>, + latest_archive: Option, + clear_epoch: u64, +} + +impl Default for OutputPersistence { + fn default() -> Self { + Self { + store: OutputStore::new(crate::recent_output::storage::archive_path()), + session_path: crate::session::session_path(), + tail: None, + latest_archive: None, + clear_epoch: 0, + } + } +} + +pub(super) fn settings_changed(cx: &mut App) { + if cx + .try_global::() + .is_none_or(|settings| settings.command_output_enabled) + { + return; + } + let registry = cx.global_mut::(); + registry.session_persistence.disable_output_references(); + let state = &mut registry.output_persistence; + state.clear_epoch += 1; + state.latest_archive = None; + // Cancel stale captures; the serialized checkpoint must also finish before quit. + state.store.next_generation(); + let snapshots = capture(None, cx); + let checkpoint = enqueue_with_mode(snapshots, SaveReason::Checkpoint, true, cx); + cx.spawn(async move |_| { + if let Err(error) = checkpoint.await { + log::warn!("Could not checkpoint disabled command output: {error}"); + } + }) + .detach(); +} + +fn capture(mut current: Option, cx: &App) -> Vec<(bool, LocalSnapshot)> { + let mut entries = cx + .global::() + .entries + .iter() + .filter(|entry| entry.role == WindowRole::Regular) + .cloned() + .collect::>(); + entries.sort_by_key(|entry| entry.runtime_window_id); + let active = cx + .active_window() + .filter(|handle| entries.iter().any(|entry| entry.handle == *handle)) + .or_else(|| { + entries.iter().max_by_key(|entry| entry.last_activated).map(|entry| entry.handle) + }); + entries + .into_iter() + .filter_map(|entry| { + let snapshot = if current + .as_ref() + .is_some_and(|snapshot| snapshot.window_id == entry.runtime_window_id) + { + current.take()? + } else { + entry.workspace.upgrade()?.read(cx).snapshot_local_session(cx) + }; + Some((active == Some(entry.handle), snapshot)) + }) + .collect() +} + +/// 按采集顺序串行提交,关窗/退出必须等待成功,不能把已入队当作已保存。 +pub(in crate::gpui_shell::workspace) fn save( + current: Option, + reason: SaveReason, + cx: &mut App, +) -> gpui::Task> { + let snapshots = capture(current, cx); + enqueue(snapshots, reason, cx) +} + +fn enqueue( + snapshots: Vec<(bool, LocalSnapshot)>, + reason: SaveReason, + cx: &mut App, +) -> gpui::Task> { + enqueue_with_mode(snapshots, reason, false, cx) +} + +fn enqueue_with_mode( + snapshots: Vec<(bool, LocalSnapshot)>, + reason: SaveReason, + without_output: bool, + cx: &mut App, +) -> gpui::Task> { + let epoch = cx.global::().output_persistence.clear_epoch; + let (done, receiver) = oneshot::channel(); + let previous = + cx.global_mut::().output_persistence.tail.replace(receiver.shared()); + cx.spawn(async move |cx| { + let result = async { + if let Some(previous) = previous { + let _ = previous.await; + } + let (mut session, mut archive) = + cx.background_executor().spawn(async move { prepare_windows(snapshots) }).await?; + let job = cx.update(|cx| { + let enabled = + cx.global::().command_output_enabled; + let registry = cx.global_mut::(); + // 清除前采集、清除后才完成编码的任务只能保存布局。 + let discard_output = + without_output || epoch != registry.output_persistence.clear_epoch || !enabled; + if discard_output { + if let Some(session) = &mut session { + for tab in &mut session.tabs { + tab.output_refs.clear(); + } + } + archive = Archive::new(Default::default()); + } + // 最后一扇窗口已关闭时,沿用同一份快照的输出,不用空档覆盖它。 + if session.as_ref().is_some_and(|session| !session.tabs.is_empty()) + || reason == SaveReason::TabsClosed + { + registry.output_persistence.latest_archive = Some(archive); + } + let pending = registry.session_persistence.prepare(session, reason)?; + let archive = registry + .output_persistence + .latest_archive + .clone() + .unwrap_or_else(|| Archive::new(Default::default())); + let store = registry.output_persistence.store.clone(); + let generation = store.next_generation(); + Some(( + pending, + archive, + store, + generation, + registry.output_persistence.session_path.clone(), + discard_output, + )) + }); + let Some((pending, archive, store, generation, path, without_output)) = job else { + return Ok(true); + }; + let (pending, result) = cx + .background_executor() + .spawn(async move { + let references = crate::session::load_local_from(&path) + .map(|session| { + session + .tabs + .into_iter() + .flat_map(|tab| tab.output_refs) + .collect::>() + }) + .unwrap_or_default(); + let result = if without_output { + store.publish_without_output(generation, || { + crate::session::save_local_to(&path, &pending.session) + }) + } else { + store.save_referenced(generation, &archive, Some(&references), || { + crate::session::save_local_to(&path, &pending.session) + }) + }; + (pending, result) + }) + .await; + if !result? { + return Ok(false); + } + Ok(cx.update(|cx| { + cx.global_mut::().session_persistence.complete(pending) + })) + } + .await; + let _ = done.send(()); + result + }) +} + +/// 清除作用于所有本机窗格,不清屏、不关终端;任务不依赖设置页存活。 +pub(crate) fn clear(cx: &mut App) -> gpui::Task> { + let views = cx + .global::() + .entries + .iter() + .filter_map(|entry| entry.workspace.upgrade()) + .flat_map(|workspace| { + workspace + .read(cx) + .tabs + .iter() + .flat_map(|tab| match tab { + WorkspaceTab::Terminal { panes, .. } => { + panes.iter().map(|pane| pane.view.clone()).collect() + }, + _ => Vec::new(), + }) + .collect::>() + }) + .collect::>(); + for view in views { + view.update(cx, |view, _| view.clear_recent_output()); + } + let registry = cx.global_mut::(); + registry.session_persistence.clear_output_references(); + let state = &mut registry.output_persistence; + state.clear_epoch += 1; + state.latest_archive = None; + state.store.next_generation(); + let store = state.store.clone(); + let (done, receiver) = oneshot::channel(); + let previous = state.tail.replace(receiver.shared()); + cx.spawn(async move |cx| { + if let Some(previous) = previous { + let _ = previous.await; + } + let result = cx + .background_executor() + .spawn(async move { store.clear(store.next_generation()) }) + .await; + let _ = done.send(()); + result + }) +} + +#[cfg(all(test, feature = "gpui-test-support"))] +pub(crate) fn set_command_output_test_path(cx: &mut App, path: PathBuf) { + let state = &mut cx.global_mut::().output_persistence; + state.session_path = path.with_file_name("session.json"); + state.store = OutputStore::new(path); +} + +#[cfg(all(test, feature = "gpui-test-support"))] +mod tests { + use super::*; + + #[gpui::test] + fn clear_invalidates_queued_output_and_does_not_erase_later_commands( + cx: &mut gpui::TestAppContext, + ) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let output = dir.path().join("output.json"); + let make_snapshot = |label: &str| { + use nebula_terminal::{ + event::VoidListener, + term::{Config, Term}, + vte::ansi, + }; + let mut term = Term::new( + Config::default(), + &crate::gpui_shell::terminal::session::GridSize { columns: 80, screen_lines: 24 }, + VoidListener, + ); + let mut parser: ansi::Processor = ansi::Processor::new(); + let mut recent = crate::recent_output::RecentOutput::default(); + parser.advance(&mut term, label.as_bytes()); + recent.begin(term.grid()); + parser.advance(&mut term, b"\r\nresult\r\n"); + recent.finish(term.grid()); + LocalSnapshot { + session: crate::session::Session::new( + 0, + vec![crate::session::TabSession::single("C:/test".into(), None, None)], + ), + outputs: vec![vec![(1, recent.snapshot(term.grid()))]], + window_id: 1, + } + }; + let (old, clearing) = cx.update(|cx| { + let mut settings = + crate::gpui_shell::config::Settings::load(nebula_settings::ThemeName::Nord); + settings.command_output_enabled = true; + cx.set_global(settings); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(output.clone()); + registry.output_persistence.session_path = dir.path().join("session.json"); + let old = enqueue(vec![(true, make_snapshot("old"))], SaveReason::Checkpoint, cx); + let clearing = clear(cx); + (old, clearing) + }); + cx.run_until_parked(); + let _ = old.now_or_never().expect("old save finishes"); + assert!(clearing.now_or_never().unwrap().unwrap()); + assert!(!output.exists(), "queued snapshots must not resurrect cleared output"); + let snapshot = make_snapshot("new"); + let expected = snapshot.outputs[0][0].1.clone(); + let new = cx.update(|cx| enqueue(vec![(true, snapshot)], SaveReason::Checkpoint, cx)); + cx.run_until_parked(); + assert!(new.now_or_never().unwrap().unwrap()); + let session: serde_json::Value = + serde_json::from_slice(&std::fs::read(dir.path().join("session.json")).unwrap()) + .unwrap(); + let reference = session["local_output_refs"][0][0].as_str().unwrap(); + let mut archive = Archive::read_from(&output).unwrap(); + let restored = archive.take_records(reference).expect("new command is published"); + assert_eq!( + serde_json::to_value(restored).unwrap(), + serde_json::to_value(expected).unwrap() + ); + } + + #[gpui::test] + fn runtime_close_waits_for_publication_and_reports_write_failure( + cx: &mut gpui::TestAppContext, + ) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let blocker = dir.path().join("not-a-directory"); + std::fs::write(&blocker, b"block").unwrap(); + let (handle, workspace, close) = cx.update(|cx| { + let (id, workspace) = super::super::transfer_tests::open_test_window(cx, 1); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(blocker.join("output.json")); + registry.output_persistence.session_path = dir.path().join("session.json"); + let handle = entry_by_id(id, cx).unwrap().handle; + let close = workspace + .update(cx, |workspace, cx| workspace.runtime_close_window(Some(id), cx)) + .unwrap(); + assert!(cx.windows().contains(&handle)); + (handle, workspace, close) + }); + cx.run_until_parked(); + let result = close.now_or_never().expect("close task must finish"); + assert_eq!(result.unwrap_err().code, "session_save_failed"); + cx.update(|cx| { + assert!(cx.windows().contains(&handle)); + assert!(!workspace.read(cx).window_close_pending); + cx.global_mut::().output_persistence.store = + OutputStore::new(dir.path().join("output.json")); + }); + let close = cx + .update(|cx| { + workspace.update(cx, |workspace, cx| workspace.runtime_close_window(None, cx)) + }) + .unwrap(); + cx.run_until_parked(); + let result = close.now_or_never().expect("close task must finish").unwrap(); + assert_eq!(result["action"]["closed"], true); + assert!(dir.path().join("output.json").is_file()); + assert!(dir.path().join("session.json").is_file()); + cx.update(|cx| assert!(!cx.windows().contains(&handle))); + } + + #[gpui::test] + fn application_quit_publishes_output_before_finishing(cx: &mut gpui::TestAppContext) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let output = dir.path().join("output.json"); + let session = dir.path().join("session.json"); + cx.update(|cx| { + super::super::transfer_tests::open_test_window(cx, 1); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(output.clone()); + registry.output_persistence.session_path = session.clone(); + super::super::shutdown::quit_all(cx); + assert!(!session.exists()); + }); + cx.run_until_parked(); + assert!(output.is_file(), "quit must save the output sidecar"); + let value: serde_json::Value = + serde_json::from_slice(&std::fs::read(session).unwrap()).unwrap(); + assert_eq!(value["tabs"].as_array().unwrap().len(), 1); + assert_eq!(value["clean_exit"], true); + } + + #[gpui::test] + fn application_quit_output_failure_is_retryable(cx: &mut gpui::TestAppContext) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let blocker = dir.path().join("not-a-directory"); + std::fs::write(&blocker, b"block").unwrap(); + cx.update(|cx| { + super::super::transfer_tests::open_test_window(cx, 1); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(blocker.join("output.json")); + registry.output_persistence.session_path = dir.path().join("session.json"); + super::super::shutdown::quit_all(cx); + }); + cx.run_until_parked(); + cx.update(|cx| { + assert!(!cx.global::().quit_pending, "failed save must cancel quit") + }); + assert!(!dir.path().join("session.json").exists()); + } + + #[gpui::test] + fn window_close_waits_for_output_and_session_publication(cx: &mut gpui::TestAppContext) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let output = dir.path().join("output.json"); + let session = dir.path().join("session.json"); + let handle = cx.update(|cx| { + let (id, workspace) = super::super::transfer_tests::open_test_window(cx, 1); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(output.clone()); + registry.output_persistence.session_path = session.clone(); + let handle = entry_by_id(id, cx).unwrap().handle; + handle + .update(cx, |_, window, cx| { + workspace.update(cx, |workspace, cx| { + assert!(!workspace.close_window_after_documents(window, cx)); + assert!(workspace.window_close_pending); + }) + }) + .unwrap(); + assert!(!session.exists()); + handle + }); + cx.run_until_parked(); + assert!(output.is_file(), "closing must publish the output sidecar"); + let value: serde_json::Value = + serde_json::from_slice(&std::fs::read(session).unwrap()).unwrap(); + assert_eq!(value["tabs"].as_array().unwrap().len(), 1); + assert_eq!(value["clean_exit"], true); + cx.update(|cx| assert!(!cx.windows().contains(&handle))); + } + + #[gpui::test] + fn window_close_preserves_document_edited_while_save_is_pending(cx: &mut gpui::TestAppContext) { + check_pending_close_draft(cx, false); + } + + #[gpui::test] + fn runtime_close_preserves_document_edited_while_save_is_pending( + cx: &mut gpui::TestAppContext, + ) { + check_pending_close_draft(cx, true); + } + + fn check_pending_close_draft(cx: &mut gpui::TestAppContext, runtime: bool) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let document = dir.path().join("draft.md"); + std::fs::write(&document, "original").unwrap(); + let (handle, workspace) = cx.update(|cx| { + let (id, workspace) = super::super::transfer_tests::open_test_window(cx, 1); + let handle = entry_by_id(id, cx).unwrap().handle; + handle + .update(cx, |_, window, cx| { + workspace.update(cx, |workspace, cx| { + workspace.open_document_at_startup(document.clone(), window, cx); + }); + }) + .unwrap(); + (handle, workspace) + }); + cx.run_until_parked(); + let (release, waiting) = oneshot::channel(); + cx.update(|cx| { + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(dir.path().join("output.json")); + registry.output_persistence.session_path = dir.path().join("session.json"); + registry.output_persistence.tail = Some(waiting.shared()); + handle + .update(cx, |_, window, cx| { + workspace.update(cx, |workspace, cx| { + if runtime { + workspace.runtime_close_window(None, cx).unwrap().detach(); + } else { + assert!(!workspace.should_close_window(window, cx)); + } + assert!(workspace.window_close_pending); + }); + }) + .unwrap(); + }); + cx.run_until_parked(); + let file = cx.update(|cx| { + let file = workspace.read(cx).tabs.iter().find_map(|tab| tab.file_editor(cx)).unwrap(); + handle + .update(cx, |_, window, cx| { + crate::gpui_shell::file_editor::tests::replace_draft( + &file, + "new unsaved draft", + window, + cx, + ); + }) + .unwrap(); + file + }); + cx.run_until_parked(); + cx.update(|cx| assert!(file.read(cx).is_dirty())); + release.send(()).unwrap(); + cx.run_until_parked(); + cx.update(|cx| { + assert!( + cx.windows().contains(&handle), + "new draft must prevent asynchronous window destruction" + ); + assert!(!workspace.read(cx).window_close_pending); + assert_eq!(file.read(cx).draft(cx).as_ref(), "new unsaved draft"); + }); + assert_eq!(std::fs::read_to_string(document).unwrap(), "original"); + } + + #[gpui::test] + fn disabling_output_queues_durable_reference_free_session_without_erasing_old_history( + cx: &mut gpui::TestAppContext, + ) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let output = dir.path().join("output.json"); + let session_path = dir.path().join("session.json"); + let mut old_session = crate::session::Session::new( + 0, + vec![crate::session::TabSession::single("C:/test".into(), None, None)], + ); + old_session.tabs[0].output_refs = vec!["old".into()]; + use nebula_terminal::{ + event::VoidListener, + term::{Config, Term}, + vte::ansi, + }; + let mut term = Term::new( + Config::default(), + &crate::gpui_shell::terminal::session::GridSize { columns: 80, screen_lines: 24 }, + VoidListener, + ); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut term, b"C:>old"); + let mut recent = crate::recent_output::RecentOutput::default(); + recent.begin(term.grid()); + parser.advance(&mut term, b"\r\nold output\r\n"); + recent.finish(term.grid()); + let old_archive = Archive::new(std::collections::BTreeMap::from([( + "old".into(), + recent.snapshot(term.grid()), + )])); + old_archive.write_to(&output).unwrap(); + crate::session::save_local_to(&session_path, &old_session).unwrap(); + let (release, waiting) = oneshot::channel(); + let queued = cx.update(|cx| { + let mut settings = + crate::gpui_shell::config::Settings::load(nebula_settings::ThemeName::Nord); + settings.command_output_enabled = true; + cx.set_global(settings); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(output.clone()); + registry.output_persistence.session_path = session_path.clone(); + registry.output_persistence.tail = Some(waiting.shared()); + enqueue( + vec![( + true, + LocalSnapshot { + session: old_session.clone(), + outputs: vec![vec![(1, Vec::new())]], + window_id: 1, + }, + )], + SaveReason::Checkpoint, + cx, + ) + }); + cx.run_until_parked(); + cx.update(|cx| { + cx.global_mut::().command_output_enabled = false; + }); + cx.run_until_parked(); + release.send(()).unwrap(); + cx.run_until_parked(); + assert!(queued.now_or_never().is_some()); + assert!( + cx.update(|cx| cx + .global::() + .session_persistence + .update_windows() + .is_ok()), + "disabling must finish its durable checkpoint before acknowledging the session" + ); + assert!( + crate::session::load_local_from(&session_path) + .unwrap() + .tabs + .iter() + .all(|tab| tab.output_refs.is_empty()) + ); + let mut after = Archive::read_from(&output).unwrap(); + assert!(after.take_records("old").is_some(), "the toggle must preserve old history"); + } + + #[gpui::test] + fn disabling_during_publication_serializes_reference_free_checkpoint( + cx: &mut gpui::TestAppContext, + ) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let output = dir.path().join("output.json"); + let session_path = dir.path().join("session.json"); + let mut old = crate::session::Session::new( + 0, + vec![crate::session::TabSession::single("C:/test".into(), None, None)], + ); + old.tabs[0].output_refs = vec!["old".into()]; + let mut new = old.clone(); + new.tabs[0].output_refs = vec!["new".into()]; + use nebula_terminal::{ + event::VoidListener, + term::{Config, Term}, + vte::ansi, + }; + let mut term = Term::new( + Config::default(), + &crate::gpui_shell::terminal::session::GridSize { columns: 80, screen_lines: 24 }, + VoidListener, + ); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut term, b"C:>old"); + let mut recent = crate::recent_output::RecentOutput::default(); + recent.begin(term.grid()); + parser.advance(&mut term, b"\r\nold output\r\n"); + recent.finish(term.grid()); + let records = recent.snapshot(term.grid()); + Archive::new(std::collections::BTreeMap::from([("old".into(), records.clone())])) + .write_to(&output) + .unwrap(); + crate::session::save_local_to(&session_path, &old).unwrap(); + let store = OutputStore::new(output.clone()); + let generation = store.next_generation(); + cx.update(|cx| { + let mut settings = + crate::gpui_shell::config::Settings::load(nebula_settings::ThemeName::Nord); + settings.command_output_enabled = true; + cx.set_global(settings); + let registry = cx.global_mut::(); + let state = &mut registry.session_persistence; + *state = super::super::super::session_persistence::tests::ordinary_window(); + let pending = state.prepare(Some(old.clone()), SaveReason::Checkpoint).unwrap(); + assert!(state.complete(pending)); + registry.output_persistence.store = store.clone(); + registry.output_persistence.session_path = session_path.clone(); + }); + let (entered, started) = std::sync::mpsc::channel(); + let (release, resume) = std::sync::mpsc::channel(); + let publishing = std::thread::spawn({ + let store = store.clone(); + let session_path = session_path.clone(); + move || { + let archive = + Archive::new(std::collections::BTreeMap::from([("new".into(), records)])); + store.save_referenced(generation, &archive, Some(&["old".into()]), || { + entered.send(()).unwrap(); + resume.recv().unwrap(); + crate::session::save_local_to(&session_path, &new) + }) + } + }); + started.recv_timeout(std::time::Duration::from_secs(5)).unwrap(); + cx.update(|cx| { + cx.global_mut::().command_output_enabled = false; + }); + assert!(cx.update(|cx| { + cx.global::().session_persistence.update_windows().is_err() + })); + assert_eq!( + crate::session::load_local_from(&session_path).unwrap().tabs[0].output_refs, + ["old"], + "the checkpoint must wait behind in-flight publication" + ); + release.send(()).unwrap(); + assert!(publishing.join().unwrap().unwrap()); + cx.run_until_parked(); + assert!(cx.update(|cx| { + cx.global::().session_persistence.update_windows().is_ok() + })); + let restored = crate::session::load_local_from(&session_path).unwrap(); + assert!(restored.tabs[0].output_refs.is_empty()); + let mut remaining = Archive::read_from(&output).unwrap(); + assert!(remaining.take_records("old").is_some(), "existing valid history is not clear"); + } + + #[gpui::test] + fn disabling_then_enabling_output_invalidates_queued_snapshot(cx: &mut gpui::TestAppContext) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let output = dir.path().join("output.json"); + let session = dir.path().join("session.json"); + let (release, waiting) = oneshot::channel(); + let save = cx.update(|cx| { + use nebula_terminal::{ + event::VoidListener, + term::{Config, Term}, + vte::ansi, + }; + let mut term = Term::new( + Config::default(), + &crate::gpui_shell::terminal::session::GridSize { columns: 80, screen_lines: 24 }, + VoidListener, + ); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut term, b"old command"); + let mut recent = crate::recent_output::RecentOutput::default(); + recent.begin(term.grid()); + parser.advance(&mut term, b"\r\nold output\r\n"); + recent.finish(term.grid()); + let mut settings = + crate::gpui_shell::config::Settings::load(nebula_settings::ThemeName::Nord); + settings.command_output_enabled = true; + cx.set_global(settings); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(output.clone()); + registry.output_persistence.session_path = session.clone(); + registry.output_persistence.tail = Some(waiting.shared()); + enqueue( + vec![( + true, + LocalSnapshot { + session: crate::session::Session::new( + 0, + vec![crate::session::TabSession::single("C:/test".into(), None, None)], + ), + outputs: vec![vec![(1, recent.snapshot(term.grid()))]], + window_id: 1, + }, + )], + SaveReason::Checkpoint, + cx, + ) + }); + cx.run_until_parked(); + cx.update(|cx| { + cx.global_mut::().command_output_enabled = false + }); + cx.run_until_parked(); + cx.update(|cx| { + cx.global_mut::().command_output_enabled = true + }); + cx.run_until_parked(); + release.send(()).unwrap(); + cx.run_until_parked(); + assert!(save.now_or_never().unwrap().unwrap()); + let restored = crate::session::load_local_from(&session).unwrap(); + assert!( + restored.tabs.iter().all(|tab| tab.output_refs.is_empty()), + "re-enabling must not publish pre-disable snapshots" + ); + } + + #[gpui::test] + fn failed_output_write_keeps_window_open_for_retry(cx: &mut gpui::TestAppContext) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let blocker = dir.path().join("not-a-directory"); + std::fs::write(&blocker, b"block").unwrap(); + let session = dir.path().join("session.json"); + let (handle, workspace) = cx.update(|cx| { + let (id, workspace) = super::super::transfer_tests::open_test_window(cx, 1); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(blocker.join("output.json")); + registry.output_persistence.session_path = session.clone(); + let handle = entry_by_id(id, cx).unwrap().handle; + handle + .update(cx, |_, window, cx| { + workspace.update(cx, |workspace, cx| { + assert!(!workspace.close_window_after_documents(window, cx)); + }) + }) + .unwrap(); + (handle, workspace) + }); + cx.run_until_parked(); + cx.update(|cx| { + assert!( + cx.windows().contains(&handle), + "a failed save must not destroy the live terminal" + ); + assert!(!workspace.read(cx).window_close_pending, "close must be retryable"); + }); + assert!(!session.exists(), "failed sidecar must not publish new session references"); + } + + #[gpui::test] + fn autosave_tick_publishes_through_background_output_store(cx: &mut gpui::TestAppContext) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let output = dir.path().join("output.json"); + let session = dir.path().join("session.json"); + cx.update(|cx| { + super::super::transfer_tests::open_test_window(cx, 1); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(output.clone()); + registry.output_persistence.session_path = session.clone(); + autosave_tick(cx); + assert!(!session.exists(), "autosave must not perform disk I/O in the UI callback"); + }); + cx.run_until_parked(); + assert!(output.is_file(), "autosave must write sidecar before session publication"); + let value: serde_json::Value = + serde_json::from_slice(&std::fs::read(session).unwrap()).unwrap(); + assert_eq!(value["tabs"].as_array().unwrap().len(), 1); + assert_eq!(value["clean_exit"], false); + } +} + +pub(super) fn checkpoint(cx: &mut App) { + let registry = cx.global::(); + if registry.quit_pending + || registry.output_persistence.tail.as_ref().is_some_and(|tail| tail.peek().is_none()) + { + return; + } + let save = save(None, SaveReason::Checkpoint, cx); + cx.spawn(async move |cx| match save.await { + Ok(true) => cx.update(|cx| super::acknowledge_session_restore(cx)), + Ok(false) => {}, + Err(error) => log::warn!("Could not checkpoint command output and session: {error}"), + }) + .detach(); +} diff --git a/nebula_app/src/gpui_shell/workspace/windowing/shutdown.rs b/nebula_app/src/gpui_shell/workspace/windowing/shutdown.rs index ca6867764..60e66438a 100644 --- a/nebula_app/src/gpui_shell/workspace/windowing/shutdown.rs +++ b/nebula_app/src/gpui_shell/workspace/windowing/shutdown.rs @@ -70,7 +70,7 @@ fn request_quit(update: Option, cx: &mut App) } else { None }; - cx.update(|cx| { + let save = cx.update(|cx| { // Recheck the current pane set after asynchronous preparation. A // window/pane opened during the handshake also needs a native target. let identities_ready = cx @@ -88,15 +88,24 @@ fn request_quit(update: Option, cx: &mut App) }); if !identities_ready && !incomplete_approved { abort_quit(Message::SessionIdentityPending, cx); - return; + return None; } if !documents_unchanged(&approved, cx) { abort_quit(Message::UpdateDraftChanged, cx); - return; + return None; } - if let Err(error) = save_combined_session(cx, true) { - log::warn!("Shutdown cancelled because session save failed: {error}"); - abort_quit(Message::SessionSaveFailed, cx); + Some(output_persistence::save(None, SaveReason::Quit, cx)) + }); + let Some(save) = save else { return }; + if !matches!(save.await, Ok(true)) { + cx.update(|cx| abort_quit(Message::SessionSaveFailed, cx)); + return; + } + cx.update(|cx| { + // A document can change while the output is being written. + if !documents_unchanged(&approved, cx) { + cx.global_mut::().session_persistence.cancel_quit(); + abort_quit(Message::UpdateDraftChanged, cx); return; } if let Some(prepared) = prepared.as_mut() { diff --git a/nebula_app/src/gpui_shell/workspace/windowing/transfer_tests.rs b/nebula_app/src/gpui_shell/workspace/windowing/transfer_tests.rs index 220c87da3..ba86382f3 100644 --- a/nebula_app/src/gpui_shell/workspace/windowing/transfer_tests.rs +++ b/nebula_app/src/gpui_shell/workspace/windowing/transfer_tests.rs @@ -2,7 +2,7 @@ use super::*; use crate::gpui_shell::terminal::view::TerminalLaunch; use gpui::TestAppContext; -fn initialize_test(cx: &mut TestAppContext) { +pub(super) fn initialize_test(cx: &mut TestAppContext) { cx.update(|cx| { gpui_component::init(cx); crate::gpui_shell::math_view::register(cx); @@ -12,7 +12,7 @@ fn initialize_test(cx: &mut TestAppContext) { }); } -fn open_test_window(cx: &mut App, count: usize) -> (u64, Entity) { +pub(super) fn open_test_window(cx: &mut App, count: usize) -> (u64, Entity) { let (id, workspace) = open_workspace_window(cx, WorkspaceStartup::Empty, None, None, false, WindowRole::Regular) .unwrap(); From 5917c5f9c5c58d09da6cb8dddc8699546fdb9412 Mon Sep 17 00:00:00 2001 From: galact <94279960+galact-byte@users.noreply.github.com> Date: Sun, 27 Sep 2026 00:57:29 +0800 Subject: [PATCH 09/10] ci: rerun checks for recent output foundation From 2f9ae61982d977acc5c9d7fd9e8e36203459e436 Mon Sep 17 00:00:00 2001 From: galact <94279960+galact-byte@users.noreply.github.com> Date: Mon, 28 Sep 2026 16:18:33 +0800 Subject: [PATCH 10/10] fix: bound snapshot decoding and sanitize orphan wide-char flags Count rows, cells and per-cell combining characters while decoding and stop as soon as a budget is exceeded; charge the shared combining budget per cell. Capture and import share one wide-char flag normalization so an orphan leading spacer can no longer reach text extraction. Add a barrier test showing a clear queued during publication runs after it and keeps the output cleared. Local session references and primary-screen capture move to the pane-capture stage that uses them. --- .../2026-09-21-bounded-local-output.md | 4 +- ...09-28-bounded-display-snapshot-decoding.md | 59 ++++++++++ .../gpui_shell/workspace/session_recovery.rs | 1 - nebula_app/src/gpui_shell/workspace/tests.rs | 1 - .../src/recent_output/storage/lifecycle.rs | 54 +++++----- nebula_app/src/session.rs | 32 ++---- nebula_app/src/session/local_output.rs | 97 ----------------- .../src/window_context/session_snapshot.rs | 1 - nebula_terminal/src/grid/snapshot.rs | 102 ++++++++++++++---- .../src/grid/snapshot/serialization.rs | 96 ++++++++++++++++- nebula_terminal/src/term/renderable.rs | 9 +- 11 files changed, 274 insertions(+), 182 deletions(-) create mode 100644 architecture/notes/nebula_terminal/grid/2026-09-28-bounded-display-snapshot-decoding.md delete mode 100644 nebula_app/src/session/local_output.rs diff --git a/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md b/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md index 4223b6b5d..3b562ebb5 100644 --- a/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md +++ b/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md @@ -13,10 +13,10 @@ ## Evidence -- [显示快照与校验](../../../../nebula_terminal/src/grid/snapshot.rs)覆盖主屏、Unicode 重排、容量和控制数据拒绝。 +- [显示快照与校验](../../../../nebula_terminal/src/grid/snapshot.rs)覆盖 Unicode 重排、容量和控制数据拒绝;备用屏活动时读取主屏由第二项随采集接入。 - [有界输出存储](../../../../nebula_app/src/recent_output/storage.rs)复用原子文件写入。 - [发布生命周期](../../../../nebula_app/src/recent_output/storage/lifecycle.rs)的回归测试覆盖两代交接、失败重试和发布回调内失效。 -- [本机会话引用](../../../../nebula_app/src/session/local_output.rs)验证引用只随自动恢复格式保存,损坏引用不破坏布局恢复。 +- 本机会话引用(`session/local_output.rs`)随第二项的逐 pane 采集交付;本项存储测试以普通文件代替会话,只验证发布回调的提交语义。 ## Decision diff --git a/architecture/notes/nebula_terminal/grid/2026-09-28-bounded-display-snapshot-decoding.md b/architecture/notes/nebula_terminal/grid/2026-09-28-bounded-display-snapshot-decoding.md new file mode 100644 index 000000000..720e37f79 --- /dev/null +++ b/architecture/notes/nebula_terminal/grid/2026-09-28-bounded-display-snapshot-decoding.md @@ -0,0 +1,59 @@ +# 显示快照的有界解码与宽字符边界 + +## Status + +#235 的候选审计修正,待审核。沿用现有 JSON 字段,不改变后台发布协议。 + +## Context + +编码文件的字节限额不能代替解码对象限额。先反序列化嵌套 Vec 再 validate, +会在拒绝输入前分配大量空行、单元格或组合字符。宽字符占位参与文本提取和 +重排;行首孤立占位会使文本提取回退到负列。另一方面,终端删除半个宽字符 +后的重排可能留下孤立标志,严格拒绝会让正常编辑后的输出无法恢复。 + +## Evidence + +- [解码器](../../../../nebula_terminal/src/grid/snapshot/serialization.rs)原先先生成完整 WireSnapshot。 +- [快照回归测试](../../../../nebula_terminal/src/grid/snapshot.rs)用超限有效元素后接畸形尾部,证明解码必须先因预算失败;包括跨单元格累计组合字符。 +- 同处真实解析器测试覆盖中文、组合字符以及删除、插入、擦除后三种列宽的重排。 + +## Decision + +通过 serde DeserializeSeed 按行读取,每读入一个单元格即扣减预算。不信任 +size_hint,不按输入提示预分配。行、单元格与单格组合字符在读取中计数,累计组合 +字符在每个单元格读完后扣减;各项均不超过 262_144。后续 validate 仍检查尺寸和 +控制数据。保留 JSON 对象字段顺序无关的合同。 + +捕获与导入共用同一规范化:清除互斥宽字符标志、未配对的宽字符/占位以及错误位置 +的跨行前导占位,保留字符、颜色、组合字符和其他标志;末行跨行占位可以没有下一行。 +倒序处理确保前导占位看到已规范化的下一行。行首孤立占位因此不会进入文本提取; +活终端不变。 + +## Rejected alternatives + +- 只在整个 Vec 建成后校验:拒绝太晚,不能限制解码期间分配。 +- 每个单元格单独限制组合字符:无法限制所有单元格的累计量。 +- 导入严格拒绝畸形宽字符标志:需与捕获分设两套规则,且一个无效标志即丢弃整段输出。 +- 依赖 columns 已先读取:会破坏已有 JSON 字段顺序无关的格式。 +- 所有跨行占位必须有下一行:误拒绝合法的有界裁剪。 +- 直接修活网格:改变正常终端编辑行为。 + +## Consequences + +资源与结构校验属于 terminal 快照边界,不增加应用依赖、数据迁移或新配置。 +旧格式的正常快照继续可读;超预算或尺寸/控制数据畸形的快照拒绝,应用降级为无旧 +输出。无效宽字符标志仅从快照副本移除,不承诺修复终端核心的编辑行为。 + +## Validation + +`cargo test --offline --locked -p nebula_terminal --features serde` 全套通过。 +新测试在原解码器上失败(超限尾部被读取、孤立占位保留),并用真实解析器覆盖中文 +半字符删除/插入/擦除后在三种列宽下重排的正常快照不被改动。 + +## Supersedes + +None。 + +## Revisit when + +改变 wire 格式、快照资源上限、宽字符布局或主屏捕获边界时重新核验。 diff --git a/nebula_app/src/gpui_shell/workspace/session_recovery.rs b/nebula_app/src/gpui_shell/workspace/session_recovery.rs index 634bbbd4e..a529c7cc6 100644 --- a/nebula_app/src/gpui_shell/workspace/session_recovery.rs +++ b/nebula_app/src/gpui_shell/workspace/session_recovery.rs @@ -203,7 +203,6 @@ impl NebulaWorkspace { launch: Some(launch), layout: Some(layout), active_pane, - output_refs: Vec::new(), }); } Session::new(active_out, tabs) diff --git a/nebula_app/src/gpui_shell/workspace/tests.rs b/nebula_app/src/gpui_shell/workspace/tests.rs index 4f5d242f1..5d1769a92 100644 --- a/nebula_app/src/gpui_shell/workspace/tests.rs +++ b/nebula_app/src/gpui_shell/workspace/tests.rs @@ -914,7 +914,6 @@ 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/nebula_app/src/recent_output/storage/lifecycle.rs b/nebula_app/src/recent_output/storage/lifecycle.rs index b71c255ee..08b83dfd9 100644 --- a/nebula_app/src/recent_output/storage/lifecycle.rs +++ b/nebula_app/src/recent_output/storage/lifecycle.rs @@ -415,29 +415,18 @@ mod tests { fn invalidation_inside_publication_reports_durable_session_and_keeps_old_reference() { let (dir, path, store) = store_fixture(); let session_path = dir.path().join("session.json"); - let mut old_session = crate::session::Session::new( - 0, - vec![crate::session::TabSession::single("C:/test".into(), None, None)], - ); - old_session.tabs[0].output_refs = vec!["old".into()]; archive("old").write_to(&path).unwrap(); - crate::session::save_local_to(&session_path, &old_session).unwrap(); - - let mut new_session = old_session.clone(); - new_session.tabs[0].output_refs = vec!["new".into()]; + std::fs::write(&session_path, "old").unwrap(); let generation = store.next_generation(); let published = store .save_referenced(generation, &archive("new"), Some(&["old".into()]), || { - crate::session::save_local_to(&session_path, &new_session)?; + std::fs::write(&session_path, "new")?; store.next_generation(); Ok(()) }) .unwrap(); assert!(published, "a written session cannot be reported as cancelled"); - assert_eq!( - crate::session::load_local_from(&session_path).unwrap().tabs[0].output_refs, - ["new"] - ); + assert_eq!(std::fs::read_to_string(&session_path).unwrap(), "new"); let mut staged = Archive::read_from(&path).unwrap(); assert!(staged.take_records("old").is_some()); assert!(staged.take_records("new").is_some()); @@ -456,21 +445,38 @@ mod tests { ); assert!(!session_path.exists()); let before = std::fs::read(&path).unwrap(); - let session = crate::session::Session::new( - 0, - vec![crate::session::TabSession::single("C:/test".into(), None, None)], - ); assert!( store - .publish_without_output(generation, || { - crate::session::save_local_to(&session_path, &session) - }) + .publish_without_output(generation, || std::fs::write(&session_path, "no refs")) .unwrap() ); assert_eq!(std::fs::read(&path).unwrap(), before); - assert!( - crate::session::load_local_from(&session_path).unwrap().tabs[0].output_refs.is_empty() - ); + assert_eq!(std::fs::read_to_string(&session_path).unwrap(), "no refs"); + } + + #[test] + fn clear_queued_during_publication_runs_after_it_and_stays_cleared() { + let (_dir, path, ref store) = store_fixture(); + let old = store.next_generation(); + let (entered, resume) = (std::sync::Barrier::new(2), std::sync::Barrier::new(2)); + std::thread::scope(|scope| { + let first = scope.spawn(|| { + store.save_and_publish(old, &archive("old"), || { + entered.wait(); + resume.wait(); + Ok(()) + }) + }); + entered.wait(); + // The UI invalidates without taking the disk writer lock. + let clear = store.next_generation(); + let second = scope.spawn(move || store.clear(clear)); + resume.wait(); + assert!(first.join().unwrap().unwrap(), "published session is durable"); + assert!(second.join().unwrap().unwrap()); + }); + assert!(!path.exists()); + assert!(!store.save(old, &archive("old")).unwrap()); } #[test] diff --git a/nebula_app/src/session.rs b/nebula_app/src/session.rs index 0277ba610..e58b6f61e 100644 --- a/nebula_app/src/session.rs +++ b/nebula_app/src/session.rs @@ -21,7 +21,6 @@ use serde::{Deserialize, Serialize}; use crate::display::color::Rgb; mod identity; -mod local_output; mod window_layout; pub(crate) use identity::codex_rollout_id; pub use window_layout::WindowLayout; @@ -207,23 +206,12 @@ 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, - output_refs: Vec::new(), - } + Self { cwd, custom_name, color, launch: None, layout: None, active_pane: 0 } } } @@ -280,7 +268,7 @@ impl Session { /// `%APPDATA%\Nebula\session.json` (or the `.config` fallback), next to the /// settings and history files. -pub(crate) fn session_path() -> PathBuf { +fn session_path() -> PathBuf { crate::display::nebula_data_dir().join("session.json") } @@ -297,11 +285,7 @@ fn parse(data: &str) -> Option { /// Load the previous session, if any and version-compatible. pub fn load() -> Option { - load_local_from(&session_path()) -} - -pub(crate) fn load_local_from(path: &Path) -> Option { - local_output::parse(&std::fs::read_to_string(path).ok()?) + load_from(&session_path()) } /// An update must not replace an unreadable workspace with an empty snapshot. @@ -313,7 +297,7 @@ pub(crate) fn load_update_windows() -> std::io::Result> { }, Err(error) => return Err(error), }; - let session = local_output::parse(&data).ok_or_else(|| { + let session = parse(&data).ok_or_else(|| { std::io::Error::new(std::io::ErrorKind::InvalidData, "Invalid saved workspace") })?; session.into_update_windows() @@ -334,12 +318,8 @@ pub fn save(session: &Session) { } pub(crate) fn try_save(session: &Session) -> std::io::Result<()> { - 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()) + let json = serde_json::to_string(session).map_err(std::io::Error::other)?; + crate::atomic_file::write(&session_path(), json.as_bytes()) } /// Write a session as a named workspace file. Pretty-printed — workspace diff --git a/nebula_app/src/session/local_output.rs b/nebula_app/src/session/local_output.rs deleted file mode 100644 index d63b1f7ae..000000000 --- a/nebula_app/src/session/local_output.rs +++ /dev/null @@ -1,97 +0,0 @@ -//! 仅自动恢复文档携带输出引用;共享 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/nebula_app/src/window_context/session_snapshot.rs b/nebula_app/src/window_context/session_snapshot.rs index 19ce8a194..c449b39bc 100644 --- a/nebula_app/src/window_context/session_snapshot.rs +++ b/nebula_app/src/window_context/session_snapshot.rs @@ -77,7 +77,6 @@ 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/nebula_terminal/src/grid/snapshot.rs b/nebula_terminal/src/grid/snapshot.rs index d0f6bb7c6..db4792b46 100644 --- a/nebula_terminal/src/grid/snapshot.rs +++ b/nebula_terminal/src/grid/snapshot.rs @@ -2,13 +2,15 @@ use super::{Dimensions, Grid}; use crate::index::{Column, Line}; -use crate::term::cell::Cell; +use crate::term::cell::{Cell, Flags}; #[cfg(feature = "serde")] mod serialization; // 解码后的防灾上限;持久化层还须独立限制每条记录的编码字节数。 const MAX_SNAPSHOT_CELLS: usize = 262_144; +const WIDE_FLAGS: Flags = + Flags::WIDE_CHAR.union(Flags::WIDE_CHAR_SPACER).union(Flags::LEADING_WIDE_CHAR_SPACER); #[derive(Clone, Debug, Default)] pub struct DisplaySnapshot { @@ -24,7 +26,7 @@ impl DisplaySnapshot { let start = range.start.0.max(-(grid.history_size() as i32)); let start = start.max(end.saturating_sub((max_cells / columns).min(i32::MAX as usize) as i32)); - let rows = (start..end) + let rows: Vec> = (start..end) .map(|line| { (0..columns) .map(|column| { @@ -35,7 +37,39 @@ impl DisplaySnapshot { .collect() }) .collect(); - Self { columns, rows } + let mut snapshot = Self { columns, rows }; + snapshot.sanitize_wide_flags(); + snapshot + } + + /// 删半个宽字符等编辑或外部文件会留下孤立标志;只清理副本,不动活终端。 + fn sanitize_wide_flags(&mut self) { + for line in (0..self.rows.len()).rev() { + for column in (0..self.rows[line].len()).rev() { + let row = &self.rows[line]; + let is = |cell: Option<&Cell>, flags| { + cell.is_some_and(|cell| cell.flags & WIDE_FLAGS == flags) + }; + let valid = match row[column].flags & WIDE_FLAGS { + Flags::WIDE_CHAR => is(row.get(column + 1), Flags::WIDE_CHAR_SPACER), + Flags::WIDE_CHAR_SPACER => { + is(column.checked_sub(1).and_then(|c| row.get(c)), Flags::WIDE_CHAR) + }, + Flags::LEADING_WIDE_CHAR_SPACER => { + column + 1 == self.columns + && row[column].flags.contains(Flags::WRAPLINE) + && self + .rows + .get(line + 1) + .is_none_or(|next| is(next.first(), Flags::WIDE_CHAR)) + }, + flags => flags.is_empty(), + }; + if !valid { + self.rows[line][column].flags.remove(WIDE_FLAGS); + } + } + } } fn validate(&self) -> Result<(), &'static str> { @@ -95,21 +129,6 @@ 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); @@ -179,6 +198,53 @@ mod tests { assert!(serde_json::from_value::(value).is_err()); } + #[cfg(feature = "serde")] + #[test] + fn decoding_stops_at_budget_before_reading_malformed_tail() { + let one = DisplaySnapshot { columns: 1, rows: vec![vec![Cell::default()]] }; + let cell = serde_json::to_value(&one).unwrap()["rows"][0][0].to_string(); + let cell = cell.trim_end_matches('}'); + let chars = |n| "\"a\",".repeat(n); + let half = format!(r#"{cell},"combining":[{}"a"]}}"#, chars(131_071)); + for input in [ + format!(r#"{{"columns":1,"rows":[{}"bad"]}}"#, "[],".repeat(262_145)), + format!(r#"{{"columns":1,"rows":[[{}"bad"]]}}"#, format!("{cell}}},").repeat(262_145)), + format!(r#"{{"columns":1,"rows":[[{cell},"combining":[{}"bad"]}}]]}}"#, chars(262_145)), + format!(r#"{{"columns":3,"rows":[[{half},{half},{cell},"combining":["a"]}},"bad"]]}}"#), + ] { + let error = serde_json::from_str::(&input).unwrap_err(); + assert!(error.to_string().contains("decode budget"), "{error}"); + } + } + + #[cfg(feature = "serde")] + #[test] + fn strips_orphan_wide_flags_from_files_and_edited_screens() { + let flags = [Flags::WIDE_CHAR_SPACER, Flags::WIDE_CHAR | Flags::WIDE_CHAR_SPACER]; + let malformed = DisplaySnapshot { + columns: 2, + rows: vec![flags.map(|flags| Cell { flags, ..Cell::default() }).to_vec()], + }; + let decoded: DisplaySnapshot = + serde_json::from_value(serde_json::to_value(&malformed).unwrap()).unwrap(); + assert!(decoded.rows[0].iter().all(|cell| !cell.flags.intersects(WIDE_FLAGS))); + for edit in ["", "\x1b[1;6H\x1b[P", "\x1b[1;5H\x1b[@", "\x1b[1;6H\x1b[K"] { + for columns in [3, 5, 12] { + let mut source = Term::new(Config::default(), &TermSize::new(8, 3), VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut source, format!("abcd中文e\u{301}\r\n{edit}").as_bytes()); + source.resize(TermSize::new(columns, 3)); + let snapshot = DisplaySnapshot::capture(source.grid(), Line(-10)..Line(3), 100); + let mut copy = snapshot.clone(); + copy.sanitize_wide_flags(); + assert_eq!(format!("{copy:?}"), format!("{snapshot:?}"), "{edit:?} {columns}"); + let json = serde_json::to_value(&snapshot).unwrap(); + let rows_first = format!(r#"{{"rows":{},"columns":{columns}}}"#, json["rows"]); + serde_json::from_str::(&rows_first).unwrap(); + } + } + } + #[test] fn rejects_malformed_rows_before_changing_live_grid() { let mut target = Grid::::new(2, 4, 10); diff --git a/nebula_terminal/src/grid/snapshot/serialization.rs b/nebula_terminal/src/grid/snapshot/serialization.rs index 05039bbec..538890da6 100644 --- a/nebula_terminal/src/grid/snapshot/serialization.rs +++ b/nebula_terminal/src/grid/snapshot/serialization.rs @@ -1,8 +1,9 @@ //! 持久化只暴露显示字段;不沿用 Cell 的链接及未来协议字段。 +use serde::de::{DeserializeSeed, Error, SeqAccess, Visitor}; use serde::{Deserialize, Deserializer, Serialize, Serializer}; -use super::DisplaySnapshot; +use super::{DisplaySnapshot, MAX_SNAPSHOT_CELLS}; use crate::term::cell::{Cell, Flags}; use crate::vte::ansi::Color; @@ -13,7 +14,7 @@ struct DisplayCell { fg: Color, bg: Color, flags: Flags, - #[serde(default, skip_serializing_if = "Vec::is_empty")] + #[serde(default, deserialize_with = "decode_combining", skip_serializing_if = "Vec::is_empty")] combining: Vec, #[serde(default, skip_serializing_if = "Option::is_none")] underline: Option, @@ -23,9 +24,95 @@ struct DisplayCell { #[serde(deny_unknown_fields)] struct WireSnapshot { columns: usize, + #[serde(deserialize_with = "decode_rows")] rows: Vec>, } +// 解码中计数:字节上限挡不住 `[]` 空行等在内存中的放大。 +fn over() -> E { + E::custom("display snapshot exceeds decode budget") +} + +fn decode_combining<'de, D: Deserializer<'de>>(deserializer: D) -> Result, D::Error> { + struct Chars; + impl<'de> Visitor<'de> for Chars { + type Value = Vec; + + fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("combining characters") + } + + fn visit_seq>(self, mut seq: A) -> Result, A::Error> { + let mut chars = Vec::new(); + while let Some(c) = seq.next_element()? { + if chars.len() == MAX_SNAPSHOT_CELLS { + return Err(over()); + } + chars.push(c); + } + Ok(chars) + } + } + deserializer.deserialize_seq(Chars) +} + +struct Budget { + cells: usize, + combining: usize, +} + +impl<'de> DeserializeSeed<'de> for &mut Budget { + type Value = Vec; + + fn deserialize>(self, deserializer: D) -> Result { + deserializer.deserialize_seq(self) + } +} + +impl<'de> Visitor<'de> for &mut Budget { + type Value = Vec; + + fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("display row") + } + + fn visit_seq>(self, mut seq: A) -> Result { + let mut row = Vec::new(); + while let Some(cell) = seq.next_element::()? { + self.cells = self.cells.checked_sub(1).ok_or_else(over)?; + self.combining = self.combining.checked_sub(cell.combining.len()).ok_or_else(over)?; + row.push(cell); + } + Ok(row) + } +} + +fn decode_rows<'de, D: Deserializer<'de>>( + deserializer: D, +) -> Result>, D::Error> { + struct Rows; + impl<'de> Visitor<'de> for Rows { + type Value = Vec>; + + fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("display rows") + } + + fn visit_seq>(self, mut seq: A) -> Result { + let mut budget = Budget { cells: MAX_SNAPSHOT_CELLS, combining: MAX_SNAPSHOT_CELLS }; + let mut rows = Vec::new(); + while let Some(row) = seq.next_element_seed(&mut budget)? { + if rows.len() == MAX_SNAPSHOT_CELLS { + return Err(over()); + } + rows.push(row); + } + Ok(rows) + } + } + deserializer.deserialize_seq(Rows) +} + impl Serialize for DisplaySnapshot { fn serialize(&self, serializer: S) -> Result { WireSnapshot { @@ -54,7 +141,7 @@ impl Serialize for DisplaySnapshot { impl<'de> Deserialize<'de> for DisplaySnapshot { fn deserialize>(deserializer: D) -> Result { let wire = WireSnapshot::deserialize(deserializer)?; - let snapshot = Self { + let mut snapshot = Self { columns: wire.columns, rows: wire .rows @@ -79,7 +166,8 @@ impl<'de> Deserialize<'de> for DisplaySnapshot { }) .collect(), }; - snapshot.validate().map_err(serde::de::Error::custom)?; + snapshot.sanitize_wide_flags(); + snapshot.validate().map_err(Error::custom)?; Ok(snapshot) } } diff --git a/nebula_terminal/src/term/renderable.rs b/nebula_terminal/src/term/renderable.rs index 6f4f1ad59..30049ba37 100644 --- a/nebula_terminal/src/term/renderable.rs +++ b/nebula_terminal/src/term/renderable.rs @@ -1,6 +1,6 @@ //! Read-only terminal viewport assembled for the renderer. -use crate::grid::{Dimensions, Grid, GridIterator}; +use crate::grid::{Dimensions, GridIterator}; use crate::index::{Line, Point}; use crate::selection::SelectionRange; use crate::term::cell::{Cell, Flags}; @@ -8,13 +8,6 @@ use crate::term::color::Colors; use crate::term::{Term, TermMode}; use crate::vte::ansi::CursorShape; -impl Term { - /// 主屏显示数据;备用屏活动时仍保留普通命令的输出,不包含 TUI 内容。 - pub fn primary_grid(&self) -> &Grid { - if self.mode.contains(TermMode::ALT_SCREEN) { &self.inactive_grid } else { &self.grid } - } -} - /// Terminal cursor rendering information. #[derive(Copy, Clone, PartialEq, Eq)] pub struct RenderableCursor {