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..3b562ebb5 --- /dev/null +++ b/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md @@ -0,0 +1,64 @@ +# 静态输出快照与本机引用的持久化边界 + +## Status + +供审核的持久化基础;尚未接入命令采集、设置控件或窗口输出恢复。 +关联 #160,本阶段不代表完整功能已交付。 + +## Context + +终端显示、输出文件和布局会话的生命周期不同。多个 pane 可以处于同一目录, +因此目录不能作为旧输出归属。直接回放原始 VT 会再次执行控制动作; +把输出及引用放进共享工作区格式,又会让导出携带本机历史。 + +## Evidence + +- [显示快照与校验](../../../../nebula_terminal/src/grid/snapshot.rs)覆盖 Unicode 重排、容量和控制数据拒绝;备用屏活动时读取主屏由第二项随采集接入。 +- [有界输出存储](../../../../nebula_app/src/recent_output/storage.rs)复用原子文件写入。 +- [发布生命周期](../../../../nebula_app/src/recent_output/storage/lifecycle.rs)的回归测试覆盖两代交接、失败重试和发布回调内失效。 +- 本机会话引用(`session/local_output.rs`)随第二项的逐 pane 采集交付;本项存储测试以普通文件代替会话,只验证发布回调的提交语义。 + +## Decision + +terminal 层仅捕获和恢复主屏的静态显示字段,恢复到历史区,不重放 VT, +不改活终端屏幕或光标。反序列化与恢复先校验结构、容量和控制数据。 + +app 层以独立 sidecar 保存有界记录,每 pane 最多五条,每条最多 256 KiB。 +正常归档最多 16 MiB,两代原子交接最多 32 MiB;超量先裁剪旧记录再生成引用。 +精确引用只属于本机自动恢复文档,共享工作区的导入和导出不携带这些引用。 + +先持久化输出,再发布会话引用,发布成功前保留旧引用可读取的那一代。 +发布失败恢复旧归档;成功后才能回收旧代。回调成功意味着会话已经落盘, +即使回调内代次失效,也必须报告真实的持久化结果并保留交接数据。 +后续接入者负责通过同一串行边界提交新的 checkpoint;无引用 checkpoint +不能等同清除全部旧历史,显式清除使用独立操作。 + +## Rejected alternatives + +- 回放原始 VT:会重放控制动作,无法保证只恢复显示。 +- 按 cwd 匹配:同目录多 pane 无法确定归属。 +- 在共享会话中嵌入输出或本机引用:扩大导出范围和载入成本。 +- 发布引用前覆盖旧代:中断后旧会话可能引用已丢失的数据。 +- 发布成功后仅凭代次变化返回未提交:内存结果会与实际磁盘状态矛盾。 + +## Consequences + +存储和终端边界可各自验证,后续采集及窗口接入复用同一规则。 +本阶段不会自动记录命令或恢复终端输出,也不新增用户设置。 +调用方须在后台执行磁盘操作,并承担持久化完成后的生命周期收尾。 + +## Validation + +Windows 上实际运行:存储 24 项、会话相关 105 项、启动恢复 1 项通过; +`cargo test --locked -p nebula_terminal --features serde` 的 352 项通过, +包含使用现有打包资产执行的 ConPTY 生命周期测试。 +应用测试启用 `gpui-test-support`;仅关闭应用测试目标的调试符号,断言不变。 +这些结果验证本阶段边界,不作为尚未接入的窗口输出恢复验收。 + +## Supersedes + +None。 + +## Revisit when + +需要改变容量、引用身份、原子交接协议,或允许跨设备导出输出时重新审核。 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/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/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/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/terminal/view.rs b/nebula_app/src/gpui_shell/terminal/view.rs index eddb5c6f1..3de9c3702 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`,裁定理由见那里。 @@ -538,6 +545,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 { @@ -746,11 +754,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(); @@ -886,6 +897,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; @@ -935,6 +947,7 @@ impl TerminalView { term.reset_cursor_style_override(); } } + self.set_recent_output_enabled(command_output_enabled); self.restart_cursor_blink(cx); cx.notify(); } @@ -1196,6 +1209,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.rs b/nebula_app/src/gpui_shell/workspace.rs index 680c59bd1..b9c25e7b5 100644 --- a/nebula_app/src/gpui_shell/workspace.rs +++ b/nebula_app/src/gpui_shell/workspace.rs @@ -1560,15 +1560,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, @@ -1709,14 +1700,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/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 a529c7cc6..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 层)。 @@ -203,6 +259,7 @@ 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/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/tests.rs b/nebula_app/src/gpui_shell/workspace/tests.rs index 5d1769a92..4f5d242f1 100644 --- a/nebula_app/src/gpui_shell/workspace/tests.rs +++ b/nebula_app/src/gpui_shell/workspace/tests.rs @@ -914,6 +914,7 @@ mod boot_breaker_tests { launch: Some(launch), }), active_pane: 0, + output_refs: Vec::new(), }; // 第三次启动:磁盘上的计数已被 `mark_boot_attempt` 抬到 2。 let mut session = crate::session::Session::new(0, vec![tab]); diff --git a/nebula_app/src/gpui_shell/workspace/windowing.rs b/nebula_app/src/gpui_shell/workspace/windowing.rs index 4aa0234f9..39d38b783 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}; mod startup_geometry; pub(super) use startup_geometry::prepare_initial_grid; @@ -139,6 +143,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, @@ -205,6 +210,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, @@ -216,19 +222,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 { @@ -244,9 +257,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); } } @@ -1110,6 +1121,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| { @@ -1390,10 +1416,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 @@ -1445,27 +1471,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); @@ -1531,17 +1536,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(); diff --git a/nebula_app/src/main.rs b/nebula_app/src/main.rs index 94b4aa02d..bd31ae522 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..3de7d9fe5 --- /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; + + pub(super) 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..95f69c495 --- /dev/null +++ b/nebula_app/src/recent_output/storage.rs @@ -0,0 +1,239 @@ +//! 本机 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, tests::Size}; + use nebula_terminal::event::VoidListener; + use nebula_terminal::term::{Config, Term}; + use nebula_terminal::vte::ansi; + + 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..08b83dfd9 --- /dev/null +++ b/nebula_app/src/recent_output/storage/lifecycle.rs @@ -0,0 +1,494 @@ +//! 后台串行文件操作;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) + } + + /// Once publish succeeds, report a committed session even if invalidated inside + /// the callback; the next serialized checkpoint reconciles the new generation. + pub(crate) fn save_referenced( + &self, + generation: u64, + archive: &Archive, + references: Option<&[String]>, + publish: 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); + } + // A successful callback has already published the session on disk. A later + // generation may schedule a follow-up, but cannot undo that publication. + // Keep both generations until the follow-up has finished. + // 新快照先校验,绝不因为旧文件损坏而接受无效的新内容。 + 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()).map(|()| false); + } + 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 generation == self.inner.generation.load(Ordering::SeqCst) { + if let Err(error) = archive.write_to(&self.inner.path) { + log::warn!("Could not prune previous command output: {error}"); + } + } + Ok(true) + } + + /// Publish a reference-free session without treating a settings toggle as clear. + pub(crate) fn publish_without_output( + &self, + generation: u64, + publish: 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); + } + publish()?; + Ok(true) + } + + 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 store_fixture() -> (tempfile::TempDir, PathBuf, OutputStore) { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let store = OutputStore::new(path.clone()); + (dir, path, store) + } + + 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, path, store) = store_fixture(); + std::fs::write(&path, b"{broken archive").unwrap(); + 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, path, store) = store_fixture(); + 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); + 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, path, store) = store_fixture(); + let mut interrupted = archive("next"); + interrupted.previous = Some(Box::new(archive("previous"))); + interrupted.write_to(&path).unwrap(); + 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, path, store) = store_fixture(); + let mut interrupted = archive("next"); + interrupted.previous = Some(Box::new(archive("previous"))); + interrupted.write_to(&path).unwrap(); + 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, path, store) = store_fixture(); + 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, path, store) = store_fixture(); + 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, path, store) = store_fixture(); + 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, path, store) = store_fixture(); + 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, path, store) = store_fixture(); + 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, path, store) = store_fixture(); + 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_is_acknowledged_before_later_clear() { + let (_dir, path, store) = store_fixture(); + 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 invalidation_inside_publication_reports_durable_session_and_keeps_old_reference() { + let (dir, path, store) = store_fixture(); + let session_path = dir.path().join("session.json"); + archive("old").write_to(&path).unwrap(); + std::fs::write(&session_path, "old").unwrap(); + let generation = store.next_generation(); + let published = store + .save_referenced(generation, &archive("new"), Some(&["old".into()]), || { + std::fs::write(&session_path, "new")?; + store.next_generation(); + Ok(()) + }) + .unwrap(); + assert!(published, "a written session cannot be reported as cancelled"); + 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()); + } + + #[test] + fn reference_free_checkpoint_preserves_old_archive_on_failure_and_retry() { + let (dir, path, store) = store_fixture(); + let session_path = dir.path().join("session.json"); + archive("old").write_to(&path).unwrap(); + let generation = store.next_generation(); + assert!( + store + .publish_without_output(generation, || Err(io::Error::other("session unavailable"))) + .is_err() + ); + assert!(!session_path.exists()); + let before = std::fs::read(&path).unwrap(); + assert!( + store + .publish_without_output(generation, || std::fs::write(&session_path, "no refs")) + .unwrap() + ); + assert_eq!(std::fs::read(&path).unwrap(), before); + 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] + fn failed_save_preserves_previous_archive_and_allows_retry() { + let (_dir, path, store) = store_fixture(); + 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 e58b6f61e..0277ba610 100644 --- a/nebula_app/src/session.rs +++ b/nebula_app/src/session.rs @@ -21,6 +21,7 @@ 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; @@ -206,12 +207,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(), + } } } @@ -268,7 +280,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") } @@ -285,7 +297,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. @@ -297,7 +313,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() @@ -318,8 +334,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 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", 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..99c848c9e --- /dev/null +++ b/nebula_terminal/src/grid/snapshot.rs @@ -0,0 +1,350 @@ +//! 安全显示数据快照:不保存终端协议、链接动作或运行状态。 + +use super::{Dimensions, Grid}; +use crate::index::{Column, Line}; +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 { + 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: Vec> = (start..end) + .map(|line| { + (0..columns) + .map(|column| { + let mut cell = grid[Line(line)][Column(column)].clone(); + cell.set_hyperlink(None); + cell + }) + .collect() + }) + .collect(); + 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> { + 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 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); + 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()); + } + + #[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); + 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..538890da6 --- /dev/null +++ b/nebula_terminal/src/grid/snapshot/serialization.rs @@ -0,0 +1,173 @@ +//! 持久化只暴露显示字段;不沿用 Cell 的链接及未来协议字段。 + +use serde::de::{DeserializeSeed, Error, SeqAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +use super::{DisplaySnapshot, MAX_SNAPSHOT_CELLS}; +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, deserialize_with = "decode_combining", 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, + #[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 { + 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 mut 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.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 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 {